diff --git a/kmymoney/converter/mymoneystatementreader.cpp b/kmymoney/converter/mymoneystatementreader.cpp
index dabe008f4..89b38482c 100644
--- a/kmymoney/converter/mymoneystatementreader.cpp
+++ b/kmymoney/converter/mymoneystatementreader.cpp
@@ -1,1579 +1,1578 @@
 /***************************************************************************
                           mymoneystatementreader.cpp
                              -------------------
     begin                : Mon Aug 30 2004
     copyright            : (C) 2000-2004 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 "mymoneystatementreader.h"
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Headers
 
 #include <QStringList>
 #include <QLabel>
 #include <QList>
 #include <QVBoxLayout>
 #include <QDialog>
 #include <QDialogButtonBox>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <KMessageBox>
 #include <KConfig>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Headers
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyprice.h"
 #include "mymoneyexception.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneypayee.h"
 #include "mymoneystatement.h"
 #include "mymoneysecurity.h"
 #include "kmymoneysettings.h"
 #include "transactioneditor.h"
 #include "stdtransactioneditor.h"
 #include "kmymoneyedit.h"
 #include "kaccountselectdlg.h"
 #include "knewaccountwizard.h"
 #include "transactionmatcher.h"
 #include "kenterscheduledlg.h"
 #include "kmymoneyaccountcombo.h"
 #include "accountsmodel.h"
 #include "models.h"
 #include "existingtransactionmatchfinder.h"
 #include "scheduledtransactionmatchfinder.h"
 #include "dialogenums.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 #include "kmymoneyutils.h"
 
 using namespace eMyMoney;
 
 bool matchNotEmpty(const QString &l, const QString &r)
 {
   return !l.isEmpty() && QString::compare(l, r, Qt::CaseInsensitive) == 0;
 }
 
 class MyMoneyStatementReader::Private
 {
 public:
   Private() :
       transactionsCount(0),
       transactionsAdded(0),
       transactionsMatched(0),
       transactionsDuplicate(0),
       m_skipCategoryMatching(true),
       m_progressCallback(nullptr),
       scannedCategories(false) {}
 
   const QString& feeId(const MyMoneyAccount& invAcc);
   const QString& interestId(const MyMoneyAccount& invAcc);
   QString interestId(const QString& name);
   QString expenseId(const QString& name);
   QString feeId(const QString& name);
   void assignUniqueBankID(MyMoneySplit& s, const MyMoneyStatement::Transaction& t_in);
   void setupPrice(MyMoneySplit &s, const MyMoneyAccount &splitAccount, const MyMoneyAccount &transactionAccount, const QDate &postDate);
 
   MyMoneyAccount                 lastAccount;
   MyMoneyAccount                 m_account;
   MyMoneyAccount                 m_brokerageAccount;
   QList<MyMoneyTransaction> transactions;
   QList<MyMoneyPayee>       payees;
   int                            transactionsCount;
   int                            transactionsAdded;
   int                            transactionsMatched;
   int                            transactionsDuplicate;
   QMap<QString, bool>            uniqIds;
   QMap<QString, MyMoneySecurity> securitiesBySymbol;
   QMap<QString, MyMoneySecurity> securitiesByName;
   bool                           m_skipCategoryMatching;
   void (*m_progressCallback)(int, int, const QString&);
 private:
   void scanCategories(QString& id, const MyMoneyAccount& invAcc, const MyMoneyAccount& parentAccount, const QString& defaultName);
   /**
    * This method tries to figure out the category to be used for fees and interest
    * from previous transactions in the given @a investmentAccount and returns the
    * ids of those categories in @a feesId and @a interestId. The last used category
    * will be returned.
    */
   void previouslyUsedCategories(const QString& investmentAccount, QString& feesId, QString& interestId);
 
   QString nameToId(const QString&name, MyMoneyAccount& parent);
 
 private:
   QString                        m_feeId;
   QString                        m_interestId;
   bool                           scannedCategories;
 };
 
 
 const QString& MyMoneyStatementReader::Private::feeId(const MyMoneyAccount& invAcc)
 {
   scanCategories(m_feeId, invAcc, MyMoneyFile::instance()->expense(), i18n("_Fees"));
   return m_feeId;
 }
 
 const QString& MyMoneyStatementReader::Private::interestId(const MyMoneyAccount& invAcc)
 {
   scanCategories(m_interestId, invAcc, MyMoneyFile::instance()->income(), i18n("_Dividend"));
   return m_interestId;
 }
 
 QString MyMoneyStatementReader::Private::nameToId(const QString& name, MyMoneyAccount& parent)
 {
   //  Adapted from KMyMoneyApp::createAccount(MyMoneyAccount& newAccount, MyMoneyAccount& parentAccount, MyMoneyAccount& brokerageAccount, MyMoneyMoney openingBal)
   //  Needed to find/create category:sub-categories
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QString id = file->categoryToAccount(name, Account::Type::Unknown);
   // if it does not exist, we have to create it
   if (id.isEmpty()) {
     MyMoneyAccount newAccount;
     MyMoneyAccount parentAccount = parent;
     newAccount.setName(name) ;
     int pos;
     // check for ':' in the name and use it as separator for a hierarchy
     while ((pos = newAccount.name().indexOf(MyMoneyFile::AccountSeparator)) != -1) {
       QString part = newAccount.name().left(pos);
       QString remainder = newAccount.name().mid(pos + 1);
       const MyMoneyAccount& existingAccount = file->subAccountByName(parentAccount, part);
       if (existingAccount.id().isEmpty()) {
         newAccount.setName(part);
         newAccount.setAccountType(parentAccount.accountType());
         file->addAccount(newAccount, parentAccount);
         parentAccount = newAccount;
       } else {
         parentAccount = existingAccount;
       }
       newAccount.setParentAccountId(QString());  // make sure, there's no parent
       newAccount.clearId();                       // and no id set for adding
       newAccount.removeAccountIds();              // and no sub-account ids
       newAccount.setName(remainder);
     }//end while
     newAccount.setAccountType(parentAccount.accountType());
 
     // make sure we have a currency. If none is assigned, we assume base currency
     if (newAccount.currencyId().isEmpty())
       newAccount.setCurrencyId(file->baseCurrency().id());
 
     file->addAccount(newAccount, parentAccount);
     id = newAccount.id();
   }
   return id;
 }
 
 QString MyMoneyStatementReader::Private::expenseId(const QString& name)
 {
   MyMoneyAccount parent = MyMoneyFile::instance()->expense();
   return nameToId(name, parent);
 }
 
 QString MyMoneyStatementReader::Private::interestId(const QString& name)
 {
   MyMoneyAccount parent = MyMoneyFile::instance()->income();
   return nameToId(name, parent);
 }
 
 QString MyMoneyStatementReader::Private::feeId(const QString& name)
 {
   MyMoneyAccount parent = MyMoneyFile::instance()->expense();
   return nameToId(name, parent);
 }
 
 void MyMoneyStatementReader::Private::previouslyUsedCategories(const QString& investmentAccount, QString& feesId, QString& interestId)
 {
   feesId.clear();
   interestId.clear();
   MyMoneyFile* file = MyMoneyFile::instance();
   try {
     MyMoneyAccount acc = file->account(investmentAccount);
     MyMoneyTransactionFilter filter(investmentAccount);
     filter.setReportAllSplits(false);
     // since we assume an investment account here, we need to collect the stock accounts as well
     filter.addAccount(acc.accountList());
     QList< QPair<MyMoneyTransaction, MyMoneySplit> > list;
     file->transactionList(list, filter);
     QList< QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it_t;
     for (it_t = list.constBegin(); it_t != list.constEnd(); ++it_t) {
       const MyMoneyTransaction& t = (*it_t).first;
       MyMoneySplit s = (*it_t).second;
 
       acc = file->account(s.accountId());
       // stock split shouldn't be fee or interest bacause it won't play nice with dissectTransaction
       // it was caused by processTransactionEntry adding splits in wrong order != with manual transaction entering
       if (acc.accountGroup() == Account::Type::Expense || acc.accountGroup() == Account::Type::Income) {
         foreach (auto sNew , t.splits()) {
           acc = file->account(sNew.accountId());
           if (acc.accountGroup() != Account::Type::Expense && // shouldn't be fee
               acc.accountGroup() != Account::Type::Income &&  // shouldn't be interest
               (sNew.value() != sNew.shares() ||                 // shouldn't be checking account...
               (sNew.value() == sNew.shares() && sNew.price() != MyMoneyMoney::ONE))) { // ...but sometimes it may look like checking account
             s = sNew;
             break;
           }
         }
       }
 
       MyMoneySplit assetAccountSplit;
       QList<MyMoneySplit> feeSplits;
       QList<MyMoneySplit> interestSplits;
       MyMoneySecurity security;
       MyMoneySecurity currency;
       eMyMoney::Split::InvestmentTransactionType transactionType;
       KMyMoneyUtils::dissectTransaction(t, s, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
       if (!feeSplits.isEmpty()) {
         feesId = feeSplits.first().accountId();
         if (!interestId.isEmpty())
           break;
       }
       if (!interestSplits.isEmpty()) {
         interestId = interestSplits.first().accountId();
         if (!feesId.isEmpty())
           break;
       }
     }
   } catch (const MyMoneyException &) {
   }
 
 }
 
 void MyMoneyStatementReader::Private::scanCategories(QString& id, const MyMoneyAccount& invAcc, const MyMoneyAccount& parentAccount, const QString& defaultName)
 {
   if (!scannedCategories) {
     previouslyUsedCategories(invAcc.id(), m_feeId, m_interestId);
     scannedCategories = true;
   }
 
   if (id.isEmpty()) {
     MyMoneyFile* file = MyMoneyFile::instance();
     MyMoneyAccount acc = file->accountByName(defaultName);
     // if it does not exist, we have to create it
     if (acc.id().isEmpty()) {
       MyMoneyAccount parent = parentAccount;
       acc.setName(defaultName);
       acc.setAccountType(parent.accountType());
       acc.setCurrencyId(parent.currencyId());
       file->addAccount(acc, parent);
     }
     id = acc.id();
   }
 }
 
 void MyMoneyStatementReader::Private::assignUniqueBankID(MyMoneySplit& s, const MyMoneyStatement::Transaction& t_in)
 {
   if (! t_in.m_strBankID.isEmpty()) {
     // make sure that id's are unique from this point on by appending a -#
     // postfix if needed
     QString base(t_in.m_strBankID);
     QString hash(base);
     int idx = 1;
     for (;;) {
       QMap<QString, bool>::const_iterator it;
       it = uniqIds.constFind(hash);
       if (it == uniqIds.constEnd()) {
         uniqIds[hash] = true;
         break;
       }
       hash = QString("%1-%2").arg(base).arg(idx);
       ++idx;
     }
 
     s.setBankID(hash);
   }
 }
 
 void MyMoneyStatementReader::Private::setupPrice(MyMoneySplit &s, const MyMoneyAccount &splitAccount, const MyMoneyAccount &transactionAccount, const QDate &postDate)
 {
   if (transactionAccount.currencyId() != splitAccount.currencyId()) {
     // a currency converstion is needed assume that split has already a proper value
     MyMoneyFile* file = MyMoneyFile::instance();
     MyMoneySecurity toCurrency = file->security(splitAccount.currencyId());
     MyMoneySecurity fromCurrency = file->security(transactionAccount.currencyId());
     // get the price for the transaction's date
     const MyMoneyPrice &price = file->price(fromCurrency.id(), toCurrency.id(), postDate);
     // if the price is valid calculate the shares
     if (price.isValid()) {
       const int fract = splitAccount.fraction(toCurrency);
       const MyMoneyMoney &shares = s.value() * price.rate(toCurrency.id());
       s.setShares(shares.convert(fract));
       qDebug("Setting second split shares to %s", qPrintable(s.shares().formatMoney(toCurrency.id(), 2)));
     } else {
       qDebug("No price entry was found to convert from '%s' to '%s' on '%s'",
              qPrintable(fromCurrency.tradingSymbol()), qPrintable(toCurrency.tradingSymbol()), qPrintable(postDate.toString(Qt::ISODate)));
     }
   }
 }
 
 MyMoneyStatementReader::MyMoneyStatementReader() :
     d(new Private),
     m_userAbort(false),
     m_autoCreatePayee(false),
     m_ft(0),
     m_progressCallback(0)
 {
   m_askPayeeCategory = KMyMoneySettings::askForPayeeCategory();
 }
 
 MyMoneyStatementReader::~MyMoneyStatementReader()
 {
   delete d;
 }
 
 bool MyMoneyStatementReader::anyTransactionAdded() const
 {
   return (d->transactionsAdded != 0) ? true : false;
 }
 
 void MyMoneyStatementReader::setAutoCreatePayee(bool create)
 {
   m_autoCreatePayee = create;
 }
 
 void MyMoneyStatementReader::setAskPayeeCategory(bool ask)
 {
   m_askPayeeCategory = ask;
 }
 
 QStringList MyMoneyStatementReader::importStatement(const QString& url, bool silent, void(*callback)(int, int, const QString&))
 {
   QStringList summary;
   MyMoneyStatement s;
   if (MyMoneyStatement::readXMLFile(s, url))
     summary = MyMoneyStatementReader::importStatement(s, silent, callback);
   else
     KMessageBox::error(nullptr, i18n("Error importing %1: This file is not a valid KMM statement file.", url), i18n("Invalid Statement"));
 
   return summary;
 }
 
 QStringList MyMoneyStatementReader::importStatement(const MyMoneyStatement& s, bool silent, void(*callback)(int, int, const QString&))
 {
   auto result = false;
 
   // keep a copy of the statement
   if (KMyMoneySettings::logImportedStatements()) {
     auto logFile = QString::fromLatin1("%1/kmm-statement-%2.txt").arg(KMyMoneySettings::logPath(),
                                                                       QDateTime::currentDateTimeUtc().toString(QStringLiteral("yyyy-MM-dd hh-mm-ss")));
     MyMoneyStatement::writeXMLFile(s, logFile);
  }
 
   // we use an object on the heap here, so that we can check the presence
   // of it during slotUpdateActions() by looking at the pointer.
   auto reader = new MyMoneyStatementReader;
   reader->setAutoCreatePayee(true);
   if (callback)
     reader->setProgressCallback(callback);
 
   // disable all standard widgets during the import
 //  setEnabled(false);
 
   QStringList messages;
   result = reader->import(s, messages);
 
   auto transactionAdded = reader->anyTransactionAdded();
 
   // get rid of the statement reader and tell everyone else
   // about the destruction by setting the pointer to zero
   delete reader;
 
   if (callback)
     callback(-1, -1, QString());
 
   // re-enable all standard widgets
 //  setEnabled(true);
 
   if (!silent && transactionAdded)
     KMessageBox::informationList(nullptr,
                                  i18n("The statement has been processed with the following results:"), messages, i18n("Statement stats"));
   if (!result)
     messages.clear();
   return messages;
 }
 
 bool MyMoneyStatementReader::import(const MyMoneyStatement& s, QStringList& messages)
 {
   //
   // For testing, save the statement to an XML file
   // (uncomment this line)
   //
   //MyMoneyStatement::writeXMLFile(s, "Imported.Xml");
 
   //
   // Select the account
   //
 
   d->m_account = MyMoneyAccount();
   d->m_brokerageAccount = MyMoneyAccount();
 
   m_ft = new MyMoneyFileTransaction();
   d->m_skipCategoryMatching = s.m_skipCategoryMatching;
 
   // if the statement source left some information about
   // the account, we use it to get the current data of it
   if (!s.m_accountId.isEmpty()) {
     try {
       d->m_account = MyMoneyFile::instance()->account(s.m_accountId);
     } catch (const MyMoneyException &) {
       qDebug("Received reference '%s' to unknown account in statement", qPrintable(s.m_accountId));
     }
   }
 
   if (d->m_account.id().isEmpty()) {
     d->m_account.setName(s.m_strAccountName);
     d->m_account.setNumber(s.m_strAccountNumber);
 
     switch (s.m_eType) {
       case eMyMoney::Statement::Type::Checkings:
         d->m_account.setAccountType(Account::Type::Checkings);
         break;
       case eMyMoney::Statement::Type::Savings:
         d->m_account.setAccountType(Account::Type::Savings);
         break;
       case eMyMoney::Statement::Type::Investment:
         //testing support for investment statements!
         //m_userAbort = true;
         //KMessageBox::error(kmymoney, i18n("This is an investment statement.  These are not supported currently."), i18n("Critical Error"));
         d->m_account.setAccountType(Account::Type::Investment);
         break;
       case eMyMoney::Statement::Type::CreditCard:
         d->m_account.setAccountType(Account::Type::CreditCard);
         break;
       default:
         d->m_account.setAccountType(Account::Type::Unknown);
         break;
     }
 
 
     // we ask the user only if we have some transactions to process
     if (!m_userAbort && s.m_listTransactions.count() > 0)
       m_userAbort = ! selectOrCreateAccount(Select, d->m_account);
   }
 
   // see if we need to update some values stored with the account
   if (d->m_account.value("lastStatementBalance") != s.m_closingBalance.toString()
       || d->m_account.value("lastImportedTransactionDate") != s.m_dateEnd.toString(Qt::ISODate)) {
     if (s.m_closingBalance != MyMoneyMoney::autoCalc) {
       d->m_account.setValue("lastStatementBalance", s.m_closingBalance.toString());
       if (s.m_dateEnd.isValid()) {
         d->m_account.setValue("lastImportedTransactionDate", s.m_dateEnd.toString(Qt::ISODate));
       }
     }
 
     try {
       MyMoneyFile::instance()->modifyAccount(d->m_account);
     } catch (const MyMoneyException &) {
       qDebug("Updating account in MyMoneyStatementReader::startImport failed");
     }
   }
 
 
   if (!d->m_account.name().isEmpty())
     messages += i18n("Importing statement for account %1", d->m_account.name());
   else if (s.m_listTransactions.count() == 0)
     messages += i18n("Importing statement without transactions");
 
   qDebug("Importing statement for '%s'", qPrintable(d->m_account.name()));
 
   //
   // Process the securities
   //
   signalProgress(0, s.m_listSecurities.count(), "Importing Statement ...");
   int progress = 0;
   QList<MyMoneyStatement::Security>::const_iterator it_s = s.m_listSecurities.begin();
   while (it_s != s.m_listSecurities.end()) {
     processSecurityEntry(*it_s);
     signalProgress(++progress, 0);
     ++it_s;
   }
   signalProgress(-1, -1);
 
   //
   // Process the transactions
   //
 
   if (!m_userAbort) {
     try {
       qDebug("Processing transactions (%s)", qPrintable(d->m_account.name()));
       signalProgress(0, s.m_listTransactions.count(), "Importing Statement ...");
       progress = 0;
       QList<MyMoneyStatement::Transaction>::const_iterator it_t = s.m_listTransactions.begin();
       while (it_t != s.m_listTransactions.end() && !m_userAbort) {
         processTransactionEntry(*it_t);
         signalProgress(++progress, 0);
         ++it_t;
       }
       qDebug("Processing transactions done (%s)", qPrintable(d->m_account.name()));
 
     } catch (const MyMoneyException &e) {
-      if (e.what() == "USERABORT")
+      if (QString::fromLatin1(e.what()).contains("USERABORT"))
         m_userAbort = true;
       else
-        qDebug("Caught exception from processTransactionEntry() not caused by USERABORT: %s", qPrintable(e.what()));
+        qDebug("Caught exception from processTransactionEntry() not caused by USERABORT: %s", e.what());
     }
     signalProgress(-1, -1);
   }
 
   //
   // process price entries
   //
   if (!m_userAbort) {
     try {
       signalProgress(0, s.m_listPrices.count(), "Importing Statement ...");
       KMyMoneyUtils::processPriceList(s);
     } catch (const MyMoneyException &e) {
-      if (e.what() == "USERABORT")
+      if (QString::fromLatin1(e.what()).contains("USERABORT"))
         m_userAbort = true;
       else
-        qDebug("Caught exception from processPriceEntry() not caused by USERABORT: %s", qPrintable(e.what()));
+        qDebug("Caught exception from processPriceEntry() not caused by USERABORT: %s", e.what());
     }
     signalProgress(-1, -1);
   }
 
   bool  rc = false;
 
   // delete all payees created in vain
   int payeeCount = d->payees.count();
   QList<MyMoneyPayee>::const_iterator it_p;
   for (it_p = d->payees.constBegin(); it_p != d->payees.constEnd(); ++it_p) {
     try {
       MyMoneyFile::instance()->removePayee(*it_p);
       --payeeCount;
     } catch (const MyMoneyException &) {
       // if we can't delete it, it must be in use which is ok for us
     }
   }
 
   if (s.m_closingBalance.isAutoCalc()) {
     messages += i18n("  Statement balance is not contained in statement.");
   } else {
     messages += i18n("  Statement balance on %1 is reported to be %2", s.m_dateEnd.toString(Qt::ISODate), s.m_closingBalance.formatMoney("", 2));
   }
   messages += i18n("  Transactions");
   messages += i18np("    %1 processed", "    %1 processed", d->transactionsCount);
   messages += i18ncp("x transactions have been added", "    %1 added", "    %1 added", d->transactionsAdded);
   messages += i18np("    %1 matched", "    %1 matched", d->transactionsMatched);
   messages += i18np("    %1 duplicate", "    %1 duplicates", d->transactionsDuplicate);
   messages += i18n("  Payees");
   messages += i18ncp("x transactions have been created", "    %1 created", "    %1 created", payeeCount);
   messages += QString();
 
   // remove the Don't ask again entries
   KSharedConfigPtr config = KSharedConfig::openConfig();
   KConfigGroup grp = config->group(QString::fromLatin1("Notification Messages"));
   QStringList::ConstIterator it;
 
   for (it = m_dontAskAgain.constBegin(); it != m_dontAskAgain.constEnd(); ++it) {
     grp.deleteEntry(*it);
   }
   config->sync();
   m_dontAskAgain.clear();
 
   rc = !m_userAbort;
 
   // finish the transaction
   if (rc)
     m_ft->commit();
   delete m_ft;
   m_ft = 0;
 
   qDebug("Importing statement for '%s' done", qPrintable(d->m_account.name()));
 
   return rc;
 }
 
 void MyMoneyStatementReader::processSecurityEntry(const MyMoneyStatement::Security& sec_in)
 {
   // For a security entry, we will just make sure the security exists in the
   // file. It will not get added to the investment account until it's called
   // for in a transaction.
   MyMoneyFile* file = MyMoneyFile::instance();
 
   // check if we already have the security
   // In a statement, we do not know what type of security this is, so we will
   // not use type as a matching factor.
   MyMoneySecurity security;
   QList<MyMoneySecurity> list = file->securityList();
   QList<MyMoneySecurity>::ConstIterator it = list.constBegin();
   while (it != list.constEnd() && security.id().isEmpty()) {
     if (matchNotEmpty(sec_in.m_strSymbol, (*it).tradingSymbol()) ||
         matchNotEmpty(sec_in.m_strName, (*it).name())) {
       security = *it;
     }
     ++it;
   }
 
   // if the security was not found, we have to create it while not forgetting
   // to setup the type
   if (security.id().isEmpty()) {
     security.setName(sec_in.m_strName);
     security.setTradingSymbol(sec_in.m_strSymbol);
     security.setTradingCurrency(file->baseCurrency().id());
     security.setValue("kmm-security-id", sec_in.m_strId);
     security.setValue("kmm-online-source", "Stooq");
     security.setSecurityType(Security::Type::Stock);
     MyMoneyFileTransaction ft;
     try {
       file->addSecurity(security);
       ft.commit();
       qDebug() << "Created " << security.name() << " with id " << security.id();
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(0, i18n("Error creating security record: %1", e.what()), i18n("Error"));
+      KMessageBox::error(0, i18n("Error creating security record: %1", QString::fromLatin1(e.what())), i18n("Error"));
     }
   } else {
     qDebug() << "Found " << security.name() << " with id " << security.id();
   }
 }
 
 void MyMoneyStatementReader::processTransactionEntry(const MyMoneyStatement::Transaction& statementTransactionUnderImport)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   MyMoneyTransaction transactionUnderImport;
 
   QString dbgMsg;
   dbgMsg = QString("Process on: '%1', id: '%3', amount: '%2', fees: '%4'")
            .arg(statementTransactionUnderImport.m_datePosted.toString(Qt::ISODate))
            .arg(statementTransactionUnderImport.m_amount.formatMoney("", 2))
            .arg(statementTransactionUnderImport.m_strBankID)
            .arg(statementTransactionUnderImport.m_fees.formatMoney("", 2));
   qDebug("%s", qPrintable(dbgMsg));
 
   // mark it imported for the view
   transactionUnderImport.setImported();
 
   // TODO (Ace) We can get the commodity from the statement!!
   // Although then we would need UI to verify
   transactionUnderImport.setCommodity(d->m_account.currencyId());
 
   transactionUnderImport.setPostDate(statementTransactionUnderImport.m_datePosted);
   transactionUnderImport.setMemo(statementTransactionUnderImport.m_strMemo);
 
   MyMoneySplit s1;
   MyMoneySplit s2;
   MyMoneySplit sFees;
   MyMoneySplit sBrokerage;
 
   s1.setMemo(statementTransactionUnderImport.m_strMemo);
   s1.setValue(statementTransactionUnderImport.m_amount + statementTransactionUnderImport.m_fees);
   s1.setShares(s1.value());
   s1.setNumber(statementTransactionUnderImport.m_strNumber);
 
   // set these values if a transfer split is needed at the very end.
   MyMoneyMoney transfervalue;
 
   // If the user has chosen to import into an investment account, determine the correct account to use
   MyMoneyAccount thisaccount = d->m_account;
   QString brokerageactid;
 
   if (thisaccount.accountType() == Account::Type::Investment) {
     // determine the brokerage account
     brokerageactid = d->m_account.value("kmm-brokerage-account").toUtf8();
     if (brokerageactid.isEmpty()) {
       brokerageactid = file->accountByName(statementTransactionUnderImport.m_strBrokerageAccount).id();
     }
     if (brokerageactid.isEmpty()) {
       brokerageactid = file->nameToAccount(statementTransactionUnderImport.m_strBrokerageAccount);
     }
     if (brokerageactid.isEmpty()) {
       brokerageactid = file->nameToAccount(thisaccount.brokerageName());
     }
     if (brokerageactid.isEmpty()) {
       brokerageactid = SelectBrokerageAccount();
     }
 
     // find the security transacted, UNLESS this transaction didn't
     // involve any security.
     if ((statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::None)
         //  eaInterest transactions MAY have a security.
         //  && (t_in.m_eAction != MyMoneyStatement::Transaction::eaInterest)
         && (statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::Fees)) {
       // the correct account is the stock account which matches two criteria:
       // (1) it is a sub-account of the selected investment account, and
       // (2a) the symbol of the underlying security matches the security of the
       // transaction, or
       // (2b) the name of the security matches the name of the security of the transaction.
 
       // search through each subordinate account
       auto found = false;
       QString currencyid;
       foreach (const auto sAccount, thisaccount.accountList()) {
         currencyid = file->account(sAccount).currencyId();
         auto security = file->security(currencyid);
         if (matchNotEmpty(statementTransactionUnderImport.m_strSymbol, security.tradingSymbol()) ||
             matchNotEmpty(statementTransactionUnderImport.m_strSecurity, security.name())) {
           thisaccount = file->account(sAccount);
           found = true;
           break;
         }
       }
 
       // If there was no stock account under the m_acccount investment account,
       // add one using the security.
       if (!found) {
         // The security should always be available, because the statement file
         // should separately list all the securities referred to in the file,
         // and when we found a security, we added it to the file.
 
         if (statementTransactionUnderImport.m_strSecurity.isEmpty()) {
           KMessageBox::information(0, i18n("This imported statement contains investment transactions with no security.  These transactions will be ignored."), i18n("Security not found"), QString("BlankSecurity"));
           return;
         } else {
           MyMoneySecurity security;
           QList<MyMoneySecurity> list = MyMoneyFile::instance()->securityList();
           QList<MyMoneySecurity>::ConstIterator it = list.constBegin();
           while (it != list.constEnd() && security.id().isEmpty()) {
             if (matchNotEmpty(statementTransactionUnderImport.m_strSymbol, (*it).tradingSymbol()) ||
                 matchNotEmpty(statementTransactionUnderImport.m_strSecurity, (*it).name())) {
               security = *it;
             }
             ++it;
           }
           if (!security.id().isEmpty()) {
             thisaccount = MyMoneyAccount();
             thisaccount.setName(security.name());
             thisaccount.setAccountType(Account::Type::Stock);
             thisaccount.setCurrencyId(security.id());
             currencyid = thisaccount.currencyId();
 
             file->addAccount(thisaccount, d->m_account);
             qDebug() << Q_FUNC_INFO << ": created account " << thisaccount.id() << " for security " << statementTransactionUnderImport.m_strSecurity << " under account " << d->m_account.id();
           }
           // this security does not exist in the file.
           else {
             // This should be rare.  A statement should have a security entry for any
             // of the securities referred to in the transactions.  The only way to get
             // here is if that's NOT the case.
             int ret = KMessageBox::warningContinueCancel(0, i18n("<center>This investment account does not contain the \"%1\" security.</center>"
                       "<center>Transactions involving this security will be ignored.</center>", statementTransactionUnderImport.m_strSecurity),
                       i18n("Security not found"), KStandardGuiItem::cont(), KStandardGuiItem::cancel());
             if (ret == KMessageBox::Cancel) {
               m_userAbort = true;
             }
             return;
           }
         }
       }
       // Don't update price if there is no price information contained in the transaction
       if (statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::CashDividend
           && statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::Shrsin
           && statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::Shrsout) {
         // update the price, while we're here.  in the future, this should be
         // an option
         QString basecurrencyid = file->baseCurrency().id();
         const MyMoneyPrice &price = file->price(currencyid, basecurrencyid, statementTransactionUnderImport.m_datePosted, true);
         if (!price.isValid()  && ((!statementTransactionUnderImport.m_amount.isZero() && !statementTransactionUnderImport.m_shares.isZero()) || !statementTransactionUnderImport.m_price.isZero())) {
           MyMoneyPrice newprice;
           if (!statementTransactionUnderImport.m_price.isZero()) {
             newprice = MyMoneyPrice(currencyid, basecurrencyid, statementTransactionUnderImport.m_datePosted,
                                     statementTransactionUnderImport.m_price.abs(), i18n("Statement Importer"));
           } else {
             newprice = MyMoneyPrice(currencyid, basecurrencyid, statementTransactionUnderImport.m_datePosted,
                                     (statementTransactionUnderImport.m_amount / statementTransactionUnderImport.m_shares).abs(), i18n("Statement Importer"));
           }
           file->addPrice(newprice);
         }
       }
     }
     s1.setAccountId(thisaccount.id());
     d->assignUniqueBankID(s1, statementTransactionUnderImport);
 
     if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::ReinvestDividend) {
       s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend));
       s1.setShares(statementTransactionUnderImport.m_shares);
 
       if (!statementTransactionUnderImport.m_price.isZero()) {
         s1.setPrice(statementTransactionUnderImport.m_price);
       } else {
         if (statementTransactionUnderImport.m_shares.isZero()) {
           KMessageBox::information(0, i18n("This imported statement contains investment transactions with no share amount.  These transactions will be ignored."), i18n("No share amount provided"), QString("BlankAmount"));
           return;
         }
         MyMoneyMoney total = -statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees;
         s1.setPrice(MyMoneyMoney((total / statementTransactionUnderImport.m_shares).convertPrecision(file->security(thisaccount.currencyId()).pricePrecision())));
       }
 
       s2.setMemo(statementTransactionUnderImport.m_strMemo);
       if (statementTransactionUnderImport.m_strInterestCategory.isEmpty())
         s2.setAccountId(d->interestId(thisaccount));
       else
         s2.setAccountId(d->interestId(statementTransactionUnderImport.m_strInterestCategory));
 
       s2.setShares(-statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees);
       s2.setValue(s2.shares());
     } else if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::CashDividend) {
       // Cash dividends require setting 2 splits to get all of the information
       // in.  Split #1 will be the income split, and we'll set it to the first
       // income account.  This is a hack, but it's needed in order to get the
       // amount into the transaction.
 
       if (statementTransactionUnderImport.m_strInterestCategory.isEmpty())
         s1.setAccountId(d->interestId(thisaccount));
       else {//  Ensure category sub-accounts are dealt with properly
         s1.setAccountId(d->interestId(statementTransactionUnderImport.m_strInterestCategory));
       }
       s1.setShares(-statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees);
       s1.setValue(-statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees);
 
       // Split 2 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.
       s2.setMemo(statementTransactionUnderImport.m_strMemo);
       s2.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend));
       s2.setAccountId(thisaccount.id());
 
       /*  at this point any fees have been taken into account already
        *  so don't deduct them again.
        *  BUG 322381
        */
       transfervalue = statementTransactionUnderImport.m_amount;
     } else if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Interest) {
       if (statementTransactionUnderImport.m_strInterestCategory.isEmpty())
         s1.setAccountId(d->interestId(thisaccount));
       else {//  Ensure category sub-accounts are dealt with properly
         if (statementTransactionUnderImport.m_amount.isPositive())
           s1.setAccountId(d->interestId(statementTransactionUnderImport.m_strInterestCategory));
         else
           s1.setAccountId(d->expenseId(statementTransactionUnderImport.m_strInterestCategory));
       }
       s1.setShares(-statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees);
       s1.setValue(-statementTransactionUnderImport.m_amount - statementTransactionUnderImport.m_fees);
 
 /// ***********   Add split as per Div       **********
       // Split 2 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.
       s2.setMemo(statementTransactionUnderImport.m_strMemo);
       s2.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::InterestIncome));
       s2.setAccountId(thisaccount.id());
       transfervalue = statementTransactionUnderImport.m_amount;
 
     } else if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Fees) {
       if (statementTransactionUnderImport.m_strInterestCategory.isEmpty())
         s1.setAccountId(d->feeId(thisaccount));
       else//  Ensure category sub-accounts are dealt with properly
         s1.setAccountId(d->feeId(statementTransactionUnderImport.m_strInterestCategory));
       s1.setShares(statementTransactionUnderImport.m_amount);
       s1.setValue(statementTransactionUnderImport.m_amount);
 
       transfervalue = statementTransactionUnderImport.m_amount;
 
       } else if ((statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Buy) ||
                  (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Sell)) {
       s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares));
       if (!statementTransactionUnderImport.m_price.isZero())  {
         s1.setPrice(statementTransactionUnderImport.m_price.abs());
       } else if (!statementTransactionUnderImport.m_shares.isZero()) {
         MyMoneyMoney total = statementTransactionUnderImport.m_amount + statementTransactionUnderImport.m_fees.abs();
         s1.setPrice(MyMoneyMoney((total / statementTransactionUnderImport.m_shares).abs().convertPrecision(file->security(thisaccount.currencyId()).pricePrecision())));
       }
       if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Buy)
           s1.setShares(statementTransactionUnderImport.m_shares.abs());
       else
           s1.setShares(-statementTransactionUnderImport.m_shares.abs());
       s1.setValue(-(statementTransactionUnderImport.m_amount + statementTransactionUnderImport.m_fees.abs()));
       transfervalue = statementTransactionUnderImport.m_amount;
 
     } else if ((statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Shrsin) ||
                (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::Shrsout)) {
       s1.setValue(MyMoneyMoney());
       s1.setShares(statementTransactionUnderImport.m_shares);
       s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::AddShares));
     } else if (statementTransactionUnderImport.m_eAction == eMyMoney::Transaction::Action::None) {
       // User is attempting to import a non-investment transaction into this
       // investment account.  This is not supportable the way KMyMoney is
       // written.  However, if a user has an associated brokerage account,
       // we can stuff the transaction there.
 
       brokerageactid = d->m_account.value("kmm-brokerage-account").toUtf8();
       if (brokerageactid.isEmpty()) {
         brokerageactid = file->accountByName(d->m_account.brokerageName()).id();
       }
       if (! brokerageactid.isEmpty()) {
         s1.setAccountId(brokerageactid);
         d->assignUniqueBankID(s1, statementTransactionUnderImport);
 
         // Needed to satisfy the bankid check below.
         thisaccount = file->account(brokerageactid);
       } else {
         // Warning!! Your transaction is being thrown away.
       }
     }
     if (!statementTransactionUnderImport.m_fees.isZero()) {
       sFees.setMemo(i18n("(Fees) %1", statementTransactionUnderImport.m_strMemo));
       sFees.setValue(statementTransactionUnderImport.m_fees);
       sFees.setShares(statementTransactionUnderImport.m_fees);
       sFees.setAccountId(d->feeId(thisaccount));
     }
   } else {
     // For non-investment accounts, just use the selected account
     // Note that it is perfectly reasonable to import an investment statement into a non-investment account
     // if you really want.  The investment-specific information, such as number of shares and action will
     // be discarded in that case.
     s1.setAccountId(d->m_account.id());
     d->assignUniqueBankID(s1, statementTransactionUnderImport);
   }
 
 
   QString payeename = statementTransactionUnderImport.m_strPayee;
   if (!payeename.isEmpty()) {
     qDebug() << QLatin1String("Start matching payee") << payeename;
     QString payeeid;
     try {
       QList<MyMoneyPayee> pList = file->payeeList();
       QList<MyMoneyPayee>::const_iterator it_p;
       QMap<int, QString> matchMap;
       for (it_p = pList.constBegin(); it_p != pList.constEnd(); ++it_p) {
         bool ignoreCase;
         QStringList keys;
         QStringList::const_iterator it_s;
         const MyMoneyPayee::payeeMatchType matchType = (*it_p).matchData(ignoreCase, keys);
         switch (matchType) {
           case MyMoneyPayee::matchDisabled:
             break;
 
           case MyMoneyPayee::matchName:
           case MyMoneyPayee::matchNameExact:
             keys << QString("%1").arg(QRegExp::escape((*it_p).name()));
             if(matchType == MyMoneyPayee::matchNameExact) {
               keys.clear();
               keys << QString("^%1$").arg(QRegExp::escape((*it_p).name()));
             }
             // intentional fall through
 
           case MyMoneyPayee::matchKey:
             for (it_s = keys.constBegin(); it_s != keys.constEnd(); ++it_s) {
               QRegExp exp(*it_s, ignoreCase ? Qt::CaseInsensitive : Qt::CaseSensitive);
               if (exp.indexIn(payeename) != -1) {
                 qDebug("Found match with '%s' on '%s'", qPrintable(payeename), qPrintable((*it_p).name()));
                 matchMap[exp.matchedLength()] = (*it_p).id();
               }
             }
             break;
         }
       }
 
       // at this point we can have several scenarios:
       // a) multiple matches
       // b) a single match
       // c) no match at all
       //
       // for c) we just do nothing, for b) we take the one we found
       // in case of a) we take the one with the largest matchedLength()
       // which happens to be the last one in the map
       if (matchMap.count() > 1) {
         qDebug("Multiple matches");
         QMap<int, QString>::const_iterator it_m = matchMap.constEnd();
         --it_m;
         payeeid = *it_m;
       } else if (matchMap.count() == 1) {
         qDebug("Single matches");
         payeeid = *(matchMap.constBegin());
       }
 
       // if we did not find a matching payee, we throw an exception and try to create it
       if (payeeid.isEmpty())
-        throw MYMONEYEXCEPTION("payee not matched");
+        throw MYMONEYEXCEPTION_CSTRING("payee not matched");
 
       s1.setPayeeId(payeeid);
     } catch (const MyMoneyException &) {
       MyMoneyPayee payee;
       int rc = KMessageBox::Yes;
 
       if (m_autoCreatePayee == false) {
         // Ask the user if that is what he intended to do?
         QString msg = i18n("Do you want to add \"%1\" as payee/receiver?\n\n", payeename);
         msg += i18n("Selecting \"Yes\" will create the payee, \"No\" will skip "
                     "creation of a payee record and remove the payee information "
                     "from this transaction. Selecting \"Cancel\" aborts the import "
                     "operation.\n\nIf you select \"No\" here and mark the \"Do not ask "
                     "again\" checkbox, the payee information for all following transactions "
                     "referencing \"%1\" will be removed.", payeename);
 
         QString askKey = QString("Statement-Import-Payee-") + payeename;
         if (!m_dontAskAgain.contains(askKey)) {
           m_dontAskAgain += askKey;
         }
         rc = KMessageBox::questionYesNoCancel(0, msg, i18n("New payee/receiver"),
                                               KStandardGuiItem::yes(), KStandardGuiItem::no(), KStandardGuiItem::cancel(), askKey);
       }
 
       if (rc == KMessageBox::Yes) {
         // for now, we just add the payee to the pool and turn
         // on simple name matching, so that future transactions
         // with the same name don't get here again.
         //
         // In the future, we could open a dialog and ask for
         // all the other attributes of the payee, but since this
         // is called in the context of an automatic procedure it
         // might distract the user.
         payee.setName(payeename);
         payee.setMatchData(MyMoneyPayee::matchKey, true, QStringList() << QString("^%1$").arg(QRegExp::escape(payeename)));
         if (m_askPayeeCategory) {
           // We use a QPointer because the dialog may get deleted
           // during exec() if the parent of the dialog gets deleted.
           // In that case the guarded ptr will reset to 0.
           QPointer<QDialog> dialog = new QDialog;
           dialog->setWindowTitle(i18n("Default Category for Payee"));
           dialog->setModal(true);
 
           QWidget *mainWidget = new QWidget;
           QVBoxLayout *topcontents = new QVBoxLayout(mainWidget);
 
           //add in caption? and account combo here
           QLabel *label1 = new QLabel(i18n("Please select a default category for payee '%1'", payeename));
           topcontents->addWidget(label1);
 
           auto filterProxyModel = new AccountNamesFilterProxyModel(this);
           filterProxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
           filterProxyModel->addAccountGroup(QVector<Account::Type> {Account::Type::Asset, Account::Type::Liability, Account::Type::Equity, Account::Type::Income, Account::Type::Expense});
 
           auto const model = Models::instance()->accountsModel();
           filterProxyModel->setSourceModel(model);
           filterProxyModel->setSourceColumns(model->getColumns());
           filterProxyModel->sort((int)eAccountsModel::Column::Account);
 
           QPointer<KMyMoneyAccountCombo> accountCombo = new KMyMoneyAccountCombo(filterProxyModel);
           topcontents->addWidget(accountCombo);
           mainWidget->setLayout(topcontents);
           QVBoxLayout *mainLayout = new QVBoxLayout;
 
           QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Cancel|QDialogButtonBox::No|QDialogButtonBox::Yes);
           dialog->setLayout(mainLayout);
           mainLayout->addWidget(mainWidget);
           dialog->connect(buttonBox, SIGNAL(accepted()), dialog, SLOT(accept()));
           dialog->connect(buttonBox, SIGNAL(rejected()), dialog, SLOT(reject()));
           mainLayout->addWidget(buttonBox);
           KGuiItem::assign(buttonBox->button(QDialogButtonBox::Yes), KGuiItem(i18n("Save Category")));
           KGuiItem::assign(buttonBox->button(QDialogButtonBox::No), KGuiItem(i18n("No Category")));
           KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), KGuiItem(i18n("Abort")));
 
           int result = dialog->exec();
 
           QString accountId;
           if (accountCombo && !accountCombo->getSelected().isEmpty()) {
             accountId = accountCombo->getSelected();
           }
           delete dialog;
           //if they hit yes instead of no, then grab setting of account combo
           if (result == QDialog::Accepted) {
             payee.setDefaultAccountId(accountId);
           } else if (result != QDialog::Rejected) {
             //add cancel button? and throw exception like below
-            throw MYMONEYEXCEPTION("USERABORT");
+            throw MYMONEYEXCEPTION_CSTRING("USERABORT");
           }
         }
 
         try {
           file->addPayee(payee);
           qDebug("Payee '%s' created", qPrintable(payee.name()));
           d->payees << payee;
           payeeid = payee.id();
           s1.setPayeeId(payeeid);
 
         } catch (const MyMoneyException &e) {
-          KMessageBox::detailedSorry(0, i18n("Unable to add payee/receiver"),
-                                     i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+          KMessageBox::detailedSorry(nullptr, i18n("Unable to add payee/receiver"), QString::fromLatin1(e.what()));
 
         }
 
       } else if (rc == KMessageBox::No) {
         s1.setPayeeId(QString());
 
       } else {
-        throw MYMONEYEXCEPTION("USERABORT");
+        throw MYMONEYEXCEPTION_CSTRING("USERABORT");
 
       }
     }
 
     if (thisaccount.accountType() != Account::Type::Stock) {
       //
       // Fill in other side of the transaction (category/etc) based on payee
       //
       // Note, this logic is lifted from KLedgerView::slotPayeeChanged(),
       // however this case is more complicated, because we have an amount and
       // a memo.  We just don't have the other side of the transaction.
       //
       // We'll search for the most recent transaction in this account with
       // this payee.  If this reference transaction is a simple 2-split
       // transaction, it's simple.  If it's a complex split, and the amounts
       // are different, we have a problem.  Somehow we have to balance the
       // transaction.  For now, we'll leave it unbalanced, and let the user
       // handle it.
       //
       const MyMoneyPayee& payeeObj = MyMoneyFile::instance()->payee(payeeid);
       if (statementTransactionUnderImport.m_listSplits.isEmpty() && payeeObj.defaultAccountEnabled()) {
         MyMoneyAccount splitAccount = file->account(payeeObj.defaultAccountId());
         MyMoneySplit s;
         s.setReconcileFlag(eMyMoney::Split::State::Cleared);
         s.clearId();
         s.setBankID(QString());
         s.setShares(-s1.shares());
         s.setValue(-s1.value());
         s.setAccountId(payeeObj.defaultAccountId());
         s.setMemo(transactionUnderImport.memo());
         s.setPayeeId(payeeid);
         d->setupPrice(s, splitAccount, d->m_account, statementTransactionUnderImport.m_datePosted);
         transactionUnderImport.addSplit(s);
         file->addVATSplit(transactionUnderImport, d->m_account, splitAccount, statementTransactionUnderImport.m_amount);
       } else if (statementTransactionUnderImport.m_listSplits.isEmpty() && !d->m_skipCategoryMatching) {
         MyMoneyTransactionFilter filter(thisaccount.id());
         filter.addPayee(payeeid);
         QList<MyMoneyTransaction> list = file->transactionList(filter);
         if (!list.empty()) {
           // Default to using the most recent transaction as the reference
           MyMoneyTransaction t_old = list.last();
 
           // if there is more than one matching transaction, try to be a little
           // smart about which one we take.  for now, we'll see if there's one
           // with the same VALUE as our imported transaction, and if so take that one.
           if (list.count() > 1) {
             QList<MyMoneyTransaction>::ConstIterator it_trans = list.constEnd();
             if (it_trans != list.constBegin())
               --it_trans;
             while (it_trans != list.constBegin()) {
               MyMoneySplit s = (*it_trans).splitByAccount(thisaccount.id());
               if (s.value() == s1.value()) {
                 // keep searching if this transaction references a closed account
                 if (!MyMoneyFile::instance()->referencesClosedAccount(*it_trans)) {
                   t_old = *it_trans;
                   break;
                 }
               }
               --it_trans;
             }
             // check constBegin, just in case
             if (it_trans == list.constBegin()) {
               MyMoneySplit s = (*it_trans).splitByAccount(thisaccount.id());
               if (s.value() == s1.value()) {
                 t_old = *it_trans;
               }
             }
           }
 
           // Only copy the splits if the transaction found does not reference a closed account
           if (!MyMoneyFile::instance()->referencesClosedAccount(t_old)) {
             foreach (const auto split, t_old.splits()) {
               // We don't need the split that covers this account,
               // we just need the other ones.
               if (split.accountId() != thisaccount.id()) {
                 MyMoneySplit s(split);
                 s.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
                 s.clearId();
                 s.setBankID(QString());
                 s.removeMatch();
 
                 if (t_old.splits().count() == 2) {
                   s.setShares(-s1.shares());
                   s.setValue(-s1.value());
                   s.setMemo(s1.memo());
                 }
                 MyMoneyAccount splitAccount = file->account(s.accountId());
                 qDebug("Adding second split to %s(%s)",
                        qPrintable(splitAccount.name()),
                        qPrintable(s.accountId()));
                 d->setupPrice(s, splitAccount, d->m_account, statementTransactionUnderImport.m_datePosted);
                 transactionUnderImport.addSplit(s);
               }
             }
           }
         }
       }
     }
   }
 
   s1.setReconcileFlag(statementTransactionUnderImport.m_reconcile);
 
   // Add the 'account' split if it's needed
   if (! transfervalue.isZero()) {
     // in case the transaction has a reference to the brokerage account, we use it
     // but if brokerageactid has already been set, keep that.
     if (!statementTransactionUnderImport.m_strBrokerageAccount.isEmpty() && brokerageactid.isEmpty()) {
       brokerageactid = file->nameToAccount(statementTransactionUnderImport.m_strBrokerageAccount);
     }
     if (brokerageactid.isEmpty()) {
       brokerageactid = file->accountByName(statementTransactionUnderImport.m_strBrokerageAccount).id();
     }
 //  There is no BrokerageAccount so have to nowhere to put this split.
     if (!brokerageactid.isEmpty()) {
       sBrokerage.setMemo(statementTransactionUnderImport.m_strMemo);
       sBrokerage.setValue(transfervalue);
       sBrokerage.setShares(transfervalue);
       sBrokerage.setAccountId(brokerageactid);
       sBrokerage.setReconcileFlag(statementTransactionUnderImport.m_reconcile);
       MyMoneyAccount splitAccount = file->account(sBrokerage.accountId());
       d->setupPrice(sBrokerage, splitAccount, d->m_account, statementTransactionUnderImport.m_datePosted);
     }
   }
 
   if (!(sBrokerage == MyMoneySplit()))
     transactionUnderImport.addSplit(sBrokerage);
 
   if (!(sFees == MyMoneySplit()))
     transactionUnderImport.addSplit(sFees);
 
   if (!(s2 == MyMoneySplit()))
     transactionUnderImport.addSplit(s2);
 
   transactionUnderImport.addSplit(s1);
 
   if ((statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::ReinvestDividend) && (statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::CashDividend) && (statementTransactionUnderImport.m_eAction != eMyMoney::Transaction::Action::Interest)
      ) {
     //******************************************
     //                   process splits
     //******************************************
 
     QList<MyMoneyStatement::Split>::const_iterator it_s;
     for (it_s = statementTransactionUnderImport.m_listSplits.begin(); it_s != statementTransactionUnderImport.m_listSplits.end(); ++it_s) {
       MyMoneySplit s3;
       s3.setAccountId((*it_s).m_accountId);
       MyMoneyAccount acc = file->account(s3.accountId());
       s3.setPayeeId(s1.payeeId());
       s3.setMemo((*it_s).m_strMemo);
       s3.setShares((*it_s).m_amount);
       s3.setValue((*it_s).m_amount);
       s3.setReconcileFlag((*it_s).m_reconcile);
       d->setupPrice(s3, acc, d->m_account, statementTransactionUnderImport.m_datePosted);
       transactionUnderImport.addSplit(s3);
     }
   }
 
   // Add the transaction
   try {
     // check for matches already stored in the engine
     TransactionMatchFinder::MatchResult result;
     TransactionMatcher matcher(thisaccount);
     d->transactionsCount++;
 
     ExistingTransactionMatchFinder existingTrMatchFinder(KMyMoneySettings::matchInterval());
     result = existingTrMatchFinder.findMatch(transactionUnderImport, s1);
     if (result != TransactionMatchFinder::MatchNotFound) {
       MyMoneyTransaction matchedTransaction = existingTrMatchFinder.getMatchedTransaction();
       if (result == TransactionMatchFinder::MatchDuplicate
       || !matchedTransaction.isImported()
       || result == TransactionMatchFinder::MatchPrecise) { // don't match with just imported transaction
         MyMoneySplit matchedSplit = existingTrMatchFinder.getMatchedSplit();
         handleMatchingOfExistingTransaction(matcher, matchedTransaction, matchedSplit, transactionUnderImport, s1, result);
         return;
       }
     }
 
     addTransaction(transactionUnderImport);
     ScheduledTransactionMatchFinder scheduledTrMatchFinder(thisaccount, KMyMoneySettings::matchInterval());
     result = scheduledTrMatchFinder.findMatch(transactionUnderImport, s1);
     if (result != TransactionMatchFinder::MatchNotFound) {
       MyMoneySplit matchedSplit = scheduledTrMatchFinder.getMatchedSplit();
       MyMoneySchedule matchedSchedule = scheduledTrMatchFinder.getMatchedSchedule();
 
       handleMatchingOfScheduledTransaction(matcher, matchedSchedule, matchedSplit, transactionUnderImport, s1);
       return;
     }
 
   } catch (const MyMoneyException &e) {
     QString message(i18n("Problem adding or matching imported transaction with id '%1': %2", statementTransactionUnderImport.m_strBankID, e.what()));
     qDebug("%s", qPrintable(message));
 
     int result = KMessageBox::warningContinueCancel(0, message);
     if (result == KMessageBox::Cancel)
-      throw MYMONEYEXCEPTION("USERABORT");
+      throw MYMONEYEXCEPTION_CSTRING("USERABORT");
   }
 }
 
 QString MyMoneyStatementReader::SelectBrokerageAccount()
 {
   if (d->m_brokerageAccount.id().isEmpty()) {
     d->m_brokerageAccount.setAccountType(Account::Type::Checkings);
     if (!m_userAbort)
       m_userAbort = ! selectOrCreateAccount(Select, d->m_brokerageAccount);
   }
   return d->m_brokerageAccount.id();
 }
 
 bool MyMoneyStatementReader::selectOrCreateAccount(const SelectCreateMode /*mode*/, MyMoneyAccount& account)
 {
   bool result = false;
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QString accountId;
 
   // Try to find an existing account in the engine which matches this one.
   // There are two ways to be a "matching account".  The account number can
   // match the statement account OR the "StatementKey" property can match.
   // Either way, we'll update the "StatementKey" property for next time.
 
   QString accountNumber = account.number();
   if (! accountNumber.isEmpty()) {
     // Get a list of all accounts
     QList<MyMoneyAccount> accounts;
     file->accountList(accounts);
 
     // Iterate through them
     QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
     while (it_account != accounts.constEnd()) {
       if (
         ((*it_account).value("StatementKey") == accountNumber) ||
         ((*it_account).number() == accountNumber)
       ) {
         MyMoneyAccount newAccount((*it_account).id(), account);
         account = newAccount;
         accountId = (*it_account).id();
         break;
       }
 
       ++it_account;
     }
   }
 
   QString msg = i18n("<b>You have downloaded a statement for the following account:</b><br/><br/>");
   msg += i18n(" - Account Name: %1", account.name()) + "<br/>";
   msg += i18n(" - Account Type: %1", MyMoneyAccount::accountTypeToString(account.accountType())) + "<br/>";
   msg += i18n(" - Account Number: %1", account.number()) + "<br/>";
   msg += "<br/>";
 
   if (!account.name().isEmpty()) {
     if (!accountId.isEmpty())
       msg += i18n("Do you want to import transactions to this account?");
     else
       msg += i18n("KMyMoney cannot determine which of your accounts to use.  You can "
                   "create a new account by pressing the <b>Create</b> button "
                   "or select another one manually from the selection box below.");
   } else {
     msg += i18n("No account information has been found in the selected statement file. "
                 "Please select an account using the selection box in the dialog or "
                 "create a new account by pressing the <b>Create</b> button.");
   }
 
   eDialogs::Category type;
   if (account.accountType() == Account::Type::Checkings) {
     type = eDialogs::Category::checking;
   } else if (account.accountType() == Account::Type::Savings) {
     type = eDialogs::Category::savings;
   } else if (account.accountType() == Account::Type::Investment) {
     type = eDialogs::Category::investment;
   } else if (account.accountType() == Account::Type::CreditCard) {
     type = eDialogs::Category::creditCard;
   } else {
     type = static_cast<eDialogs::Category>(eDialogs::Category::asset | eDialogs::Category::liability);
   }
 
   QPointer<KAccountSelectDlg> accountSelect = new KAccountSelectDlg(type, "StatementImport", 0);
   connect(accountSelect, &KAccountSelectDlg::createAccount, this, &MyMoneyStatementReader::slotNewAccount);
 
   accountSelect->setHeader(i18n("Import transactions"));
   accountSelect->setDescription(msg);
   accountSelect->setAccount(account, accountId);
   accountSelect->setMode(false);
   accountSelect->showAbortButton(true);
   accountSelect->hideQifEntry();
   QString accname;
   bool done = false;
   while (!done) {
     if (accountSelect->exec() == QDialog::Accepted && !accountSelect->selectedAccount().isEmpty()) {
       result = true;
       done = true;
       accountId = accountSelect->selectedAccount();
       account = file->account(accountId);
       if (! accountNumber.isEmpty() && account.value("StatementKey") != accountNumber) {
         account.setValue("StatementKey", accountNumber);
         MyMoneyFileTransaction ft;
         try {
           MyMoneyFile::instance()->modifyAccount(account);
           ft.commit();
           accname = account.name();
         } catch (const MyMoneyException &) {
           qDebug("Updating account in MyMoneyStatementReader::selectOrCreateAccount failed");
         }
       }
     } else {
       if (accountSelect->aborted())
-        //throw MYMONEYEXCEPTION("USERABORT");
+        //throw MYMONEYEXCEPTION_CSTRING("USERABORT");
         done = true;
       else
         KMessageBox::error(0, QLatin1String("<html>") + i18n("You must select an account, create a new one, or press the <b>Abort</b> button.") + QLatin1String("</html>"));
     }
   }
   delete accountSelect;
 
   return result;
 }
 
 const MyMoneyAccount& MyMoneyStatementReader::account() const {
   return d->m_account;
 }
 
 void MyMoneyStatementReader::setProgressCallback(void(*callback)(int, int, const QString&))
 {
   m_progressCallback = callback;
 }
 
 void MyMoneyStatementReader::signalProgress(int current, int total, const QString& msg)
 {
   if (m_progressCallback != 0)
     (*m_progressCallback)(current, total, msg);
 }
 
 void MyMoneyStatementReader::handleMatchingOfExistingTransaction(TransactionMatcher & matcher,
     MyMoneyTransaction matchedTransaction,
     MyMoneySplit matchedSplit,
     MyMoneyTransaction & importedTransaction,
     const MyMoneySplit & importedSplit,
     const TransactionMatchFinder::MatchResult & matchResult)
 {
   switch (matchResult) {
     case TransactionMatchFinder::MatchNotFound:
       break;
     case TransactionMatchFinder::MatchDuplicate:
       d->transactionsDuplicate++;
       qDebug("Detected transaction duplicate");
       break;
     case TransactionMatchFinder::MatchImprecise:
     case TransactionMatchFinder::MatchPrecise:
       addTransaction(importedTransaction);
       qDebug("Detected as match to transaction '%s'", qPrintable(matchedTransaction.id()));
       matcher.match(matchedTransaction, matchedSplit, importedTransaction, importedSplit, true);
       d->transactionsMatched++;
       break;
   }
 }
 
 void MyMoneyStatementReader::handleMatchingOfScheduledTransaction(TransactionMatcher & matcher,
     MyMoneySchedule matchedSchedule,
     MyMoneySplit matchedSplit,
     const MyMoneyTransaction & importedTransaction,
     const MyMoneySplit & importedSplit)
 {
   QPointer<TransactionEditor> editor;
 
   if (askUserToEnterScheduleForMatching(matchedSchedule, importedSplit, importedTransaction)) {
     KEnterScheduleDlg dlg(0, matchedSchedule);
     editor = dlg.startEdit();
     if (editor) {
 
       MyMoneyTransaction torig;
       try {
         // in case the amounts of the scheduled transaction and the
         // imported transaction differ, we need to update the amount
         // using the transaction editor.
         if (matchedSplit.shares() != importedSplit.shares() && !matchedSchedule.isFixed()) {
           // for now this only works with regular transactions and not
           // for investment transactions. As of this, we don't have
           // scheduled investment transactions anyway.
           auto se = dynamic_cast<StdTransactionEditor*>(editor.data());
           if (se) {
             // the following call will update the amount field in the
             // editor and also adjust a possible VAT assignment. Make
             // sure to use only the absolute value of the amount, because
             // the editor keeps the sign in a different position (deposit,
             // withdrawal tab)
             KMyMoneyEdit* amount = dynamic_cast<KMyMoneyEdit*>(se->haveWidget("amount"));
             if (amount) {
               amount->setValue(importedSplit.shares().abs());
               se->slotUpdateAmount(importedSplit.shares().abs().toString());
 
               // we also need to update the matchedSplit variable to
               // have the modified share/value.
               matchedSplit.setShares(importedSplit.shares());
               matchedSplit.setValue(importedSplit.value());
             }
           }
         }
 
         editor->createTransaction(torig, dlg.transaction(), dlg.transaction().splits().isEmpty() ? MyMoneySplit() : dlg.transaction().splits().front(), true);
         QString newId;
         if (editor->enterTransactions(newId, false, true)) {
           if (!newId.isEmpty()) {
             torig = MyMoneyFile::instance()->transaction(newId);
             matchedSchedule.setLastPayment(torig.postDate());
           }
           matchedSchedule.setNextDueDate(matchedSchedule.nextPayment(matchedSchedule.nextDueDate()));
           MyMoneyFile::instance()->modifySchedule(matchedSchedule);
         }
 
         // now match the two transactions
         matcher.match(torig, matchedSplit, importedTransaction, importedSplit);
         d->transactionsMatched++;
 
-      } catch (const MyMoneyException &e) {
+      } catch (const MyMoneyException &) {
         // make sure we get rid of the editor before
         // the KEnterScheduleDlg is destroyed
         delete editor;
-        throw e; // rethrow
+        throw; // rethrow
       }
     }
     // delete the editor
     delete editor;
   }
 }
 
 void MyMoneyStatementReader::addTransaction(MyMoneyTransaction& transaction)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   file->addTransaction(transaction);
   d->transactionsAdded++;
 }
 
 bool MyMoneyStatementReader::askUserToEnterScheduleForMatching(const MyMoneySchedule& matchedSchedule, const MyMoneySplit& importedSplit, const MyMoneyTransaction & importedTransaction) const
 {
   QString scheduleName = matchedSchedule.name();
   int currencyDenom = d->m_account.fraction(MyMoneyFile::instance()->currency(d->m_account.currencyId()));
   QString splitValue = importedSplit.value().formatMoney(currencyDenom);
   QString payeeName = MyMoneyFile::instance()->payee(importedSplit.payeeId()).name();
 
   QString questionMsg = i18n("KMyMoney has found a scheduled transaction which matches an imported transaction.<br/>"
                              "Schedule name: <b>%1</b><br/>"
                              "Transaction: <i>%2 %3</i><br/>"
                              "Do you want KMyMoney to enter this schedule now so that the transaction can be matched?",
                              scheduleName, splitValue, payeeName);
 
   // check that dates are within user's setting
   const auto gap = static_cast<int>(qAbs(matchedSchedule.transaction().postDate().toJulianDay() - importedTransaction.postDate().toJulianDay()));
   if (gap > KMyMoneySettings::matchInterval())
     questionMsg = i18np("KMyMoney has found a scheduled transaction which matches an imported transaction.<br/>"
                         "Schedule name: <b>%2</b><br/>"
                         "Transaction: <i>%3 %4</i><br/>"
                         "The transaction dates are one day apart.<br/>"
                         "Do you want KMyMoney to enter this schedule now so that the transaction can be matched?",
                         "KMyMoney has found a scheduled transaction which matches an imported transaction.<br/>"
                         "Schedule name: <b>%2</b><br/>"
                         "Transaction: <i>%3 %4</i><br/>"
                         "The transaction dates are %1 days apart.<br/>"
                         "Do you want KMyMoney to enter this schedule now so that the transaction can be matched?",
                         gap ,scheduleName, splitValue, payeeName);
 
   const int userAnswer = KMessageBox::questionYesNo(0, QLatin1String("<html>") + questionMsg + QLatin1String("</html>"), i18n("Schedule found"));
 
   return (userAnswer == KMessageBox::Yes);
 }
 
 void MyMoneyStatementReader::slotNewAccount(const MyMoneyAccount& acc)
 {
   auto newAcc = acc;
   NewAccountWizard::Wizard::newAccount(newAcc);
 }
diff --git a/kmymoney/converter/mymoneytemplate.cpp b/kmymoney/converter/mymoneytemplate.cpp
index b21c32dc6..472b26650 100644
--- a/kmymoney/converter/mymoneytemplate.cpp
+++ b/kmymoney/converter/mymoneytemplate.cpp
@@ -1,505 +1,505 @@
 /***************************************************************************
                           mymoneytemplate.cpp  -  description
                              -------------------
     begin                : Sat Aug 14 2004
     copyright            : (C) 2004 by Thomas Baumgart
     email                : 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 "mymoneytemplate.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFile>
 #include <QFileInfo>
 #include <QTextStream>
 #include <QList>
 #include <QSaveFile>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <QTemporaryFile>
 #include <KXmlGuiWindow>
 #include <KIO/StoredTransferJob>
 #include <KJobWidgets>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneyutils.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 MyMoneyTemplate::MyMoneyTemplate() :
     m_progressCallback(0),
     m_accountsRead(0)
 {
 }
 
 MyMoneyTemplate::MyMoneyTemplate(const QUrl& url) :
     m_progressCallback(0),
     m_accountsRead(0)
 {
   loadTemplate(url);
 }
 
 MyMoneyTemplate::~MyMoneyTemplate()
 {
 }
 
 bool MyMoneyTemplate::loadTemplate(const QUrl &url)
 {
   QString filename;
   bool downloadedFile = false;
   if (!url.isValid()) {
     qDebug("Invalid template URL '%s'", qPrintable(url.url()));
     return false;
   }
 
   m_source = url;
   if (url.isLocalFile()) {
     filename = url.toLocalFile();
 
   } else {
     bool rc = false;
     downloadedFile = true;
     KIO::StoredTransferJob *transferjob = KIO::storedGet (url);
     KJobWidgets::setWindow(transferjob, KMyMoneyUtils::mainWindow());
     rc = transferjob->exec();
     if (! rc) {
         KMessageBox::detailedError(KMyMoneyUtils::mainWindow(),
                                  i18n("Error while loading file '%1'.", url.url()),
                                  transferjob->errorString(),
                                  i18n("File access error"));
         return false;
     }
     QTemporaryFile file;
     file.setAutoRemove(false);
     file.open();
     file.write(transferjob->data());
     filename = file.fileName();
     file.close();
   }
 
   bool rc = true;
   QFile file(filename);
   QFileInfo info(file);
   if (!info.isFile()) {
     QString msg = i18n("<p><b>%1</b> is not a template file.</p>", filename);
     KMessageBox::error(KMyMoneyUtils::mainWindow(), msg, i18n("Filetype Error"));
     return false;
   }
 
   if (file.open(QIODevice::ReadOnly)) {
     QString errMsg;
     int errLine, errColumn;
     if (!m_doc.setContent(&file, &errMsg, &errLine, &errColumn)) {
       QString msg = i18n("<p>Error while reading template file <b>%1</b> in line %2, column %3</p>", filename, errLine, errColumn);
       KMessageBox::detailedError(KMyMoneyUtils::mainWindow(), msg, errMsg, i18n("Template Error"));
       rc = false;
     } else {
       rc = loadDescription();
     }
     file.close();
   } else {
     KMessageBox::sorry(KMyMoneyUtils::mainWindow(), i18n("File '%1' not found.", filename));
     rc = false;
   }
 
   // if a temporary file was downloaded, then it will be removed
   // with the next call. Otherwise, it stays untouched on the local
   // filesystem.
   if (downloadedFile) {
     QFile::remove(filename);
   }
   return rc;
 }
 
 bool MyMoneyTemplate::loadDescription()
 {
   int validMask = 0x00;
   const int validAccount = 0x01;
   const int validTitle = 0x02;
   const int validShort = 0x04;
   const int validLong = 0x08;
   const int invalid = 0x10;
   const int validHeader = 0x0F;
 
   QDomElement rootElement = m_doc.documentElement();
   if (!rootElement.isNull()
       && rootElement.tagName() == "kmymoney-account-template") {
     QDomNode child = rootElement.firstChild();
     while (!child.isNull() && child.isElement()) {
       QDomElement childElement = child.toElement();
       // qDebug("MyMoneyTemplate::import: Processing child node %s", childElement.tagName().data());
       if (childElement.tagName() == "accounts") {
         m_accounts = childElement.firstChild();
         validMask |= validAccount;
       } else if (childElement.tagName() == "title") {
         m_title = childElement.text();
         validMask |= validTitle;
       } else if (childElement.tagName() == "shortdesc") {
         m_shortDesc = childElement.text();
         validMask |= validShort;
       } else if (childElement.tagName() == "longdesc") {
         m_longDesc = childElement.text();
         validMask |= validLong;
       } else {
         KMessageBox::error(KMyMoneyUtils::mainWindow(), i18n("<p>Invalid tag <b>%1</b> in template file <b>%2</b></p>", childElement.tagName(), m_source.toDisplayString()));
         validMask |= invalid;
       }
       child = child.nextSibling();
     }
   }
   return validMask == validHeader;
 }
 
 bool MyMoneyTemplate::hierarchy(QMap<QString, QTreeWidgetItem*>& list, const QString& parent, QDomNode account)
 {
   bool rc = true;
   while (rc == true && !account.isNull()) {
     if (account.isElement()) {
       QDomElement accountElement = account.toElement();
       if (accountElement.tagName() == "account") {
         QString name = QString("%1:%2").arg(parent).arg(accountElement.attribute("name"));
         list[name] = 0;
         hierarchy(list, name, account.firstChild());
       }
     }
     account = account.nextSibling();
   }
   return rc;
 }
 
 void MyMoneyTemplate::hierarchy(QMap<QString, QTreeWidgetItem*>& list)
 {
   bool rc = !m_accounts.isNull();
   QDomNode accounts = m_accounts;
   while (rc == true && !accounts.isNull() && accounts.isElement()) {
     QDomElement rootNode = accounts.toElement();
     QString name = rootNode.attribute("name");
     if (rootNode.tagName() == "account") {
         rootNode = rootNode.firstChild().toElement();
         eMyMoney::Account::Type type = static_cast<eMyMoney::Account::Type>(accounts.toElement().attribute("type").toUInt());
         switch (type) {
         case eMyMoney::Account::Type::Asset:
         case eMyMoney::Account::Type::Liability:
         case eMyMoney::Account::Type::Income:
         case eMyMoney::Account::Type::Expense:
         case eMyMoney::Account::Type::Equity:
           if (name.isEmpty())
             name = MyMoneyAccount::accountTypeToString(type);
           list[name] = 0;
           rc = hierarchy(list, name, rootNode);
           break;
 
         default:
           rc = false;
           break;
       }
     } else {
       rc = false;
     }
     accounts = accounts.nextSibling();
   }
 }
 
 bool MyMoneyTemplate::importTemplate(void(*callback)(int, int, const QString&))
 {
   m_progressCallback = callback;
   bool rc = !m_accounts.isNull();
   MyMoneyFile* file = MyMoneyFile::instance();
   signalProgress(0, m_doc.elementsByTagName("account").count(), i18n("Loading template %1", m_source.url()));
   m_accountsRead = 0;
 
   while (rc == true && !m_accounts.isNull() && m_accounts.isElement()) {
     QDomElement childElement = m_accounts.toElement();
     if (childElement.tagName() == "account") {
       ++m_accountsRead;
       MyMoneyAccount parent;
       switch (childElement.attribute("type").toUInt()) {
         case (uint)eMyMoney::Account::Type::Asset:
           parent = file->asset();
           break;
         case (uint)eMyMoney::Account::Type::Liability:
           parent = file->liability();
           break;
         case (uint)eMyMoney::Account::Type::Income:
           parent = file->income();
           break;
         case (uint)eMyMoney::Account::Type::Expense:
           parent = file->expense();
           break;
         case (uint)eMyMoney::Account::Type::Equity:
           parent = file->equity();
           break;
 
         default:
           KMessageBox::error(KMyMoneyUtils::mainWindow(), i18n("<p>Invalid top-level account type <b>%1</b> in template file <b>%2</b></p>", childElement.attribute("type"), m_source.toDisplayString()));
           rc = false;
       }
 
       if (rc == true) {
         if (childElement.attribute("name").isEmpty())
             rc = createAccounts(parent, childElement.firstChild());
         else
             rc = createAccounts(parent, childElement);
       }
     } else {
       rc = false;
     }
     m_accounts = m_accounts.nextSibling();
   }
   signalProgress(-1, -1);
   return rc;
 }
 
 bool MyMoneyTemplate::createAccounts(MyMoneyAccount& parent, QDomNode account)
 {
   bool rc = true;
   while (rc == true && !account.isNull()) {
     MyMoneyAccount acc;
     if (account.isElement()) {
       QDomElement accountElement = account.toElement();
       if (accountElement.tagName() == "account") {
         signalProgress(++m_accountsRead, 0);
         QList<MyMoneyAccount> subAccountList;
         QList<MyMoneyAccount>::ConstIterator it;
         it = subAccountList.constEnd();
         if (!parent.accountList().isEmpty()) {
           MyMoneyFile::instance()->accountList(subAccountList, parent.accountList());
           for (it = subAccountList.constBegin(); it != subAccountList.constEnd(); ++it) {
             if ((*it).name() == accountElement.attribute("name")) {
               acc = *it;
               break;
             }
           }
         }
         if (it == subAccountList.constEnd()) {
           // not found, we need to create it
           acc.setName(accountElement.attribute("name"));
           acc.setAccountType(static_cast<eMyMoney::Account::Type>(accountElement.attribute("type").toUInt()));
           setFlags(acc, account.firstChild());
           try {
             MyMoneyFile::instance()->addAccount(acc, parent);
           } catch (const MyMoneyException &) {
           }
         }
         createAccounts(acc, account.firstChild());
       }
     }
     account = account.nextSibling();
   }
   return rc;
 }
 
 bool MyMoneyTemplate::setFlags(MyMoneyAccount& acc, QDomNode flags)
 {
   bool rc = true;
   while (rc == true && !flags.isNull()) {
     if (flags.isElement()) {
       QDomElement flagElement = flags.toElement();
       if (flagElement.tagName() == "flag") {
         // make sure, we only store flags we know!
         QString value = flagElement.attribute("name");
         if (value == "Tax") {
           acc.setValue(value.toLatin1(), "Yes");
         } else if (value == "OpeningBalanceAccount") {
           acc.setValue("OpeningBalanceAccount", "Yes");
         } else {
           KMessageBox::error(KMyMoneyUtils::mainWindow(), i18n("<p>Invalid flag type <b>%1</b> for account <b>%3</b> in template file <b>%2</b></p>", flagElement.attribute("name"), m_source.toDisplayString(), acc.name()));
           rc = false;
         }
         QString currency = flagElement.attribute("currency");
         if (!currency.isEmpty())
           acc.setCurrencyId(currency);
       }
     }
     flags = flags.nextSibling();
   }
   return rc;
 }
 
 void MyMoneyTemplate::signalProgress(int current, int total, const QString& msg)
 {
   if (m_progressCallback != 0)
     (*m_progressCallback)(current, total, msg);
 }
 
 bool MyMoneyTemplate::exportTemplate(void(*callback)(int, int, const QString&))
 {
   m_progressCallback = callback;
 
   m_doc = QDomDocument("KMYMONEY-TEMPLATE");
 
   QDomProcessingInstruction instruct = m_doc.createProcessingInstruction(QString("xml"), QString("version=\"1.0\" encoding=\"utf-8\""));
   m_doc.appendChild(instruct);
 
   QDomElement mainElement = m_doc.createElement("kmymoney-account-template");
   m_doc.appendChild(mainElement);
 
   QDomElement title = m_doc.createElement("title");
   QDomText t = m_doc.createTextNode(m_title);
   title.appendChild(t);
   mainElement.appendChild(title);
 
   QDomElement shortDesc = m_doc.createElement("shortdesc");
   t = m_doc.createTextNode(m_shortDesc);
   shortDesc.appendChild(t);
   mainElement.appendChild(shortDesc);
 
   QDomElement longDesc = m_doc.createElement("longdesc");
   t = m_doc.createTextNode(m_longDesc);
   longDesc.appendChild(t);
   mainElement.appendChild(longDesc);
 
   QDomElement accounts = m_doc.createElement("accounts");
   mainElement.appendChild(accounts);
 
   addAccountStructure(accounts, MyMoneyFile::instance()->asset());
   addAccountStructure(accounts, MyMoneyFile::instance()->expense());
   addAccountStructure(accounts, MyMoneyFile::instance()->income());
   addAccountStructure(accounts, MyMoneyFile::instance()->liability());
   addAccountStructure(accounts, MyMoneyFile::instance()->equity());
 
   return true;
 }
 
 const QString& MyMoneyTemplate::title() const
 {
   return m_title;
 }
 
 const QString& MyMoneyTemplate::shortDescription() const
 {
   return m_shortDesc;
 }
 
 const QString& MyMoneyTemplate::longDescription() const
 {
   return m_longDesc;
 }
 
 void MyMoneyTemplate::setTitle(const QString &s)
 {
   m_title = s;
 }
 
 void MyMoneyTemplate::setShortDescription(const QString &s)
 {
   m_shortDesc = s;
 }
 
 void MyMoneyTemplate::setLongDescription(const QString &s)
 {
   m_longDesc = s;
 }
 
 static bool nameLessThan(MyMoneyAccount &a1, MyMoneyAccount &a2)
 {
   return a1.name() < a2.name();
 }
 
 bool MyMoneyTemplate::addAccountStructure(QDomElement& parent, const MyMoneyAccount& acc)
 {
   QDomElement account = m_doc.createElement("account");
   parent.appendChild(account);
 
   if (MyMoneyFile::instance()->isStandardAccount(acc.id()))
     account.setAttribute(QString("name"), QString());
   else
     account.setAttribute(QString("name"), acc.name());
   account.setAttribute(QString("type"), (int)acc.accountType());
 
   // FIXME: add tax flag stuff
   if (acc.pairs().contains("OpeningBalanceAccount")) {
     QString openingBalanceAccount = acc.value("OpeningBalanceAccount");
     if (openingBalanceAccount == "Yes") {
       QDomElement flag = m_doc.createElement("flag");
       flag.setAttribute(QString("name"), "OpeningBalanceAccount");
       flag.setAttribute(QString("currency"), acc.currencyId());
       account.appendChild(flag);
     }
   }
 
   // any child accounts?
   if (acc.accountList().count() > 0) {
     QList<MyMoneyAccount> list;
     MyMoneyFile::instance()->accountList(list, acc.accountList(), false);
     qSort(list.begin(), list.end(), nameLessThan);
     QList<MyMoneyAccount>::Iterator it;
     for (it = list.begin(); it != list.end(); ++it) {
       addAccountStructure(account, *it);
     }
   }
   return true;
 }
 
 bool MyMoneyTemplate::saveTemplate(const QUrl &url)
 {
   QString filename;
 
   if (!url.isValid()) {
     qDebug("Invalid template URL '%s'", qPrintable(url.url()));
     return false;
   }
 
   if (url.isLocalFile()) {
     filename = url.toLocalFile();
     QSaveFile qfile(filename/*, 0600*/);
     if (qfile.open(QIODevice::WriteOnly)) {
       saveToLocalFile(&qfile);
       if (!qfile.commit()) {
-        throw MYMONEYEXCEPTION(i18n("Unable to write changes to '%1'", filename));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to write changes to '%1'").arg(filename));
       }
     } else {
-      throw MYMONEYEXCEPTION(i18n("Unable to write changes to '%1'", filename));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to write changes to '%1'").arg(filename));
     }
   } else {
     QTemporaryFile tmpfile;
     tmpfile.open();
     QSaveFile qfile(tmpfile.fileName());
     if (qfile.open(QIODevice::WriteOnly)) {
       saveToLocalFile(&qfile);
       if (!qfile.commit()) {
-        throw MYMONEYEXCEPTION(i18n("Unable to upload to '%1'", url.toDisplayString()));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to upload to '%1'").arg(url.toDisplayString()));
       }
     } else {
-      throw MYMONEYEXCEPTION(i18n("Unable to upload to '%1'", url.toDisplayString()));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to upload to '%1'").arg(url.toDisplayString()));
     }
     int permission = -1;
     QFile file(tmpfile.fileName());
     file.open(QIODevice::ReadOnly);
     KIO::StoredTransferJob *putjob = KIO::storedPut(file.readAll(), url, permission, KIO::JobFlag::Overwrite);
     if (!putjob->exec()) {
-      throw MYMONEYEXCEPTION(i18n("Unable to upload to '%1'.<br />%2", url.toDisplayString(), putjob->errorString()));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to upload to '%1'.<br />%2").arg(url.toDisplayString(), putjob->errorString()));
     }
     file.close();
   }
   return true;
 }
 
 bool MyMoneyTemplate::saveToLocalFile(QSaveFile* qfile)
 {
   QTextStream stream(qfile);
   stream.setCodec("UTF-8");
   stream << m_doc.toString();
   stream.flush();
 
   return true;
 }
diff --git a/kmymoney/converter/tests/converter-test.cpp b/kmymoney/converter/tests/converter-test.cpp
index 38826f9b5..588119336 100644
--- a/kmymoney/converter/tests/converter-test.cpp
+++ b/kmymoney/converter/tests/converter-test.cpp
@@ -1,201 +1,201 @@
 /***************************************************************************
                           convertertest.cpp
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "converter-test.h"
 
 #include <QtTest>
 #include <QFile>
 
 // uses helper functions from reports tests
 #include "reportstestcommon.h"
 using namespace test;
 
 #include "mymoneyinstitution.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneyreport.h"
 #include "mymoneypayee.h"
 #include "mymoneystatement.h"
 #include "mymoneyexception.h"
 #include "storage/mymoneystoragexml.h"
 #include "storage/mymoneystoragedump.h"
 #include "webpricequote.h"
 
 QTEST_GUILESS_MAIN(ConverterTest)
 
 using namespace convertertest;
 
 void ConverterTest::init()
 {
   storage = new MyMoneyStorageMgr;
   file = MyMoneyFile::instance();
   file->attachStorage(storage);
 
   MyMoneyFileTransaction ft;
 
   file->addCurrency(MyMoneySecurity("CAD", "Canadian Dollar",        "C$"));
   file->addCurrency(MyMoneySecurity("USD", "US Dollar",              "$"));
   file->addCurrency(MyMoneySecurity("JPY", "Japanese Yen",           QChar(0x00A5), 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2("Thomas Baumgart");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount("Checking Account", eMyMoney::Account::Type::Checkings, moConverterCheckingOpen, QDate(2004, 5, 15), acAsset);
   acCredit = makeAccount("Credit Card", eMyMoney::Account::Type::CreditCard, moConverterCreditOpen, QDate(2004, 7, 15), acLiability);
   acSolo = makeAccount("Solo", eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acParent = makeAccount("Parent", eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acChild = makeAccount("Child", eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acForeign = makeAccount("Foreign", eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 }
 
 void ConverterTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void ConverterTest::testWebQuotes_data()
 {
   QTest::addColumn<QString>("symbol");
   QTest::addColumn<QString>("testname");
   QTest::addColumn<QString>("source");
 
   QTest::newRow("Yahoo UK") << "VOD.L" << "test Yahoo UK" << "Yahoo UK";
   QTest::newRow("Yahoo Currency") << "EUR > USD" << "test Yahoo Currency" << "Yahoo Currency";
   QTest::newRow("Financial Express") << "0585239" << "test Financial Express" << "Financial Express";
   QTest::newRow("Yahoo France") << "EAD.PA" << "test Yahoo France" << "Yahoo France";
   QTest::newRow("Globe & Mail") << "50492" << "test Globe-Mail" << "Globe & Mail";
   QTest::newRow("MSN Canada") << "TDB647" << "test MSN.CA" << "MSN.CA";
 
 //  QTest::newRow("Finanztreff") << "BASF.SE" << "test Finanztreff" << "Finanztreff";
 //  QTest::newRow("boerseonline") << "symbol" << "test boerseonline" << "boerseonline";
 //  QTest::newRow("Wallstreet-Online.DE (Default)") << "symbol" << "test Wallstreet-Online.DE (Default)" << "Wallstreet-Online.DE (Default)";
 //  QTest::newRow("Financial Times UK") << "DZGEAE" << "test Financial Times UK Funds" << "Financial Times UK Funds");
 
   QTest::newRow("Yahoo Canada") << "UTS.TO" << "test Yahoo Canada" << "Yahoo Canada";
 
 //  QTest::newRow("Wallstreed-Online.DE (Hamburg)") << "TDB647" << "test Wallstreet-Online.DE (Hamburg)" << "Wallstreet-Online.DE (Hamburg)";
 //  QTest::newRow("Gielda Papierow Wartosciowych (GPW)") << "TDB647" << "test Gielda Papierow Wartosciowych (GPW)" << "Gielda Papierow Wartosciowych (GPW)";
 //  QTest::newRow("OMX Baltic") << "TDB647" << "test OMX Baltic funds" << "OMX Baltic funds";
 
   QTest::newRow("Finance::Quote usa") << "DIS" << "test F::Q usa" << "Finance::Quote usa";
 //UNTESTED: Other F::Q sources, local files, user custom sources
 }
 
 void ConverterTest::testWebQuotesDefault()
 {
 #ifdef PERFORM_ONLINE_TESTS
   try {
     WebPriceQuote q;
     QuoteReceiver qr(&q);
 
     q.launch("DIS", "test default");
 //    qDebug() << "ConverterTest::testWebQuotes(): quote for " << q.m_symbol << " on " << qr.m_date.toString() << " is " << qr.m_price.toString() << " errors(" << qr.m_errors.count() << "): " << qr.m_errors.join(" /// ");
 
     // No errors allowed
     QVERIFY(qr.m_errors.count() == 0);
 
     // Quote date should be within the last week, or something bad is going on.
     QVERIFY(qr.m_date <= QDate::currentDate());
     QVERIFY(qr.m_date >= QDate::currentDate().addDays(-7));
 
     // Quote value should at least be positive
     QVERIFY(qr.m_price.isPositive());
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 #endif
 }
 
 void ConverterTest::testWebQuotes()
 {
 #ifdef PERFORM_ONLINE_TESTS
   try {
     WebPriceQuote q;
     QuoteReceiver qr(&q);
 
     QFETCH(QString, symbol);
     QFETCH(QString, testname);
     QFETCH(QString, source);
 
     q.launch(symbol, testname, source);
     QVERIFY(qr.m_errors.count() == 0);
     QVERIFY(qr.m_date <= QDate::currentDate().addDays(1));
     QVERIFY(qr.m_date >= QDate::currentDate().addDays(-7));
     QVERIFY(qr.m_price.isPositive());
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 #endif
 }
 
 void ConverterTest::testDateFormat()
 {
   try {
     MyMoneyDateFormat format("%mm-%dd-%yyyy");
 
     QVERIFY(format.convertString("1-5-2005") == QDate(2005, 1, 5));
     QVERIFY(format.convertString("jan-15-2005") == QDate(2005, 1, 15));
     QVERIFY(format.convertString("august-25-2005") == QDate(2005, 8, 25));
 
     format = MyMoneyDateFormat("%mm/%dd/%yy");
 
     QVERIFY(format.convertString("1/5/05") == QDate(2005, 1, 5));
     QVERIFY(format.convertString("jan/15/05") == QDate(2005, 1, 15));
     QVERIFY(format.convertString("august/25/05") == QDate(2005, 8, 25));
 
     format = MyMoneyDateFormat("%d\\.%m\\.%yy");
 
     QVERIFY(format.convertString("1.5.05") == QDate(2005, 5, 1));
     QVERIFY(format.convertString("15.jan.05") == QDate(2005, 1, 15));
     QVERIFY(format.convertString("25.august.05") == QDate(2005, 8, 25));
 
     format = MyMoneyDateFormat("%yyyy\\\\%dddd\\\\%mmmmmmmmmmm");
 
     QVERIFY(format.convertString("2005\\31\\12") == QDate(2005, 12, 31));
     QVERIFY(format.convertString("2005\\15\\jan") == QDate(2005, 1, 15));
     QVERIFY(format.convertString("2005\\25\\august") == QDate(2005, 8, 25));
 
     format = MyMoneyDateFormat("%m %dd, %yyyy");
 
     QVERIFY(format.convertString("jan 15, 2005") == QDate(2005, 1, 15));
     QVERIFY(format.convertString("august 25, 2005") == QDate(2005, 8, 25));
     QVERIFY(format.convertString("january 1st, 2005") == QDate(2005, 1, 1));
 
     format = MyMoneyDateFormat("%m %d %y");
 
     QVERIFY(format.convertString("12/31/50", false, 2000) == QDate(1950, 12, 31));
     QVERIFY(format.convertString("1/1/90", false, 2000) == QDate(1990, 1, 1));
     QVERIFY(format.convertString("december 31st, 5", false) == QDate(2005, 12, 31));
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
diff --git a/kmymoney/converter/transactionmatchfinder.cpp b/kmymoney/converter/transactionmatchfinder.cpp
index 7bb057352..5cb8cfbb3 100644
--- a/kmymoney/converter/transactionmatchfinder.cpp
+++ b/kmymoney/converter/transactionmatchfinder.cpp
@@ -1,159 +1,159 @@
 /***************************************************************************
     KMyMoney transaction importing module - base class for searching for a matching transaction
 
     copyright            : (C) 2012 by Lukasz Maszczynski <lukasz@maszczynski.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 "transactionmatchfinder.h"
 
 #include <QDebug>
 #include <QDate>
 
 #include <KLocalizedString>
 
 #include "mymoneymoney.h"
 #include "mymoneyaccount.h"
 #include "mymoneyfile.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 
 TransactionMatchFinder::TransactionMatchFinder(int _matchWindow) :
     m_matchWindow(_matchWindow),
     matchResult(MatchNotFound)
 {
 }
 
 TransactionMatchFinder::~TransactionMatchFinder()
 {
 }
 
 TransactionMatchFinder::MatchResult TransactionMatchFinder::findMatch(const MyMoneyTransaction& transactionToMatch, const MyMoneySplit& splitToMatch)
 {
   importedTransaction = transactionToMatch;
   m_importedSplit = splitToMatch;
   matchResult = MatchNotFound;
   matchedTransaction.reset();
   matchedSplit.reset();
   matchedSchedule.reset();
 
   QString date = importedTransaction.postDate().toString(Qt::ISODate);
   QString payeeName = MyMoneyFile::instance()->payee(m_importedSplit.payeeId()).name();
   QString amount = m_importedSplit.shares().formatMoney("", 2);
   QString account = MyMoneyFile::instance()->account(m_importedSplit.accountId()).name();
   qDebug() << "Looking for a match with transaction: " << date << "," << payeeName << "," << amount
   << "(referenced account: " << account << ")";
 
   createListOfMatchCandidates();
   findMatchInMatchCandidatesList();
   return matchResult;
 }
 
 MyMoneySplit TransactionMatchFinder::getMatchedSplit() const
 {
   if (matchedSplit.isNull()) {
-    throw MYMONEYEXCEPTION(i18n("Internal error - no matching splits"));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Internal error - no matching splits"));
   }
 
   return *matchedSplit;
 }
 
 MyMoneyTransaction TransactionMatchFinder::getMatchedTransaction() const
 {
   if (matchedTransaction.isNull()) {
-    throw MYMONEYEXCEPTION(i18n("Internal error - no matching transactions"));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Internal error - no matching transactions"));
   }
 
   return *matchedTransaction;
 }
 
 MyMoneySchedule TransactionMatchFinder::getMatchedSchedule() const
 {
   if (matchedSchedule.isNull()) {
-    throw MYMONEYEXCEPTION(i18n("Internal error - no matching schedules"));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Internal error - no matching schedules"));
   }
 
   return *matchedSchedule;
 }
 
 bool TransactionMatchFinder::splitsAreDuplicates(const MyMoneySplit& split1, const MyMoneySplit& split2, int amountVariation) const
 {
   return (splitsAmountsMatch(split1, split2, amountVariation) && splitsBankIdsDuplicated(split1, split2));
 }
 
 bool TransactionMatchFinder::splitsMatch(const MyMoneySplit& importedSplit, const MyMoneySplit& existingSplit, int amountVariation) const
 {
   return (splitsAccountsMatch(importedSplit, existingSplit) &&
           splitsBankIdsMatch(importedSplit, existingSplit) &&
           splitsAmountsMatch(importedSplit, existingSplit, amountVariation) &&
           splitsPayeesMatchOrEmpty(importedSplit, existingSplit) &&
           !existingSplit.isMatched());
 }
 
 bool TransactionMatchFinder::splitsAccountsMatch(const MyMoneySplit & split1, const MyMoneySplit & split2) const
 {
   return split1.accountId() == split2.accountId();
 }
 
 bool TransactionMatchFinder::splitsAmountsMatch(const MyMoneySplit& split1, const MyMoneySplit& split2, int amountVariation) const
 {
   MyMoneyMoney upper(split1.shares());
   MyMoneyMoney lower(upper);
   if ((amountVariation > 0) && (amountVariation < 100)) {
     lower = lower - (lower.abs() * MyMoneyMoney(amountVariation, 100));
     upper = upper + (upper.abs() * MyMoneyMoney(amountVariation, 100));
   }
 
   return (split2.shares() >= lower) && (split2.shares() <= upper);
 }
 
 bool TransactionMatchFinder::splitsBankIdsDuplicated(const MyMoneySplit& split1, const MyMoneySplit& split2) const
 {
   return (!split1.bankID().isEmpty()) && (split1.bankID() == split2.bankID());
 }
 
 bool TransactionMatchFinder::splitsBankIdsMatch(const MyMoneySplit& importedSplit, const MyMoneySplit& existingSplit) const
 {
   return (existingSplit.bankID().isEmpty() || existingSplit.bankID() == importedSplit.bankID());
 }
 
 bool TransactionMatchFinder::splitsPayeesMatchOrEmpty(const MyMoneySplit& split1, const MyMoneySplit& split2) const
 {
   bool payeesMatch = (split1.payeeId() == split2.payeeId());
   bool atLeastOnePayeeIsNotSet = (split1.payeeId().isEmpty() || split2.payeeId().isEmpty());
   return payeesMatch || atLeastOnePayeeIsNotSet;
 }
 
 void TransactionMatchFinder::findMatchingSplit(const MyMoneyTransaction& transaction, int amountVariation)
 {
   foreach (const MyMoneySplit & split, transaction.splits()) {
     if (splitsAreDuplicates(m_importedSplit, split, amountVariation)) {
       matchedTransaction.reset(new MyMoneyTransaction(transaction));
       matchedSplit.reset(new MyMoneySplit(split));
       matchResult = MatchDuplicate;
       break;
     }
 
     if (splitsMatch(m_importedSplit, split, amountVariation)) {
       matchedTransaction.reset(new MyMoneyTransaction(transaction));
       matchedSplit.reset(new MyMoneySplit(split));
 
       bool datesMatchPrecisely = importedTransaction.postDate() == transaction.postDate();
       if (datesMatchPrecisely) {
         matchResult = MatchPrecise;
       } else {
         matchResult = MatchImprecise;
       }
       break;
     }
   }
 }
diff --git a/kmymoney/converter/webpricequote.cpp b/kmymoney/converter/webpricequote.cpp
index 733d1bd8b..1e6dfb5fa 100644
--- a/kmymoney/converter/webpricequote.cpp
+++ b/kmymoney/converter/webpricequote.cpp
@@ -1,1242 +1,1242 @@
 /***************************************************************************
                           webpricequote.cpp
                              -------------------
     begin                : Thu Dec 30 2004
     copyright            : (C) 2004 by Ace Jones
     email                : Ace Jones <acejones@users.sourceforge.net>
     copyright            : (C) 2017 by Łukasz Wojniłowicz
     email                : Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "webpricequote.h"
 
 // ----------------------------------------------------------------------------
 // QT Headers
 
 #include <QFile>
 #include <QTextCodec>
 #include <QByteArray>
 #include <QString>
 #include <QTemporaryFile>
 #include <QUrl>
 #include <QRegularExpression>
 #include <QDebug>
 #include <QLoggingCategory>
 #include <QLocale>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KShell>
 #include <KConfigGroup>
 #include <KEncodingProber>
 #include <KIO/Scheduler>
 #include <KIO/Job>
 #include <KJobWidgets>
 
 // ----------------------------------------------------------------------------
 // Project Headers
 
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneysecurity.h"
 
 Q_DECLARE_LOGGING_CATEGORY(WEBPRICEQUOTE)
 Q_LOGGING_CATEGORY(WEBPRICEQUOTE, "kmymoney_webpricequote")
 
 // define static members
 QString WebPriceQuote::m_financeQuoteScriptPath;
 QStringList WebPriceQuote::m_financeQuoteSources;
 
 class WebPriceQuote::Private
 {
 public:
   WebPriceQuoteProcess m_filter;
   QString m_quoteData;
   QString m_webID;
   QString m_kmmID;
   QDate m_date;
   QDate m_fromDate;
   QDate m_toDate;
   double m_price;
   WebPriceQuoteSource m_source;
   PricesProfile    m_CSVSource;
 };
 
 WebPriceQuote::WebPriceQuote(QObject* _parent):
     QObject(_parent),
     d(new Private)
 {
   // only do this once (I know, it is not thread safe, but it should
   // always yield the same result so we don't do any semaphore foo here)
   if (m_financeQuoteScriptPath.isEmpty()) {
     m_financeQuoteScriptPath = QStandardPaths::locate(QStandardPaths::DataLocation, QString("misc/financequote.pl"));
   }
   connect(&d->m_filter, SIGNAL(processExited(QString)), this, SLOT(slotParseQuote(QString)));
 }
 
 WebPriceQuote::~WebPriceQuote()
 {
   delete d;
 }
 
 void WebPriceQuote::setDate(const QDate& _from, const QDate& _to)
 {
   d->m_fromDate = _from;
   d->m_toDate = _to;
 }
 
 bool WebPriceQuote::launch(const QString& _webID, const QString& _kmmID, const QString& _sourcename)
 {
   if (_sourcename.contains("Finance::Quote"))
     return (launchFinanceQuote(_webID, _kmmID, _sourcename));
   else if ((!d->m_fromDate.isValid() || !d->m_toDate.isValid()) ||
            (d->m_fromDate == d->m_toDate && d->m_toDate == QDate::currentDate()))
     return (launchNative(_webID, _kmmID, _sourcename));
   else
     return launchCSV(_webID, _kmmID, _sourcename);
 }
 
 bool WebPriceQuote::launchCSV(const QString& _webID, const QString& _kmmID, const QString& _sourcename)
 {
   d->m_webID = _webID;
   d->m_kmmID = _kmmID;
 
 //   emit status(QString("(Debug) symbol=%1 id=%2...").arg(_symbol,_id));
 
   // Get sources from the config file
   QString sourcename = _sourcename;
   if (sourcename.isEmpty())
     return false;
 
   // for historical exchange rates we switch to Stooq
   if (sourcename == QLatin1String("KMyMoney Currency"))
     sourcename = QLatin1String("Stooq Currency");
 
   if (quoteSources().contains(sourcename))
     d->m_source = WebPriceQuoteSource(sourcename);
   else {
     emit error(i18n("Source <placeholder>%1</placeholder> does not exist.", sourcename));
     emit failed(d->m_kmmID, d->m_webID);
     return false;
   }
 
   int monthOffset = 0;
   if (sourcename.contains(QLatin1String("Yahoo"), Qt::CaseInsensitive))
     monthOffset = -1;
 
   QUrl url;
   QString urlStr = d->m_source.m_csvUrl;
   int i = urlStr.indexOf(QLatin1String("%y"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_fromDate.year()));
   i = urlStr.indexOf(QLatin1String("%y"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_toDate.year()));
 
   i = urlStr.indexOf(QLatin1String("%m"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_fromDate.month() + monthOffset).rightJustified(2, QLatin1Char('0')));
   i = urlStr.indexOf(QLatin1String("%m"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_toDate.month() + monthOffset).rightJustified(2, QLatin1Char('0')));
 
   i = urlStr.indexOf(QLatin1String("%d"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_fromDate.day()).rightJustified(2, QLatin1Char('0')));
   i = urlStr.indexOf(QLatin1String("%d"));
   if (i != -1)
     urlStr.replace(i, 2, QString().setNum(d->m_toDate.day()).rightJustified(2, QLatin1Char('0')));
 
   if (urlStr.contains(QLatin1String("%y")) || urlStr.contains(QLatin1String("%m")) || urlStr.contains(QLatin1String("%d"))) {
     emit error(i18n("Cannot resolve input date."));
     emit failed(d->m_kmmID, d->m_webID);
     return false;
   }
 
   bool isCurrency = false;
   if (urlStr.contains(QLatin1String("%2"))) {
     d->m_CSVSource.m_profileType = Profile::CurrencyPrices;
     isCurrency = true;
   } else
     d->m_CSVSource.m_profileType = Profile::StockPrices;
 
   d->m_CSVSource.m_profileName = sourcename;
   if (!d->m_CSVSource.readSettings(CSVImporterCore::configFile())) {
     QMap<QString, PricesProfile> result = defaultCSVQuoteSources();
     d->m_CSVSource = result.value(sourcename);
     if (d->m_CSVSource.m_profileName.isEmpty()) {
       emit error(i18n("CSV source <placeholder>%1</placeholder> does not exist.", sourcename));
       emit failed(d->m_kmmID, d->m_webID);
       return false;
     }
   }
 
   if (isCurrency) {
     // this is a two-symbol quote.  split the symbol into two.  valid symbol
     // characters are: 0-9, A-Z and the dot.  anything else is a separator
     QRegularExpression splitrx("([0-9a-z\\.]+)[^a-z0-9]+([0-9a-z\\.]+)", QRegularExpression::CaseInsensitiveOption);
     QRegularExpressionMatch match;
     // if we've truly found 2 symbols delimited this way...
     if (d->m_webID.indexOf(splitrx, 0, &match) != -1) {
       url = QUrl(urlStr.arg(match.captured(1), match.captured(2)));
       d->m_CSVSource.m_currencySymbol = match.captured(2);
       d->m_CSVSource.m_securitySymbol = match.captured(1);
     } else {
       qCDebug(WEBPRICEQUOTE) << "WebPriceQuote::launch() did not find 2 symbols";
       emit error(i18n("Cannot find from and to currency."));
       emit failed(d->m_kmmID, d->m_webID);
       return false;
     }
 
   } else {
     // a regular one-symbol quote
     url = QUrl(urlStr.arg(d->m_webID));
     d->m_CSVSource.m_securityName = MyMoneyFile::instance()->security(d->m_kmmID).name();
     d->m_CSVSource.m_securitySymbol = MyMoneyFile::instance()->security(d->m_kmmID).tradingSymbol();
   }
 
   if (url.isLocalFile()) {
     emit error(i18n("Local quote sources aren't supported."));
     emit failed(d->m_kmmID, d->m_webID);
     return false;
   } else {
     //silent download
     emit status(i18n("Fetching URL %1...", url.toDisplayString()));
     QString tmpFile;
     {
       QTemporaryFile tmpFileFile;
       tmpFileFile.setAutoRemove(false);
       if (tmpFileFile.open())
           qDebug() << "created tmpfile";
 
       tmpFile = tmpFileFile.fileName();
     }
     QFile::remove(tmpFile);
     const QUrl dest = QUrl::fromLocalFile(tmpFile);
     KIO::Scheduler::checkSlaveOnHold(true);
     KIO::Job *job = KIO::file_copy(url, dest, -1, KIO::HideProgressInfo);
     connect(job, SIGNAL(result(KJob*)),
             this, SLOT(downloadCSV(KJob*)));
   }
   return true;
 }
 
 bool WebPriceQuote::launchNative(const QString& _webID, const QString& _kmmID, const QString& _sourcename)
 {
   d->m_webID = _webID;
   d->m_kmmID = _kmmID;
 
   if (_webID == i18n("[No identifier]")) {
     emit error(i18n("<placeholder>%1</placeholder> skipped because it doesn't have identification number.", _kmmID));
     emit failed(d->m_kmmID, d->m_webID);
     return false;
   }
 //   emit status(QString("(Debug) symbol=%1 id=%2...").arg(_symbol,_id));
 
   // Get sources from the config file
   QString sourcename = _sourcename;
   if (sourcename.isEmpty())
     sourcename = "Yahoo";
 
   if (quoteSources().contains(sourcename))
     d->m_source = WebPriceQuoteSource(sourcename);
   else {
     emit error(i18n("Source <placeholder>%1</placeholder> does not exist.", sourcename));
     emit failed(d->m_kmmID, d->m_webID);
     return false;
   }
 
   QUrl url;
 
   // if the source has room for TWO symbols..
   if (d->m_source.m_url.contains("%2")) {
     // this is a two-symbol quote.  split the symbol into two.  valid symbol
     // characters are: 0-9, A-Z and the dot.  anything else is a separator
     QRegularExpression splitrx("([0-9a-z\\.]+)[^a-z0-9]+([0-9a-z\\.]+)", QRegularExpression::CaseInsensitiveOption);
     QRegularExpressionMatch match;
     // if we've truly found 2 symbols delimited this way...
     if (d->m_webID.indexOf(splitrx, 0, &match) != -1) {
       url = QUrl(d->m_source.m_url.arg(match.captured(1), match.captured(2)));
     } else {
       qCDebug(WEBPRICEQUOTE) << "WebPriceQuote::launch() did not find 2 symbols";
     }
   } else {
     // a regular one-symbol quote
     url = QUrl(d->m_source.m_url.arg(d->m_webID));
   }
 
   if (url.isLocalFile()) {
     emit status(i18nc("The process x is executing", "Executing %1...", url.toLocalFile()));
 
     QString program;
     QStringList arguments = url.toLocalFile().split(' ', QString::SkipEmptyParts);
     if (!arguments.isEmpty()) {
         program = arguments.first();
         arguments.removeFirst();
     }
     d->m_filter.setWebID(d->m_webID);
 
     d->m_filter.setProcessChannelMode(QProcess::MergedChannels);
     d->m_filter.start(program, arguments);
 
     if (!d->m_filter.waitForStarted()) {
       emit error(i18n("Unable to launch: %1", url.toLocalFile()));
       slotParseQuote(QString());
     }
   } else {
     //silent download
     emit status(i18n("Fetching URL %1...", url.toDisplayString()));
     QString tmpFile;
     {
       QTemporaryFile tmpFileFile;
       tmpFileFile.setAutoRemove(false);
       if (tmpFileFile.open())
           qDebug() << "created tmpfile";
 
       tmpFile = tmpFileFile.fileName();
     }
     QFile::remove(tmpFile);
     const QUrl dest = QUrl::fromLocalFile(tmpFile);
     KIO::Scheduler::checkSlaveOnHold(true);
     KIO::Job *job = KIO::file_copy(url, dest, -1, KIO::HideProgressInfo);
     connect(job, SIGNAL(result(KJob*)),
             this, SLOT(downloadResult(KJob*)));
   }
   return true;
 }
 
 void WebPriceQuote::downloadCSV(KJob* job)
 {
   QString tmpFile = dynamic_cast<KIO::FileCopyJob*>(job)->destUrl().toLocalFile();
   QUrl url = dynamic_cast<KIO::FileCopyJob*>(job)->srcUrl();
   if (!job->error())
   {
     qDebug() << "Downloaded" << tmpFile << "from" << url;
     QFile f(tmpFile);
     if (f.open(QIODevice::ReadOnly)) {
       f.close();
       slotParseCSVQuote(tmpFile);
     } else {
       emit error(i18n("Failed to open downloaded file"));
       slotParseCSVQuote(QString());
     }
   } else {
     emit error(job->errorString());
     slotParseCSVQuote(QString());
   }
 }
 
 void WebPriceQuote::downloadResult(KJob* job)
 {
   QString tmpFile = dynamic_cast<KIO::FileCopyJob*>(job)->destUrl().toLocalFile();
   QUrl url = dynamic_cast<KIO::FileCopyJob*>(job)->srcUrl();
   if (!job->error())
   {
     qDebug() << "Downloaded" << tmpFile << "from" << url;
     QFile f(tmpFile);
     if (f.open(QIODevice::ReadOnly)) {
       // Find out the page encoding and convert it to unicode
       QByteArray page = f.readAll();
       KEncodingProber prober(KEncodingProber::Universal);
       prober.feed(page);
       QTextCodec* codec = QTextCodec::codecForName(prober.encoding());
       if (!codec)
           codec = QTextCodec::codecForLocale();
       QString quote = codec->toUnicode(page);
       f.close();
       slotParseQuote(quote);
     } else {
       emit error(i18n("Failed to open downloaded file"));
       slotParseQuote(QString());
     }
     QFile::remove(tmpFile);
   } else {
     emit error(job->errorString());
     slotParseQuote(QString());
   }
 }
 
 bool WebPriceQuote::launchFinanceQuote(const QString& _webID, const QString& _kmmID,
                                        const QString& _sourcename)
 {
   bool result = true;
   d->m_webID = _webID;
   d->m_kmmID = _kmmID;
   QString FQSource = _sourcename.section(' ', 1);
   d->m_source = WebPriceQuoteSource(_sourcename, m_financeQuoteScriptPath, m_financeQuoteScriptPath,
                                     "\"([^,\"]*)\",.*",  // webIDRegExp
                                     WebPriceQuoteSource::identifyBy::Symbol,
                                     "[^,]*,[^,]*,\"([^\"]*)\"", // price regexp
                                     "[^,]*,([^,]*),.*", // date regexp
                                     "%y-%m-%d"); // date format
 
   //emit status(QString("(Debug) symbol=%1 id=%2...").arg(_symbol,_id));
 
   QStringList arguments;
   arguments << m_financeQuoteScriptPath << FQSource << KShell::quoteArg(_webID);
   d->m_filter.setWebID(d->m_webID);
   emit status(i18nc("Executing 'script' 'online source' 'investment symbol' ", "Executing %1 %2 %3...", m_financeQuoteScriptPath, FQSource, _webID));
 
   d->m_filter.setProcessChannelMode(QProcess::MergedChannels);
   d->m_filter.start(QLatin1Literal("perl"), arguments);
 
   // This seems to work best if we just block until done.
   if (d->m_filter.waitForFinished()) {
     result = true;
   } else {
     emit error(i18n("Unable to launch: %1", m_financeQuoteScriptPath));
     slotParseQuote(QString());
   }
 
   return result;
 }
 
 void WebPriceQuote::slotParseCSVQuote(const QString& filename)
 {
   bool isOK = true;
   if (filename.isEmpty())
     isOK = false;
   else {
     MyMoneyStatement st;
     CSVImporterCore* csvImporter = new CSVImporterCore;
     st = csvImporter->unattendedImport(filename, &d->m_CSVSource);
     if (!st.m_listPrices.isEmpty())
       emit csvquote(d->m_kmmID, d->m_webID, st);
     else
       isOK = false;
     delete csvImporter;
     QFile::remove(filename);
   }
 
   if (!isOK) {
     emit error(i18n("Unable to update price for %1", d->m_webID));
     emit failed(d->m_kmmID, d->m_webID);
   }
 }
 
 void WebPriceQuote::slotParseQuote(const QString& _quotedata)
 {
   QString quotedata = _quotedata;
   d->m_quoteData = quotedata;
   bool gotprice = false;
   bool gotdate = false;
 
   qCDebug(WEBPRICEQUOTE) << "quotedata" << _quotedata;
 
   if (! quotedata.isEmpty()) {
     if (!d->m_source.m_skipStripping) {
       // First, remove extranous non-data elements
 
       // HTML tags
       quotedata.remove(QRegularExpression("<[^>]*>"));
 
       // &...;'s
       quotedata.replace(QRegularExpression("&\\w+;"), QLatin1String(" "));
 
       // Extra white space
       quotedata = quotedata.simplified();
       qCDebug(WEBPRICEQUOTE) << "stripped text" << quotedata;
     }
 
     QRegularExpression webIDRegExp(d->m_source.m_webID);
     QRegularExpression dateRegExp(d->m_source.m_date);
     QRegularExpression priceRegExp(d->m_source.m_price);
     QRegularExpressionMatch match;
 
     if (quotedata.indexOf(webIDRegExp, 0, &match) > -1) {
       qCDebug(WEBPRICEQUOTE) << "Identifier" << match.captured(1);
       emit status(i18n("Identifier found: '%1'", match.captured(1)));
     }
 
     if (quotedata.indexOf(priceRegExp, 0, &match) > -1) {
       gotprice = true;
 
       // Deal with european quotes that come back as X.XXX,XX or XX,XXX
       //
       // We will make the assumption that ALL prices have a decimal separator.
       // So "1,000" always means 1.0, not 1000.0.
       //
       // Remove all non-digits from the price string except the last one, and
       // set the last one to a period.
       QString pricestr = match.captured(1);
 
       int pos = pricestr.lastIndexOf(QRegularExpression("\\D"));
       if (pos > 0) {
         pricestr[pos] = QLatin1Char('.');
         pos = pricestr.lastIndexOf(QRegularExpression("\\D"), pos - 1);
       }
       while (pos > 0) {
         pricestr.remove(pos, 1);
         pos = pricestr.lastIndexOf(QRegularExpression("\\D"), pos);
       }
 
       d->m_price = pricestr.toDouble();
       qCDebug(WEBPRICEQUOTE) << "Price" << pricestr;
       emit status(i18n("Price found: '%1' (%2)", pricestr, d->m_price));
     }
 
     if (quotedata.indexOf(dateRegExp, 0, &match) > -1) {
       QString datestr = match.captured(1);
 
       MyMoneyDateFormat dateparse(d->m_source.m_dateformat);
       try {
         d->m_date = dateparse.convertString(datestr, false /*strict*/);
         gotdate = true;
         qCDebug(WEBPRICEQUOTE) << "Date" << datestr;
         emit status(i18n("Date found: '%1'", d->m_date.toString()));;
       } catch (const MyMoneyException &) {
         // emit error(i18n("Unable to parse date %1 using format %2: %3").arg(datestr,dateparse.format(),e.what()));
         d->m_date = QDate::currentDate();
         gotdate = true;
       }
     }
 
     if (gotprice && gotdate) {
       emit quote(d->m_kmmID, d->m_webID, d->m_date, d->m_price);
     } else {
       emit error(i18n("Unable to update price for %1 (no price or no date)", d->m_webID));
       emit failed(d->m_kmmID, d->m_webID);
     }
   } else {
     emit error(i18n("Unable to update price for %1 (empty quote data)", d->m_webID));
     emit failed(d->m_kmmID, d->m_webID);
   }
 }
 
 const QMap<QString, PricesProfile> WebPriceQuote::defaultCSVQuoteSources()
 {
   QMap<QString, PricesProfile> result;
 
   // tip: possible delimiter indexes are in csvenums.h
 
   result[QLatin1String("Stooq")] = PricesProfile(QLatin1String("Stooq"),
                                                  106, 1, 0, DateFormat::YearMonthDay, FieldDelimiter::Semicolon,
                                                  TextDelimiter::DoubleQuote, DecimalSymbol::Dot,
                                                  QMap<Column, int>{{Column::Date, 0}, {Column::Price, 4}},
                                                  2, Profile::StockPrices);
 
   result[QLatin1String("Stooq Currency")] = PricesProfile(QLatin1String("Stooq Currency"),
                                                           106, 1, 0, DateFormat::YearMonthDay, FieldDelimiter::Semicolon,
                                                           TextDelimiter::DoubleQuote, DecimalSymbol::Dot,
                                                           QMap<Column, int>{{Column::Date, 0}, {Column::Price, 4}},
                                                           2, Profile::CurrencyPrices);
 
   result[QLatin1String("Yahoo")] = PricesProfile(QLatin1String("Yahoo"),
                                                  106, 1, 0, DateFormat::YearMonthDay, FieldDelimiter::Comma,
                                                  TextDelimiter::DoubleQuote, DecimalSymbol::Dot,
                                                  QMap<Column, int>{{Column::Date, 0}, {Column::Price, 4}},
                                                  2, Profile::StockPrices);
 
   result[QLatin1String("Nasdaq Baltic - Shares")] = PricesProfile(QLatin1String("Nasdaq Baltic - Shares"),
                                                                   106, 1, 0, DateFormat::DayMonthYear, FieldDelimiter::Tab,
                                                                   TextDelimiter::DoubleQuote, DecimalSymbol::Dot,
                                                                   QMap<Column, int>{{Column::Date, 0}, {Column::Price, 5}},
                                                                   2, Profile::StockPrices);
 
   result[QLatin1String("Nasdaq Baltic - Funds")] = PricesProfile(QLatin1String("Nasdaq Baltic - Funds"),
                                                                  106, 1, 0, DateFormat::DayMonthYear, FieldDelimiter::Tab,
                                                                  TextDelimiter::DoubleQuote, DecimalSymbol::Dot,
                                                                  QMap<Column, int>{{Column::Date, 0}, {Column::Price, 5}},
                                                                  2, Profile::StockPrices);
   return result;
 }
 
 const QMap<QString, WebPriceQuoteSource> WebPriceQuote::defaultQuoteSources()
 {
   QMap<QString, WebPriceQuoteSource> result;
 
   // Use fx-rate.net as the standard currency exchange rate source until
   // we have the capability to use more than one source. Use a neutral
   // name for the source.
   result["KMyMoney Currency"] = WebPriceQuoteSource("KMyMoney Currency",
                                           "https://fx-rate.net/%1/%2",
                                           QString(),
                                           "https://fx-rate.net/([^/]+/[^/]+)",
                                           WebPriceQuoteSource::identifyBy::Symbol,
                                           "1\\s[^=]+\\s=</span><br\\s/>\\s([^\\s]+)",
                                           "updated\\s\\d+:\\d+:\\d+\\(\\w+\\)\\s+(\\d{1,2}/\\d{2}/\\d{4})",
                                           "%d/%m/%y",
                                           true // skip HTML stripping
                                        );
 
   // Update on 2017-06 by Łukasz Wojniłowicz
   result["Globe & Mail"] = WebPriceQuoteSource("Globe & Mail",
                                                "http://globefunddb.theglobeandmail.com/gishome/plsql/gis.price_history?pi_fund_id=%1",
                                                QString(),
                                                QString(),  // webIDRegExp
                                                WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                                "Fund Price:\\D+(\\d+\\.\\d+)", // priceregexp
                                                "Fund Price:.+as at (\\w+ \\d+, \\d+)\\)", // dateregexp
                                                "%m %d %y" // dateformat
                                                );
 
   // Update on 2017-06 by Łukasz Wojniłowicz
   result["MSN"] = WebPriceQuoteSource("MSN",
                                       "http://www.msn.com/en-us/money/stockdetails/%1",
                                       QString(),
                                       QString(),  // webIDRegExp
                                       WebPriceQuoteSource::identifyBy::Symbol,
                                       "(\\d+\\.\\d+) [+-]\\d+.\\d+", // priceregexp
                                       "(\\d+/\\d+/\\d+)", //dateregexp
                                       "%y %m %d" // dateformat
                                       );
 
   // Finanztreff (replaces VWD.DE) supplied by Michael Zimmerman
   result["Finanztreff"] = WebPriceQuoteSource("Finanztreff",
                                               "http://finanztreff.de/kurse_einzelkurs_detail.htn?u=100&i=%1",
                                               "",
                                               QString(),  // webIDRegExp
                                               WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                               "([0-9]+,\\d+).+Gattung:Fonds", // priceregexp
                                               "\\).(\\d+\\D+\\d+\\D+\\d+)", // dateregexp (doesn't work; date in chart
                                               "%d.%m.%y" // dateformat
                                               );
 
   // First revision by Michael Zimmerman
   // Update on 2017-06 by Łukasz Wojniłowicz
   result["boerseonlineaktien"] = WebPriceQuoteSource("Börse Online - Aktien",
                                                "http://www.boerse-online.de/aktie/%1-Aktie",
                                                QString(),
                                                QString(),  // webIDRegExp
                                                WebPriceQuoteSource::identifyBy::Name,
                                                "Aktienkurs\\D+(\\d+,\\d{2})", // priceregexp
                                                "Datum (\\d{2}\\.\\d{2}\\.\\d{4})", // dateregexp
                                                "%d.%m.%y" // dateformat
                                                );
 
   // This quote source provided by e-mail and should replace the previous one:
   // From: David Houlden <djhoulden@gmail.com>
   // To: kmymoney@kde.org
   // Date: Sat, 6 Apr 2013 13:22:45 +0100
   // Updated on 2017-06 by Łukasz Wojniłowicz
   result["Financial Times - UK Funds"] = WebPriceQuoteSource("Financial Times",
                                                            "http://funds.ft.com/uk/Tearsheet/Summary?s=%1",
                                                            QString(),
                                                            QString(), // webIDRegExp
                                                            WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                                            "Price\\D+([\\d,]*\\d+\\.\\d+)", // price regexp
                                                            "Data delayed at least 15 minutes, as of\\ (.*)\\.", // date regexp
                                                            "%m %d %y", // date format
                                                            true // skip HTML stripping
                                                            );
 
   // The following two price sources were contributed by
   // Marc Zahnlecker <tf2k@users.sourceforge.net>
 
   result["Wallstreet-Online.DE (Default)"] = WebPriceQuoteSource("Wallstreet-Online.DE (Default)",
                                                                  "http://www.wallstreet-online.de/si/?k=%1&spid=ws",
                                                                  "",
                                                                  "Symbol:(\\w+)",  // webIDRegExp
                                                                  WebPriceQuoteSource::identifyBy::Symbol,
                                                                  "Letzter Kurs: ([0-9.]+,\\d+)", // priceregexp
                                                                  ", (\\d+\\D+\\d+\\D+\\d+)", // dateregexp
                                                                  "%d %m %y" // dateformat
                                                                  );
 
   // (tf2k) The "mpid" is I think the market place id. In this case five
   // stands for Hamburg.
   //
   // Here the id for several market places: 2 Frankfurt, 3 Berlin, 4
   // Düsseldorf, 5 Hamburg, 6 München/Munich, 7 Hannover, 9 Stuttgart, 10
   // Xetra, 32 NASDAQ, 36 NYSE
 
   result["Wallstreet-Online.DE (Hamburg)"] = WebPriceQuoteSource("Wallstreet-Online.DE (Hamburg)",
                                                                  "http://fonds.wallstreet-online.de/si/?k=%1&spid=ws&mpid=5",
                                                                  "",
                                                                  "Symbol:(\\w+)",  // webIDRegExp
                                                                  WebPriceQuoteSource::identifyBy::Symbol,
                                                                  "Fonds \\(EUR\\) ([0-9.]+,\\d+)", // priceregexp
                                                                  ", (\\d+\\D+\\d+\\D+\\d+)", // dateregexp
                                                                  "%d %m %y" // dateformat
                                                                  );
   // First revision on 2017-06 by Łukasz Wojniłowicz
   result["Puls Biznesu"] = WebPriceQuoteSource("Puls Biznesu",
                                         "http://notowania.pb.pl/instrument/%1",
                                         QString(),
                                         QString(),                   // webIDRegExp
                                         WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                         "(\\d+,\\d{2})\\D+\\d+,\\d{2}%",    // price regexp
                                         "(\\d{4}-\\d{2}-\\d{2}) \\d{2}:\\d{2}:\\d{2}", // date regexp
                                         "%y %m %d"                   // date format
                                         );
 
   // The following price quote was contributed by
   // Piotr Adacha <piotr.adacha@googlemail.com>
 
   // I would like to post new Online Query Settings for KMyMoney. This set is
   // suitable to query stooq.com service, providing quotes for stocks, futures,
   // mutual funds and other financial instruments from Polish Gielda Papierow
   // Wartosciowych (GPW). Unfortunately, none of well-known international
   // services provide quotes for this market (biggest one in central and eastern
   // Europe), thus, I think it could be helpful for Polish users of KMyMoney (and
   // I am one of them for almost a year).
 
   // Update on 2017-06 by Łukasz Wojniłowicz
   result["Stooq"] = WebPriceQuoteSource("Stooq",
                                         "http://stooq.com/q/?s=%1",
                                         "http://stooq.pl/q/d/l/?s=%1&d1=%y%m%d&d2=%y%m%d&i=d&c=1",
                                         QString(),                   // webIDRegExp
                                         WebPriceQuoteSource::identifyBy::Symbol,
                                         "Last(\\d+\\.\\d+).*Date",    // price regexp
                                         "(\\d{4,4}-\\d{2,2}-\\d{2,2})", // date regexp
                                         "%y %m %d"                   // date format
                                         );
 
   // First revision on 2017-06 by Łukasz Wojniłowicz
   result[QLatin1String("Stooq Currency")] = WebPriceQuoteSource("Stooq Currency",
                                                                 "http://stooq.com/q/?s=%1%2",
                                                                 "http://stooq.pl/q/d/l/?s=%1%2&d1=%y%m%d&d2=%y%m%d&i=d&c=1",
                                                                 QString(),                   // webIDRegExp
                                                                 WebPriceQuoteSource::identifyBy::Symbol,
                                                                 "Last.*(\\d+\\.\\d+).*Date",    // price regexp
                                                                 "(\\d{4,4}-\\d{2,2}-\\d{2,2})", // date regexp
                                                                 "%y %m %d"                   // date format
                                                                 );
 
   // First revision on 2017-06 by Łukasz Wojniłowicz
   result["Nasdaq Baltic - Shares"] = WebPriceQuoteSource("Nasdaq Baltic - Shares",
                                                          "http://www.nasdaqbaltic.com/market/?pg=details&instrument=%1&lang=en",
                                                          "http://www.nasdaqbaltic.com/market/?instrument=%1&pg=details&tab=historical&lang=en&date=&start=%d.%m.%y&end=%d.%m.%y&pg=details&pg2=equity&downloadcsv=1&csv_style=english",
                                                          QString(),  // webIDRegExp
                                                          WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                                          "lastPrice\\D+(\\d+,\\d+)",  // priceregexp
                                                          "as of: (\\d{2}.\\d{2}.\\d{4})",  // dateregexp
                                                          "%d.%m.%y",   // dateformat
                                                          true
                                                          );
 
   // First revision on 2017-06 by Łukasz Wojniłowicz
   result["Nasdaq Baltic - Funds"] = WebPriceQuoteSource("Nasdaq Baltic - Funds",
                                                         "http://www.nasdaqbaltic.com/market/?pg=details&instrument=%1&lang=en",
                                                         "http://www.nasdaqbaltic.com/market/?instrument=%1&pg=details&tab=historical&lang=en&date=&start=%d.%m.%y&end=%d.%m.%y&pg=details&pg2=equity&downloadcsv=1&csv_style=english",
                                                         QString(),  // webIDRegExp
                                                         WebPriceQuoteSource::identifyBy::IdentificationNumber,
                                                         "marketShareDetailTable(.+\\n){21}\\D+(\\d+)",  // priceregexp
                                                         "as of: (\\d{2}.\\d{2}.\\d{4})",  // dateregexp
                                                         "%d.%m.%y",   // dateformat
                                                         true
                                                         );
   return result;
 }
 
 const QStringList WebPriceQuote::quoteSources(const _quoteSystemE _system)
 {
   if (_system == Native)
     return (quoteSourcesNative());
   else
     return (quoteSourcesFinanceQuote());
 }
 
 const QStringList WebPriceQuote::quoteSourcesNative()
 {
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   QStringList groups = kconfig->groupList();
 
   QStringList::Iterator it;
   QRegularExpression onlineQuoteSource(QString("^Online-Quote-Source-(.*)$"));
   QRegularExpressionMatch match;
 
   // get rid of all 'non online quote source' entries
   for (it = groups.begin(); it != groups.end(); it = groups.erase(it)) {
     if ((*it).indexOf(onlineQuoteSource, 0, &match) >= 0) {
       // Insert the name part
       it = groups.insert(it, match.captured(1));
       ++it;
     }
   }
 
   // if the user has the OLD quote source defined, now is the
   // time to remove that entry and convert it to the new system.
   if (! groups.count() && kconfig->hasGroup("Online Quotes Options")) {
     KConfigGroup grp = kconfig->group("Online Quotes Options");
     QString url(grp.readEntry("URL", "http://finance.yahoo.com/d/quotes.csv?s=%1&f=sl1d1"));
     QString webIDRegExp(grp.readEntry("SymbolRegex", "\"([^,\"]*)\",.*"));
     QString priceRegExp(grp.readEntry("PriceRegex", "[^,]*,([^,]*),.*"));
     QString dateRegExp(grp.readEntry("DateRegex", "[^,]*,[^,]*,\"([^\"]*)\""));
     kconfig->deleteGroup("Online Quotes Options");
 
     groups += "Old Source";
     grp = kconfig->group(QString(QLatin1String("Online-Quote-Source-%1")).arg("Old Source"));
     grp.writeEntry("URL", url);
     grp.writeEntry("CSVURL", "http://finance.yahoo.com/d/quotes.csv?s=%1&f=sl1d1");
     grp.writeEntry("IDRegex", webIDRegExp);
     grp.writeEntry("PriceRegex", priceRegExp);
     grp.writeEntry("DateRegex", dateRegExp);
     grp.writeEntry("DateFormatRegex", "%m %d %y");
     grp.sync();
   }
 
   // if the user has OLD quote source based only on symbols (and not ISIN)
   // now is the time to convert it to the new system.
   foreach (const auto group, groups) {
     KConfigGroup grp = kconfig->group(QString(QLatin1String("Online-Quote-Source-%1")).arg(group));
     if (grp.hasKey("SymbolRegex")) {
       grp.writeEntry("IDRegex", grp.readEntry("SymbolRegex"));
       grp.deleteEntry("SymbolRegex");
     } else
       break;
   }
 
   // Set up each of the default sources.  These are done piecemeal so that
   // when we add a new source, it's automatically picked up. And any changes
   // are also picked up.
   QMap<QString, WebPriceQuoteSource> defaults = defaultQuoteSources();
   QMap<QString, WebPriceQuoteSource>::const_iterator it_source = defaults.constBegin();
   while (it_source != defaults.constEnd()) {
     if (! groups.contains((*it_source).m_name)) {
       groups += (*it_source).m_name;
       (*it_source).write();
       kconfig->sync();
     }
     ++it_source;
   }
 
   return groups;
 }
 
 const QStringList WebPriceQuote::quoteSourcesFinanceQuote()
 {
   if (m_financeQuoteSources.empty()) { // run the process one time only
     // since this is a static function it can be called without constructing an object
     // so we need to make sure that m_financeQuoteScriptPath is properly initialized
     if (m_financeQuoteScriptPath.isEmpty()) {
       m_financeQuoteScriptPath = QStandardPaths::locate(QStandardPaths::DataLocation, QString("misc/financequote.pl"));
     }
     FinanceQuoteProcess getList;
     getList.launch(m_financeQuoteScriptPath);
     while (!getList.isFinished()) {
       QCoreApplication::processEvents();
     }
     m_financeQuoteSources = getList.getSourceList();
   }
   return (m_financeQuoteSources);
 }
 
 //
 // Helper class to load/save an individual source
 //
 
 WebPriceQuoteSource::WebPriceQuoteSource(const QString& name, const QString& url, const QString &csvUrl, const QString& id, const identifyBy idBy, const QString& price, const QString& date, const QString& dateformat, bool skipStripping):
     m_name(name),
     m_url(url),
     m_csvUrl(csvUrl),
     m_webID(id),
     m_webIDBy(idBy),
     m_price(price),
     m_date(date),
     m_dateformat(dateformat),
     m_skipStripping(skipStripping)
 { }
 
 WebPriceQuoteSource::WebPriceQuoteSource(const QString& name)
 {
   m_name = name;
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   KConfigGroup grp = kconfig->group(QString("Online-Quote-Source-%1").arg(m_name));
   m_webID = grp.readEntry("IDRegex");
   m_webIDBy = static_cast<WebPriceQuoteSource::identifyBy>(grp.readEntry("IDBy", "0").toInt());
   m_date = grp.readEntry("DateRegex");
   m_dateformat = grp.readEntry("DateFormatRegex", "%m %d %y");
   m_price = grp.readEntry("PriceRegex");
   m_url = grp.readEntry("URL");
   m_csvUrl = grp.readEntry("CSVURL");
   m_skipStripping = grp.readEntry("SkipStripping", false);
 }
 
 void WebPriceQuoteSource::write() const
 {
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   KConfigGroup grp = kconfig->group(QString("Online-Quote-Source-%1").arg(m_name));
   grp.writeEntry("URL", m_url);
   grp.writeEntry("CSVURL", m_csvUrl);
   grp.writeEntry("PriceRegex", m_price);
   grp.writeEntry("DateRegex", m_date);
   grp.writeEntry("DateFormatRegex", m_dateformat);
   grp.writeEntry("IDRegex", m_webID);
   grp.writeEntry("IDBy", static_cast<int>(m_webIDBy));
   if (m_skipStripping)
     grp.writeEntry("SkipStripping", m_skipStripping);
   else
     grp.deleteEntry("SkipStripping");
   kconfig->sync();
 }
 
 void WebPriceQuoteSource::rename(const QString& name)
 {
   remove();
   m_name = name;
   write();
 }
 
 void WebPriceQuoteSource::remove() const
 {
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   kconfig->deleteGroup(QString("Online-Quote-Source-%1").arg(m_name));
   kconfig->sync();
 }
 
 //
 // Helper class to babysit the KProcess used for running the local script in that case
 //
 
 WebPriceQuoteProcess::WebPriceQuoteProcess()
 {
   connect(this, SIGNAL(readyReadStandardOutput()), this, SLOT(slotReceivedDataFromFilter()));
   connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotProcessExited(int,QProcess::ExitStatus)));
 }
 
 void WebPriceQuoteProcess::slotReceivedDataFromFilter()
 {
 //   qDebug() << "WebPriceQuoteProcess::slotReceivedDataFromFilter(): " << QString(data);
   m_string += QString(readAllStandardOutput());
 }
 
 void WebPriceQuoteProcess::slotProcessExited(int /*exitCode*/, QProcess::ExitStatus /*exitStatus*/)
 {
 //   qDebug() << "WebPriceQuoteProcess::slotProcessExited()";
   emit processExited(m_string);
   m_string.truncate(0);
 }
 
 //
 // Helper class to babysit the KProcess used for running the Finance Quote sources script
 //
 
 FinanceQuoteProcess::FinanceQuoteProcess()
 {
   m_isDone = false;
   m_string = "";
   m_fqNames["aex"] = "AEX";
   m_fqNames["aex_futures"] = "AEX Futures";
   m_fqNames["aex_options"] = "AEX Options";
   m_fqNames["amfiindia"] = "AMFI India";
   m_fqNames["asegr"] = "ASE";
   m_fqNames["asia"] = "Asia (Yahoo, ...)";
   m_fqNames["asx"] = "ASX";
   m_fqNames["australia"] = "Australia (ASX, Yahoo, ...)";
   m_fqNames["bmonesbittburns"] = "BMO NesbittBurns";
   m_fqNames["brasil"] = "Brasil (Yahoo, ...)";
   m_fqNames["canada"] = "Canada (Yahoo, ...)";
   m_fqNames["canadamutual"] = "Canada Mutual (Fund Library, ...)";
   m_fqNames["deka"] = "Deka Investments";
   m_fqNames["dutch"] = "Dutch (AEX, ...)";
   m_fqNames["dwsfunds"] = "DWS";
   m_fqNames["europe"] = "Europe (Yahoo, ...)";
   m_fqNames["fidelity"] = "Fidelity (Fidelity, ...)";
   m_fqNames["fidelity_direct"] = "Fidelity Direct";
   m_fqNames["financecanada"] = "Finance Canada";
   m_fqNames["ftportfolios"] = "First Trust (First Trust, ...)";
   m_fqNames["ftportfolios_direct"] = "First Trust Portfolios";
   m_fqNames["fundlibrary"] = "Fund Library";
   m_fqNames["greece"] = "Greece (ASE, ...)";
   m_fqNames["indiamutual"] = "India Mutual (AMFI, ...)";
   m_fqNames["maninv"] = "Man Investments";
   m_fqNames["fool"] = "Motley Fool";
   m_fqNames["nasdaq"] = "Nasdaq (Yahoo, ...)";
   m_fqNames["nz"] = "New Zealand (Yahoo, ...)";
   m_fqNames["nyse"] = "NYSE (Yahoo, ...)";
   m_fqNames["nzx"] = "NZX";
   m_fqNames["platinum"] = "Platinum Asset Management";
   m_fqNames["seb_funds"] = "SEB";
   m_fqNames["sharenet"] = "Sharenet";
   m_fqNames["za"] = "South Africa (Sharenet, ...)";
   m_fqNames["troweprice_direct"] = "T. Rowe Price";
   m_fqNames["troweprice"] = "T. Rowe Price";
   m_fqNames["tdefunds"] = "TD Efunds";
   m_fqNames["tdwaterhouse"] = "TD Waterhouse Canada";
   m_fqNames["tiaacref"] = "TIAA-CREF";
   m_fqNames["trustnet"] = "Trustnet";
   m_fqNames["uk_unit_trusts"] = "U.K. Unit Trusts";
   m_fqNames["unionfunds"] = "Union Investments";
   m_fqNames["tsp"] = "US Govt. Thrift Savings Plan";
   m_fqNames["usfedbonds"] = "US Treasury Bonds";
   m_fqNames["usa"] = "USA (Yahoo, Fool ...)";
   m_fqNames["vanguard"] = "Vanguard";
   m_fqNames["vwd"] = "VWD";
   m_fqNames["yahoo"] = "Yahoo";
   m_fqNames["yahoo_asia"] = "Yahoo Asia";
   m_fqNames["yahoo_australia"] = "Yahoo Australia";
   m_fqNames["yahoo_brasil"] = "Yahoo Brasil";
   m_fqNames["yahoo_europe"] = "Yahoo Europe";
   m_fqNames["yahoo_nz"] = "Yahoo New Zealand";
   m_fqNames["zifunds"] = "Zuerich Investments";
   connect(this, SIGNAL(readyReadStandardOutput()), this, SLOT(slotReceivedDataFromFilter()));
   connect(this, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotProcessExited()));
   connect(this, SIGNAL(error(QProcess::ProcessError)), this, SLOT(slotProcessExited()));
 }
 
 void FinanceQuoteProcess::slotReceivedDataFromFilter()
 {
   QByteArray data(readAllStandardOutput());
 
 //   qDebug() << "WebPriceQuoteProcess::slotReceivedDataFromFilter(): " << QString(data);
   m_string += QString(data);
 }
 
 void FinanceQuoteProcess::slotProcessExited()
 {
 //   qDebug() << "WebPriceQuoteProcess::slotProcessExited()";
   m_isDone = true;
 }
 
 void FinanceQuoteProcess::launch(const QString& scriptPath)
 {
   QStringList arguments;
   arguments << scriptPath << QLatin1Literal("-l");
   setProcessChannelMode(QProcess::ForwardedOutputChannel);
   start(QLatin1Literal("perl"), arguments);
   if (! waitForStarted()) qWarning("Unable to start FQ script");
   return;
 }
 
 const QStringList FinanceQuoteProcess::getSourceList() const
 {
   QStringList raw = m_string.split(0x0A, QString::SkipEmptyParts);
   QStringList sources;
   QStringList::iterator it;
   for (it = raw.begin(); it != raw.end(); ++it) {
     if (m_fqNames[*it].isEmpty()) sources.append(*it);
     else sources.append(m_fqNames[*it]);
   }
   sources.sort();
   return (sources);
 }
 
 const QString FinanceQuoteProcess::crypticName(const QString& niceName) const
 {
   QString ret(niceName);
   fqNameMap::const_iterator it;
   for (it = m_fqNames.begin(); it != m_fqNames.end(); ++it) {
     if (niceName == it.value()) {
       ret = it.key();
       break;
     }
   }
   return (ret);
 }
 
 const QString FinanceQuoteProcess::niceName(const QString& crypticName) const
 {
   QString ret(m_fqNames[crypticName]);
   if (ret.isEmpty()) ret = crypticName;
   return (ret);
 }
 //
 // Universal date converter
 //
 
 // In 'strict' mode, this is designed to be compatable with the QIF profile date
 // converter.  However, that converter deals with the concept of an apostrophe
 // format in a way I don't understand.  So for the moment, they are 99%
 // compatable, waiting on that issue. (acejones)
 
 const QDate MyMoneyDateFormat::convertString(const QString& _in, bool _strict, unsigned _centurymidpoint) const
 {
   //
   // Break date format string into component parts
   //
 
   QRegularExpression formatrex("%([mdy]+)(\\W+)%([mdy]+)(\\W+)%([mdy]+)", QRegularExpression::CaseInsensitiveOption);
   QRegularExpressionMatch match;
   if (m_format.indexOf(formatrex, 0, &match) == -1) {
-    throw MYMONEYEXCEPTION("Invalid format string");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid format string");
   }
 
   QStringList formatParts;
   formatParts += match.captured(1);
   formatParts += match.captured(3);
   formatParts += match.captured(5);
 
   QStringList formatDelimiters;
   formatDelimiters += match.captured(2);
   formatDelimiters += match.captured(4);
   match = QRegularExpressionMatch();
 
   //
   // Break input string up into component parts,
   // using the delimiters found in the format string
   //
 
   QRegularExpression inputrex;
   inputrex.setPatternOptions(QRegularExpression::CaseInsensitiveOption);
 
   // strict mode means we must enforce the delimiters as specified in the
   // format.  non-strict allows any delimiters
   if (_strict)
     inputrex.setPattern(QString("(\\w+)%1(\\w+)%2(\\w+)").arg(formatDelimiters[0], formatDelimiters[1]));
   else
     inputrex.setPattern("(\\w+)\\W+(\\w+)\\W+(\\w+)");
 
   if (_in.indexOf(inputrex, 0, &match) == -1) {
-    throw MYMONEYEXCEPTION("Invalid input string");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid input string");
   }
 
   QStringList scannedParts;
   scannedParts += match.captured(1).toLower();
   scannedParts += match.captured(2).toLower();
   scannedParts += match.captured(3).toLower();
   match = QRegularExpressionMatch();
 
   //
   // Convert the scanned parts into actual date components
   //
   unsigned day = 0, month = 0, year = 0;
   bool ok;
   QRegularExpression digitrex("(\\d+)");
   QStringList::const_iterator it_scanned = scannedParts.constBegin();
   QStringList::const_iterator it_format = formatParts.constBegin();
   while (it_scanned != scannedParts.constEnd()) {
     // decide upon the first character of the part
     switch ((*it_format).at(0).cell()) {
       case 'd':
         // remove any extraneous non-digits (e.g. read "3rd" as 3)
         ok = false;
         if ((*it_scanned).indexOf(digitrex, 0, &match) != -1)
           day = match.captured(1).toUInt(&ok);
         if (!ok || day > 31)
-          throw MYMONEYEXCEPTION(QString("Invalid day entry: %1").arg(*it_scanned));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid day entry: %1").arg(*it_scanned));
         break;
       case 'm':
         month = (*it_scanned).toUInt(&ok);
         if (!ok) {
           month = 0;
           // maybe it's a textual date
           unsigned i = 1;
           // search the name in the current selected locale
           QLocale locale;
           while (i <= 12) {
             if (locale.standaloneMonthName(i).toLower() == *it_scanned
                 || locale.standaloneMonthName(i, QLocale::ShortFormat).toLower() == *it_scanned) {
               month = i;
               break;
             }
             ++i;
           }
           // in case we did not find the month in the current locale,
           // we look for it in the C locale
           if(month == 0) {
             QLocale localeC(QLocale::C);
             if( !(locale == localeC)) {
               i = 1;
               while (i <= 12) {
                 if (localeC.standaloneMonthName(i).toLower() == *it_scanned
                     || localeC.standaloneMonthName(i, QLocale::ShortFormat).toLower() == *it_scanned) {
                   month = i;
                   break;
                 }
                 ++i;
               }
             }
           }
         }
 
         if (month < 1 || month > 12)
-          throw MYMONEYEXCEPTION(QString("Invalid month entry: %1").arg(*it_scanned));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid month entry: %1").arg(*it_scanned));
 
         break;
       case 'y':
         if (_strict && (*it_scanned).length() != (*it_format).length())
-          throw MYMONEYEXCEPTION(QString("Length of year (%1) does not match expected length (%2).")
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Length of year (%1) does not match expected length (%2).")
                                  .arg(*it_scanned, *it_format));
 
         year = (*it_scanned).toUInt(&ok);
 
         if (!ok)
-          throw MYMONEYEXCEPTION(QString("Invalid year entry: %1").arg(*it_scanned));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid year entry: %1").arg(*it_scanned));
 
         //
         // 2-digit year case
         //
         // this algorithm will pick a year within +/- 50 years of the
         // centurymidpoint parameter.  i.e. if the midpoint is 2000,
         // then 0-49 will become 2000-2049, and 50-99 will become 1950-1999
         if (year < 100) {
           unsigned centuryend = _centurymidpoint + 50;
           unsigned centurybegin = _centurymidpoint - 50;
 
           if (year < centuryend % 100)
             year += 100;
           year += centurybegin - centurybegin % 100;
         }
 
         if (year < 1900)
-          throw MYMONEYEXCEPTION(QString("Invalid year (%1)").arg(year));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid year (%1)").arg(year));
 
         break;
       default:
-        throw MYMONEYEXCEPTION("Invalid format character");
+        throw MYMONEYEXCEPTION_CSTRING("Invalid format character");
     }
 
     ++it_scanned;
     ++it_format;
   }
   QDate result(year, month, day);
   if (! result.isValid())
-    throw MYMONEYEXCEPTION(QString("Invalid date (yr%1 mo%2 dy%3)").arg(year).arg(month).arg(day));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid date (yr%1 mo%2 dy%3)").arg(year).arg(month).arg(day));
 
   return result;
 }
 
 //
 // Unit test helpers
 //
 
 convertertest::QuoteReceiver::QuoteReceiver(WebPriceQuote* q, QObject* parent) :
     QObject(parent)
 {
   connect(q, SIGNAL(quote(QString,QString,QDate,double)),
           this, SLOT(slotGetQuote(QString,QString,QDate,double)));
   connect(q, SIGNAL(status(QString)),
           this, SLOT(slotStatus(QString)));
   connect(q, SIGNAL(error(QString)),
           this, SLOT(slotError(QString)));
 }
 
 convertertest::QuoteReceiver::~QuoteReceiver()
 {
 }
 
 void convertertest::QuoteReceiver::slotGetQuote(const QString&, const QString&, const QDate& d, const double& m)
 {
 //   qDebug() << "test::QuoteReceiver::slotGetQuote( , " << d << " , " << m.toString() << " )";
 
   m_price = MyMoneyMoney(m);
   m_date = d;
 }
 
 void convertertest::QuoteReceiver::slotStatus(const QString& msg)
 {
 //   qDebug() << "test::QuoteReceiver::slotStatus( " << msg << " )";
 
   m_statuses += msg;
 }
 
 void convertertest::QuoteReceiver::slotError(const QString& msg)
 {
 //   qDebug() << "test::QuoteReceiver::slotError( " << msg << " )";
 
   m_errors += msg;
 }
 
 // leave this moc until we will have resolved our dependency issues
 // now 'converter' depends on 'kmymoney' a pointer to the application
 // defined in main.cpp, which makes this static library unusable without
 // the --as-needed linker flag;
 // otherwise the 'moc' methods of this object will be linked into the automoc
 // object file which contains methods from all the other objects from this
 // library, thus even if the --as-needed option is used all objects will be
 // pulled in while linking 'convertertest' which only needs the WebPriceQuote
 // object - spent a whole day investigating this
 #include "moc_webpricequote.cpp"
diff --git a/kmymoney/dialogs/kconfirmmanualenterdlg.cpp b/kmymoney/dialogs/kconfirmmanualenterdlg.cpp
index a4f097ec0..24e6aa152 100644
--- a/kmymoney/dialogs/kconfirmmanualenterdlg.cpp
+++ b/kmymoney/dialogs/kconfirmmanualenterdlg.cpp
@@ -1,193 +1,193 @@
 /***************************************************************************
                           kconfirmmanualenterdlg.cpp
                              -------------------
     begin                : Mon Apr  9 2007
     copyright            : (C) 2007 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kconfirmmanualenterdlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QButtonGroup>
 #include <QRadioButton>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KTextEdit>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kconfirmmanualenterdlg.h"
 
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneypayee.h"
 #include "mymoneysplit.h"
 #include "mymoneyschedule.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "mymoneytransaction.h"
 #include "mymoneyenums.h"
 
 KConfirmManualEnterDlg::KConfirmManualEnterDlg(const MyMoneySchedule& schedule, QWidget* parent) :
     QDialog(parent),
     ui(new Ui::KConfirmManualEnterDlg)
 {
   ui->setupUi(this);
   ui->buttonGroup1->setId(ui->m_discardRadio, 0);
   ui->buttonGroup1->setId(ui->m_onceRadio, 1);
   ui->buttonGroup1->setId(ui->m_setRadio, 2);
 
   ui->m_onceRadio->setChecked(true);
 
   if (schedule.type() == eMyMoney::Schedule::Type::LoanPayment) {
     ui->m_setRadio->setEnabled(false);
     ui->m_discardRadio->setEnabled(false);
   }
 }
 
 KConfirmManualEnterDlg::~KConfirmManualEnterDlg()
 {
   delete ui;
 }
 
 void KConfirmManualEnterDlg::loadTransactions(const MyMoneyTransaction& to, const MyMoneyTransaction& tn)
 {
   QString messageDetail("<qt>");
   auto file = MyMoneyFile::instance();
   int noItemsChanged = 0;
 
   try {
     if (to.splits().isEmpty())
       throw MYMONEYEXCEPTION(i18n("Transaction %1 has no splits", to.id()));
     if (tn.splits().isEmpty())
       throw MYMONEYEXCEPTION(i18n("Transaction %1 has no splits", tn.id()));
 
     QString po, pn;
     if (!to.splits().front().payeeId().isEmpty())
       po = file->payee(to.splits().front().payeeId()).name();
     if (!tn.splits().front().payeeId().isEmpty())
       pn = file->payee(tn.splits().front().payeeId()).name();
 
     if (po != pn) {
       noItemsChanged++;
       messageDetail += i18n("<p>Payee changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>", po, pn);
     }
 
     if (to.splits().front().accountId() != tn.splits().front().accountId()) {
       noItemsChanged++;
       messageDetail += i18n("<p>Account changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>"
                             , file->account(to.splits().front().accountId()).name()
                             , file->account(tn.splits().front().accountId()).name());
     }
 
     if (file->isTransfer(to) && file->isTransfer(tn)) {
       if (to.splits()[1].accountId() != tn.splits()[1].accountId()) {
         noItemsChanged++;
         messageDetail += i18n("<p>Transfer account changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>"
                               , file->account(to.splits()[1].accountId()).name()
                               , file->account(tn.splits()[1].accountId()).name());
       }
     } else {
       QString co, cn;
       switch (to.splitCount()) {
         default:
           co = i18nc("Split transaction (category replacement)", "Split transaction");
           break;
         case 2:
           co = file->accountToCategory(to.splits()[1].accountId());
         case 1:
           break;
       }
 
       switch (tn.splitCount()) {
         default:
           cn = i18nc("Split transaction (category replacement)", "Split transaction");
           break;
         case 2:
           cn = file->accountToCategory(tn.splits()[1].accountId());
         case 1:
           break;
       }
       if (co != cn) {
         noItemsChanged++;
         messageDetail += i18n("<p>Category changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>", co, cn);
       }
     }
 
     QString mo, mn;
     mo = to.splits().front().memo();
     mn = tn.splits().front().memo();
     if (mo.isEmpty())
       mo = QString("<i>") + i18nc("Empty memo", "empty") + QString("</i>");
     if (mn.isEmpty())
       mn = QString("<i>") + i18nc("Empty memo", "empty") + QString("</i>");
     if (mo != mn) {
       noItemsChanged++;
       messageDetail += i18n("<p>Memo changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>", mo, mn);
     }
 
     QString no, nn;
     no = to.splits().front().number();
     nn = tn.splits().front().number();
     if (no.isEmpty())
       no = QString("<i>") + i18nc("No number", "empty") + QString("</i>");
     if (nn.isEmpty())
       nn = QString("<i>") + i18nc("No number", "empty") + QString("</i>");
     if (no != nn) {
       noItemsChanged++;
       messageDetail += i18n("<p>Number changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>", no, nn);
     }
 
     const MyMoneySecurity& sec = MyMoneyFile::instance()->security(to.commodity());
     MyMoneyMoney ao, an;
     ao = to.splits().front().value();
     an = tn.splits().front().value();
     if (ao != an) {
       noItemsChanged++;
       messageDetail += i18n("<p>Amount changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>", ao.formatMoney(sec.smallestAccountFraction()), an.formatMoney(sec.smallestAccountFraction()));
     }
 
     eMyMoney::Split::State fo, fn;
     fo = to.splits().front().reconcileFlag();
     fn = tn.splits().front().reconcileFlag();
     if (fo != fn) {
       noItemsChanged++;
       messageDetail += i18n("<p>Reconciliation flag changed.<br/>&nbsp;&nbsp;&nbsp;Old: <b>%1</b>, New: <b>%2</b></p>",    KMyMoneyUtils::reconcileStateToString(fo, true), KMyMoneyUtils::reconcileStateToString(fn, true));
     }
   } catch (const MyMoneyException &e) {
-    KMessageBox::error(this, i18n("Fatal error in determining data: %1", e.what()));
+    KMessageBox::error(this, i18n("Fatal error in determining data: %1", QString::fromLatin1(e.what())));
   }
 
   messageDetail += "</qt>";
   ui->m_details->setText(messageDetail);
   return;
 }
 
 KConfirmManualEnterDlg::Action KConfirmManualEnterDlg::action() const
 {
   if (ui->m_discardRadio->isChecked())
     return UseOriginal;
   if (ui->m_setRadio->isChecked())
     return ModifyAlways;
   return ModifyOnce;
 }
diff --git a/kmymoney/dialogs/kcurrencyeditdlg.cpp b/kmymoney/dialogs/kcurrencyeditdlg.cpp
index 2d2d18bfc..10fa2b85d 100644
--- a/kmymoney/dialogs/kcurrencyeditdlg.cpp
+++ b/kmymoney/dialogs/kcurrencyeditdlg.cpp
@@ -1,621 +1,621 @@
 /***************************************************************************
                           kcurrencyeditdlg.cpp  -  description
                              -------------------
     begin                : Wed Mar 24 2004
     copyright            : (C) 2000-2004 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>
                            Alvaro Soliverez <asoliverez@gmail.com>
                            (C) 2017 Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kcurrencyeditdlg.h"
 
 #include <locale.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QPixmap>
 #include <QBitmap>
 #include <QList>
 #include <QTreeWidget>
 #include <QStyledItemDelegate>
 #include <QIcon>
 #include <QPushButton>
 #include <QBitArray>
 #include <QInputDialog>
 #include <QMenu>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KTreeWidgetSearchLineWidget>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kcurrencyeditdlg.h"
 #include "ui_kcurrencyeditordlg.h"
 #include "ui_kavailablecurrencydlg.h"
 
 #include "mymoneyexception.h"
 #include "mymoneysecurity.h"
 #include "mymoneyfile.h"
 #include "mymoneyprice.h"
 #include "kavailablecurrencydlg.h"
 #include "kcurrencyeditordlg.h"
 #include "kmymoneyutils.h"
 #include "icons/icons.h"
 #include "storageenums.h"
 
 using namespace Icons;
 
 // duplicated eMenu namespace from menuenums.h for consistency
 // there shouldn't be any clash, because we don't need menuenums.h here
 namespace eMenu {
   enum class Action {
     // *************
     // The currency menu
     // *************
     NewCurrency, RenameCurrency, DeleteCurrency,
     SetBaseCurrency,
   };
   inline uint qHash(const Action key, uint seed) { return ::qHash(static_cast<uint>(key), seed); }
 }
 
 // this delegate is needed to disable editing the currency id (column 1)
 // since QTreeWidgetItem has only one set of flags for the whole row
 // the column editable property couldn't be set in an easier way
 class KCurrencyEditDelegate : public QStyledItemDelegate
 {
 public:
   explicit KCurrencyEditDelegate(QObject *parent = 0);
 
 protected:
   QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const final override;
 };
 
 KCurrencyEditDelegate::KCurrencyEditDelegate(QObject* parent): QStyledItemDelegate(parent)
 {
 }
 
 QWidget *KCurrencyEditDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
 {
   if (index.column() == 1)
     return 0;
   return QStyledItemDelegate::createEditor(parent, option, index);
 }
 
 class KCurrencyEditDlgPrivate
 {
   Q_DISABLE_COPY(KCurrencyEditDlgPrivate)
   Q_DECLARE_PUBLIC(KCurrencyEditDlg)
 
 public:
   explicit KCurrencyEditDlgPrivate(KCurrencyEditDlg *qq) :
     q_ptr(qq),
     ui(new Ui::KCurrencyEditDlg),
     m_availableCurrencyDlg(nullptr),
     m_currencyEditorDlg(nullptr),
     m_searchWidget(nullptr),
     m_inLoading(false)
   {
   }
 
   ~KCurrencyEditDlgPrivate()
   {
     delete ui;
   }
 
   enum removalModeE :int { RemoveSelected, RemoveUnused };
 
   void removeCurrency(const removalModeE& mode)
   {
     Q_Q(KCurrencyEditDlg);
     auto file = MyMoneyFile::instance();
     MyMoneyFileTransaction ft;
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(false);                                 // check reference to all...
     skip.setBit((int)eStorage::Reference::Price);      // ...except price
 
     QTreeWidgetItemIterator it (ui->m_currencyList);  // iterate over whole tree
     if (mode == RemoveUnused) {
       while (*it) {
         MyMoneySecurity currency = (*it)->data(0, Qt::UserRole).value<MyMoneySecurity>();
         if (file->baseCurrency() != currency && !file->isReferenced(currency, skip))
           KMyMoneyUtils::deleteSecurity(currency, q);
         ++it;
       }
     } else if (mode == RemoveSelected) {
       QList<QTreeWidgetItem*> currencyRows = ui->m_currencyList->selectedItems();
       foreach(auto currencyRow, currencyRows) {
         MyMoneySecurity currency = currencyRow->data(0, Qt::UserRole).value<MyMoneySecurity>();
         if (file->baseCurrency() != currency && !file->isReferenced(currency, skip))
           KMyMoneyUtils::deleteSecurity(currency, q);
       }
     }
     ft.commit();
     ui->m_removeUnusedCurrencyButton->setDisabled(file->currencyList().count() <= 1);
   }
 
   void setBaseCurrency(const MyMoneySecurity& cur)
   {
     Q_Q(KCurrencyEditDlg);
     if (!cur.id().isEmpty()) {
       if (cur.id() != MyMoneyFile::instance()->baseCurrency().id()) {
         MyMoneyFileTransaction ft;
         try {
           MyMoneyFile::instance()->setBaseCurrency(cur);
           ft.commit();
         } catch (const MyMoneyException &e) {
-          KMessageBox::sorry(q, i18n("Cannot set %1 as base currency: %2", cur.name(), e.what()), i18n("Set base currency"));
+          KMessageBox::sorry(q, i18n("Cannot set %1 as base currency: %2", cur.name(), QString::fromLatin1(e.what())), i18n("Set base currency"));
         }
       }
     }
   }
 
   void updateCurrency(const QString &currencyId, const QString& currencyName, const QString& currencyTradingSymbol)
   {
     Q_Q(KCurrencyEditDlg);
     const auto file = MyMoneyFile::instance();
     try {
       if (currencyName != m_currentCurrency.name() || currencyTradingSymbol != m_currentCurrency.tradingSymbol()) {
         MyMoneySecurity currency = file->currency(currencyId);
         currency.setName(currencyName);
         currency.setTradingSymbol(currencyTradingSymbol);
         MyMoneyFileTransaction ft;
         try {
           file->modifyCurrency(currency);
           m_currentCurrency = currency;
           ft.commit();
         } catch (const MyMoneyException &e) {
-          KMessageBox::sorry(q, i18n("Cannot update currency. %1", e.what()), i18n("Update currency"));
+          KMessageBox::sorry(q, i18n("Cannot update currency. %1", QString::fromLatin1(e.what())), i18n("Update currency"));
         }
       }
     } catch (const MyMoneyException &e) {
-      KMessageBox::sorry(q, i18n("Cannot update currency. %1", e.what()), i18n("Update currency"));
+      KMessageBox::sorry(q, i18n("Cannot update currency. %1", QString::fromLatin1(e.what())), i18n("Update currency"));
     }
   }
 
   KCurrencyEditDlg      *q_ptr;
   Ui::KCurrencyEditDlg  *ui;
 
   KAvailableCurrencyDlg *m_availableCurrencyDlg;
   KCurrencyEditorDlg    *m_currencyEditorDlg;
   MyMoneySecurity        m_currentCurrency;
   /**
     * Search widget for the list
     */
   KTreeWidgetSearchLineWidget*    m_searchWidget;
   bool                   m_inLoading;
 };
 
 KCurrencyEditDlg::KCurrencyEditDlg(QWidget *parent) :
   QDialog(parent),
   d_ptr(new KCurrencyEditDlgPrivate(this))
 {
   Q_D(KCurrencyEditDlg);
   d->ui->setupUi(this);
   d->m_searchWidget = new KTreeWidgetSearchLineWidget(this, d->ui->m_currencyList);
   d->m_searchWidget->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed));
   d->m_searchWidget->setFocus();
   d->ui->verticalLayout->insertWidget(0, d->m_searchWidget);
   d->ui->m_currencyList->setItemDelegate(new KCurrencyEditDelegate(d->ui->m_currencyList));
   d->ui->m_closeButton->setIcon(Icons::get(Icon::DialogClose));
   d->ui->m_editCurrencyButton->setIcon(Icons::get(Icon::DocumentEdit));
   d->ui->m_selectBaseCurrencyButton->setIcon(Icons::get(Icon::KMyMoney));
 
   connect(d->ui->m_currencyList, &QWidget::customContextMenuRequested, this, &KCurrencyEditDlg::slotShowCurrencyMenu);
   connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, this, &KCurrencyEditDlg::slotLoadCurrencies);
   connect(d->ui->m_currencyList, &QTreeWidget::itemChanged, this, static_cast<void (KCurrencyEditDlg::*)(QTreeWidgetItem *, int)>(&KCurrencyEditDlg::slotUpdateCurrency));
   connect(d->ui->m_currencyList, &QTreeWidget::itemSelectionChanged, this, &KCurrencyEditDlg::slotItemSelectionChanged);
 
   connect(d->ui->m_selectBaseCurrencyButton, &QAbstractButton::clicked, this, &KCurrencyEditDlg::slotSelectBaseCurrency);
   connect(d->ui->m_addCurrencyButton, &QAbstractButton::clicked, this, &KCurrencyEditDlg::slotAddCurrency);
   connect(d->ui->m_removeCurrencyButton, &QAbstractButton::clicked, this, &KCurrencyEditDlg::slotRemoveCurrency);
   connect(d->ui->m_editCurrencyButton, &QAbstractButton::clicked, this, &KCurrencyEditDlg::slotEditCurrency);
   connect(d->ui->m_removeUnusedCurrencyButton, &QAbstractButton::clicked, this, &KCurrencyEditDlg::slotRemoveUnusedCurrency);
 
   QTimer::singleShot(10, this, SLOT(timerDone()));
 }
 
 void KCurrencyEditDlg::timerDone()
 {
   Q_D(KCurrencyEditDlg);
   slotLoadCurrencies();
 
   //resize the column widths
   for (auto i = 0; i < 3; ++i)
     d->ui->m_currencyList->resizeColumnToContents(i);
 
   if (!d->m_currentCurrency.id().isEmpty()) {
     QTreeWidgetItemIterator it(d->ui->m_currencyList);
     QTreeWidgetItem* q;
     while ((q = *it) != 0) {
       if (q->text(1) == d->m_currentCurrency.id()) {
         d->ui->m_currencyList->scrollToItem(q);
         break;
       }
       ++it;
     }
   }
 }
 
 KCurrencyEditDlg::~KCurrencyEditDlg()
 {
   Q_D(KCurrencyEditDlg);
   delete d;
 }
 
 void KCurrencyEditDlg::slotLoadCurrencies()
 {
   const QSet<QString> metalSymbols { "XAU", "XPD", "XPT", "XAG" };
 
   Q_D(KCurrencyEditDlg);
 
   // catch recursive calls and avoid them
   if (d->m_inLoading)
     return;
   d->m_inLoading = true;
 
   disconnect(d->ui->m_currencyList, &QTreeWidget::currentItemChanged, this, static_cast<void (KCurrencyEditDlg::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&KCurrencyEditDlg::slotSelectCurrency));
   disconnect(d->ui->m_currencyList, &QTreeWidget::itemChanged, this, static_cast<void (KCurrencyEditDlg::*)(QTreeWidgetItem *, int)>(&KCurrencyEditDlg::slotUpdateCurrency));
 
   QList<MyMoneySecurity> list = MyMoneyFile::instance()->currencyList();
   QList<MyMoneySecurity>::ConstIterator it;
   QTreeWidgetItem *first = 0;
 
   // sort the currencies ...
   // ... and make sure a few precious metals are at the ned
   qSort(list.begin(), list.end(),
         [=] (const MyMoneySecurity& c1, const MyMoneySecurity& c2)
         {
           const bool c1Metal = c1.tradingSymbol().startsWith(QLatin1Char('X')) && metalSymbols.contains(c1.tradingSymbol());
           const bool c2Metal = c2.tradingSymbol().startsWith(QLatin1Char('X')) && metalSymbols.contains(c2.tradingSymbol());
           if (c1Metal ^ c2Metal)
             return c2Metal;
 
           return c1.name().compare(c2.name()) < 0;
         });
 
   QString localCurrency(localeconv()->int_curr_symbol);
   localCurrency.truncate(3);
 
   QString baseCurrency;
   try {
     baseCurrency = MyMoneyFile::instance()->baseCurrency().id();
   } catch (const MyMoneyException &e) {
-    qDebug("%s", qPrintable(e.what()));
+    qDebug("%s", e.what());
   }
 
   // construct a transparent 16x16 pixmap
   QPixmap empty(16, 16);
   QBitmap mask(16, 16);
   mask.clear();
   empty.setMask(mask);
 
   d->ui->m_currencyList->setSortingEnabled(false);
   d->ui->m_currencyList->clear();
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     QTreeWidgetItem *p = new QTreeWidgetItem(d->ui->m_currencyList);
     p->setText(0, (*it).name());
     p->setData(0, Qt::UserRole, QVariant::fromValue(*it));
     p->setFlags(p->flags() | Qt::ItemIsEditable);
     p->setText(1, (*it).id());
     // fix the ATS problem
     QString symbol = (*it).tradingSymbol();
     if (((*it).id() == QLatin1String("ATS")) && (symbol != QString::fromUtf8("ÖS"))) {
       MyMoneySecurity tmp = d->m_currentCurrency;
       symbol = QString::fromUtf8("ÖS");
       d->updateCurrency((*it).id(), (*it).name(), symbol);
       d->m_currentCurrency = tmp;
     }
     p->setText(2, symbol);
 
     if ((*it).id() == baseCurrency) {
       p->setData(0, Qt::DecorationRole, Icons::get(Icon::KMyMoney));
       if (d->m_currentCurrency.id().isEmpty())
         first = p;
     } else {
       p->setData(0, Qt::DecorationRole, empty);
     }
 
     // if we had a previously selected
     if (!d->m_currentCurrency.id().isEmpty()) {
       if (d->m_currentCurrency.id() == p->text(1))
         first = p;
     } else if ((*it).id() == localCurrency && !first)
       first = p;
   }
   d->ui->m_removeUnusedCurrencyButton->setDisabled(list.count() <= 1);
 
   connect(d->ui->m_currencyList, &QTreeWidget::currentItemChanged, this, static_cast<void (KCurrencyEditDlg::*)(QTreeWidgetItem *, QTreeWidgetItem *)>(&KCurrencyEditDlg::slotSelectCurrency));
   connect(d->ui->m_currencyList, &QTreeWidget::itemChanged, this, static_cast<void (KCurrencyEditDlg::*)(QTreeWidgetItem *, int)>(&KCurrencyEditDlg::slotUpdateCurrency));
 
   if (first == 0)
     first = d->ui->m_currencyList->invisibleRootItem()->child(0);
   if (first != 0) {
     d->ui->m_currencyList->setCurrentItem(first);
     d->ui->m_currencyList->scrollToItem(first);
   }
 
   slotSelectCurrency(first);
   d->m_inLoading = false;
 }
 
 void KCurrencyEditDlg::slotUpdateCurrency(QTreeWidgetItem* citem, int)
 {
   slotUpdateCurrency(citem, nullptr);
 }
 
 void KCurrencyEditDlg::slotUpdateCurrency(QTreeWidgetItem* citem, QTreeWidgetItem *pitem)
 {
   Q_D(KCurrencyEditDlg);
   Q_UNUSED(pitem)
   //if there is no current item selected, exit
   if (!d->ui->m_currencyList->currentItem() || citem != d->ui->m_currencyList->currentItem())
     return;
 
   //verify that the stored currency id is not empty and the edited fields are not empty either
   if (!d->m_currentCurrency.id().isEmpty()
       && !d->ui->m_currencyList->currentItem()->text(2).isEmpty()
       && !d->ui->m_currencyList->currentItem()->text(0).isEmpty()) {
     //check that either the name or the id have changed
     if (d->ui->m_currencyList->currentItem()->text(2) != d->m_currentCurrency.tradingSymbol()
         || d->ui->m_currencyList->currentItem()->text(0) != d->m_currentCurrency.name()) {
       //update the name and the id
       d->m_currentCurrency.setName(d->ui->m_currencyList->currentItem()->text(0));
       d->m_currentCurrency.setTradingSymbol(d->ui->m_currencyList->currentItem()->text(2));
 
       d->updateCurrency(d->m_currentCurrency.id(), d->m_currentCurrency.name(), d->m_currentCurrency.tradingSymbol());
     }
   }
 }
 
 void KCurrencyEditDlg::slotSelectCurrency(const QString& id)
 {
   Q_D(KCurrencyEditDlg);
   QTreeWidgetItemIterator it(d->ui->m_currencyList);
 
   while (*it) {
     if ((*it)->text(1) == id) {
       d->ui->m_currencyList->blockSignals(true);
       slotSelectCurrency(*it);
       d->ui->m_currencyList->setCurrentItem(*it);
       d->ui->m_currencyList->scrollToItem(*it);
       d->ui->m_currencyList->blockSignals(false);
       break;
     }
     ++it;
   }
 }
 
 void KCurrencyEditDlg::slotSelectCurrency(QTreeWidgetItem *citem, QTreeWidgetItem *pitem)
 {
   Q_UNUSED(pitem)
   slotSelectCurrency(citem);
 }
 
 void KCurrencyEditDlg::slotSelectCurrency(QTreeWidgetItem *item)
 {
   Q_D(KCurrencyEditDlg);
   auto file = MyMoneyFile::instance();
   QString baseId;
   try {
     baseId = MyMoneyFile::instance()->baseCurrency().id();
   } catch (const MyMoneyException &) {
   }
 
   if (item) {
     try {
       d->m_currentCurrency = file->security(item->text(1));
 
     } catch (const MyMoneyException &) {
       d->m_currentCurrency = MyMoneySecurity();
     }
 
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(false);
     skip.setBit((int)eStorage::Reference::Price);
 
     const bool rc1 = d->m_currentCurrency.id() == baseId;
     const bool rc2 = file->isReferenced(d->m_currentCurrency, skip);
     const int count = d->ui->m_currencyList->selectedItems().count();
 
     d->ui->m_selectBaseCurrencyButton->setDisabled(rc1 || count != 1);
     d->ui->m_editCurrencyButton->setDisabled(count != 1);
     d->ui->m_removeCurrencyButton->setDisabled((rc1 || rc2) && count <= 1);
 //    emit selectObject(d->m_currentCurrency);
   }
 }
 
 void KCurrencyEditDlg::slotItemSelectionChanged()
 {
   Q_D(KCurrencyEditDlg);
   int count = d->ui->m_currencyList->selectedItems().count();
   if (!d->ui->m_selectBaseCurrencyButton->isEnabled() && count == 1)
     slotSelectCurrency(d->ui->m_currencyList->currentItem());
   if (count > 1)
     d->ui->m_removeCurrencyButton->setEnabled(true);
 }
 
 void KCurrencyEditDlg::slotShowCurrencyMenu(const QPoint& p)
 {
   Q_D(KCurrencyEditDlg);
   auto item = d->ui->m_currencyList->itemAt(p);
   if (item) {
     const auto sec = item->data(0, Qt::UserRole).value<MyMoneySecurity>();
     const auto file = MyMoneyFile::instance();
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(false);
     skip.setBit((int)eStorage::Reference::Transaction);
     const auto cond1 = !sec.id().isEmpty();
     const auto cond2 = cond1 && !file->isReferenced(sec, skip);
     const auto cond3 = cond1 && sec.id() != file->baseCurrency().id();
     auto menu = new QMenu;
     typedef void(KCurrencyEditDlg::*KCurrencyEditDlgFunc)();
     struct actionInfo {
       eMenu::Action        action;
       KCurrencyEditDlgFunc callback;
       QString              text;
       Icon                 icon;
       bool                 enabled;
     };
 
     const QVector<actionInfo> actionInfos {
       {eMenu::Action::NewCurrency,      &KCurrencyEditDlg::slotNewCurrency,     i18n("New currency"),            Icon::ListAdd,     true},
       {eMenu::Action::RenameCurrency,   &KCurrencyEditDlg::slotRenameCurrency,  i18n("Rename currency"),         Icon::EditRename,  cond1},
       {eMenu::Action::DeleteCurrency,   &KCurrencyEditDlg::slotDeleteCurrency,  i18n("Delete currency"),         Icon::EditDelete,  cond2},
       {eMenu::Action::SetBaseCurrency,  &KCurrencyEditDlg::slotSetBaseCurrency, i18n("Select as base currency"), Icon::KMyMoney,    cond3}
     };
 
     QList<QAction*> LUTActions;
     for (const auto& info : actionInfos) {
       auto a = new QAction(Icons::get(info.icon), info.text, nullptr); // WARNING: no empty Icon::Empty here
       a->setEnabled(info.enabled);
       connect(a, &QAction::triggered, this, info.callback);
       LUTActions.append(a);
     }
     menu->addSection(i18nc("Menu header","Currency options"));
     menu->addActions(LUTActions);
     menu->exec(QCursor::pos());
   }
 }
 
 void KCurrencyEditDlg::slotSelectBaseCurrency()
 {
   Q_D(KCurrencyEditDlg);
   if (!d->m_currentCurrency.id().isEmpty()) {
     QTreeWidgetItem* p = d->ui->m_currencyList->currentItem();
     d->setBaseCurrency(d->m_currentCurrency);
     // in case the dataChanged() signal was not sent out (nested FileTransaction)
     // we update the list manually
     if (p == d->ui->m_currencyList->currentItem())
       slotLoadCurrencies();
   }
 }
 
 void KCurrencyEditDlg::slotAddCurrency()
 {
   Q_D(KCurrencyEditDlg);
   d->m_availableCurrencyDlg = new KAvailableCurrencyDlg;                                   // create new dialog for selecting currencies to add
   if (d->m_availableCurrencyDlg->exec() != QDialog::Rejected) {
     auto file = MyMoneyFile::instance();
     QMap<MyMoneySecurity, MyMoneyPrice> ancientCurrencies = file->ancientCurrencies();
     MyMoneyFileTransaction ft;
     QList<QTreeWidgetItem *> currencyRows = d->m_availableCurrencyDlg->ui->m_currencyList->selectedItems(); // get selected currencies from new dialog
     foreach (auto currencyRow, currencyRows) {
       MyMoneySecurity currency = currencyRow->data(0, Qt::UserRole).value<MyMoneySecurity>();
       file->addCurrency(currency);
       if (ancientCurrencies.value(currency, MyMoneyPrice()) != MyMoneyPrice()) // if ancient currency is added...
         file->addPrice(ancientCurrencies[currency]);                           // ...we want to add last known exchange rate as well
     }
     ft.commit();
     d->ui->m_removeUnusedCurrencyButton->setDisabled(file->currencyList().count() <= 1);
   }
   delete d->m_availableCurrencyDlg;
 }
 
 void KCurrencyEditDlg::slotRemoveCurrency()
 {
   Q_D(KCurrencyEditDlg);
   d->removeCurrency(KCurrencyEditDlgPrivate::RemoveSelected);
 }
 
 void KCurrencyEditDlg::slotRemoveUnusedCurrency()
 {
   Q_D(KCurrencyEditDlg);
   d->removeCurrency(KCurrencyEditDlgPrivate::RemoveUnused);
 }
 
 void KCurrencyEditDlg::slotEditCurrency()
 {
   Q_D(KCurrencyEditDlg);
   MyMoneySecurity currency = d->ui->m_currencyList->currentItem()->data(0, Qt::UserRole).value<MyMoneySecurity>();
   d->m_currencyEditorDlg = new KCurrencyEditorDlg(currency);                                   // create new dialog for editing currency
   if (d->m_currencyEditorDlg->exec() != QDialog::Rejected) {
     auto file = MyMoneyFile::instance();
     MyMoneyFileTransaction ft;
     currency.setPricePrecision(d->m_currencyEditorDlg->ui->m_pricePrecision->value());
     try {
       file->modifyCurrency(currency);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      qDebug("%s", qPrintable(e.what()));
+      qDebug("%s", e.what());
     }
   }
   delete d->m_currencyEditorDlg;
 }
 
 void KCurrencyEditDlg::slotNewCurrency()
 {
   QString sid = QInputDialog::getText(0, i18n("New currency"), i18n("Enter ISO 4217 code for the new currency"));
   if (!sid.isEmpty()) {
     QString id(sid);
     MyMoneySecurity currency(id, i18n("New currency"));
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->addCurrency(currency);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::sorry(this, i18n("Cannot create new currency. %1", e.what()), i18n("New currency"));
+      KMessageBox::sorry(this, i18n("Cannot create new currency. %1", QString::fromLatin1(e.what())), i18n("New currency"));
     }
     slotSelectCurrency(id);
   }
 }
 
 void KCurrencyEditDlg::slotRenameCurrency()
 {
   Q_D(KCurrencyEditDlg);
   QTreeWidgetItemIterator it_l(d->ui->m_currencyList, QTreeWidgetItemIterator::Selected);
   QTreeWidgetItem* it_v;
   if ((it_v = *it_l) != 0) {
     d->ui->m_currencyList->editItem(it_v, 0);
   }
 }
 
 void KCurrencyEditDlg::slotDeleteCurrency()
 {
   Q_D(KCurrencyEditDlg);
   if (!d->m_currentCurrency.id().isEmpty()) {
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->removeCurrency(d->m_currentCurrency);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::sorry(this, i18n("Cannot delete currency %1. %2", d->m_currentCurrency.name(), e.what()), i18n("Delete currency"));
+      KMessageBox::sorry(this, i18n("Cannot delete currency %1. %2", d->m_currentCurrency.name(), QString::fromLatin1(e.what())), i18n("Delete currency"));
     }
   }
 }
 
 void KCurrencyEditDlg::slotSetBaseCurrency()
 {
   Q_D(KCurrencyEditDlg);
   if (!d->m_currentCurrency.id().isEmpty()) {
     if (d->m_currentCurrency.id() != MyMoneyFile::instance()->baseCurrency().id()) {
       MyMoneyFileTransaction ft;
       try {
         MyMoneyFile::instance()->setBaseCurrency(d->m_currentCurrency);
         ft.commit();
       } catch (const MyMoneyException &e) {
-        KMessageBox::sorry(this, i18n("Cannot set %1 as base currency: %2", d->m_currentCurrency.name(), e.what()), i18n("Set base currency"));
+        KMessageBox::sorry(this, i18n("Cannot set %1 as base currency: %2", d->m_currentCurrency.name(), QString::fromLatin1(e.what())), i18n("Set base currency"));
       }
     }
   }
 }
diff --git a/kmymoney/dialogs/keditscheduledlg.cpp b/kmymoney/dialogs/keditscheduledlg.cpp
index 6bcf643a6..b2c6627e2 100644
--- a/kmymoney/dialogs/keditscheduledlg.cpp
+++ b/kmymoney/dialogs/keditscheduledlg.cpp
@@ -1,776 +1,776 @@
 /***************************************************************************
                           keditscheduledlg.cpp  -  description
                              -------------------
     begin                : Mon Sep  3 2007
     copyright            : (C) 2007 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "keditscheduledlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QCheckBox>
 #include <QLabel>
 #include <QList>
 #include <QPushButton>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KStandardGuiItem>
 #include <KLineEdit>
 #include <KHelpClient>
 #include <KMessageBox>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_keditscheduledlg.h"
 
 #include "tabbar.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "register.h"
 #include "transactionform.h"
 #include "transaction.h"
 #include "selectedtransactions.h"
 #include "transactioneditor.h"
 #include "kmymoneylineedit.h"
 #include "kmymoneydateinput.h"
 #include "kmymoneymvccombo.h"
 #include "kguiutils.h"
 #include "kmymoneyutils.h"
 #include "knewaccountdlg.h"
 #include "knewinvestmentwizard.h"
 #include "keditloanwizard.h"
 #include "kmymoneysettings.h"
 #include "mymoneyenums.h"
 #include "widgetenums.h"
 
 using namespace eMyMoney;
 
 class KEditScheduleDlgPrivate
 {
   Q_DISABLE_COPY(KEditScheduleDlgPrivate)
   Q_DECLARE_PUBLIC(KEditScheduleDlg)
 
 public:
   explicit KEditScheduleDlgPrivate(KEditScheduleDlg *qq) :
     q_ptr(qq),
     ui(new Ui::KEditScheduleDlg),
     m_item(nullptr),
     m_editor(nullptr),
     m_requiredFields(nullptr)
   {
   }
 
   ~KEditScheduleDlgPrivate()
   {
     delete ui;
   }
 
   void init()
   {
     Q_Q(KEditScheduleDlg);
     ui->setupUi(q);
 
     m_requiredFields = new KMandatoryFieldGroup(q);
     m_requiredFields->setOkButton(ui->buttonBox->button(QDialogButtonBox::Ok)); // button to be enabled when all fields present
 
     // make sure, we have a tabbar with the form
     // insert it after the horizontal line
     ui->m_paymentInformationLayout->insertWidget(2, ui->m_form->getTabBar(ui->m_form->parentWidget()));
 
     // we never need to see the register
     ui->m_register->hide();
 
     // ... setup the form ...
     ui->m_form->setupForm(m_schedule.account());
 
     // ... and the register ...
     ui->m_register->clear();
 
     // ... now add the transaction to register and form ...
     auto t = transaction();
     if (m_schedule.transaction().splits().isEmpty())
       m_item = KMyMoneyRegister::Register::transactionFactory(ui->m_register, t, MyMoneySplit(), 0);
     else
       m_item = KMyMoneyRegister::Register::transactionFactory(ui->m_register, t,
                   m_schedule.transaction().splits().isEmpty() ? MyMoneySplit() : m_schedule.transaction().splits().front(), 0);
     ui->m_register->selectItem(m_item);
     // show the account row
     m_item->setShowRowInForm(0, true);
 
     ui->m_form->slotSetTransaction(m_item);
 
     // setup widget contents
     ui->m_nameEdit->setText(m_schedule.name());
 
     ui->m_frequencyEdit->setCurrentItem((int)m_schedule.occurrencePeriod());
     if (ui->m_frequencyEdit->currentItem() == Schedule::Occurrence::Any)
       ui->m_frequencyEdit->setCurrentItem((int)Schedule::Occurrence::Monthly);
     q->slotFrequencyChanged((int)ui->m_frequencyEdit->currentItem());
     ui->m_frequencyNoEdit->setValue(m_schedule.occurrenceMultiplier());
 
     // load option widgets
     ui->m_paymentMethodEdit->insertItem(i18n("Direct deposit"), (int)Schedule::PaymentType::DirectDeposit);
     ui->m_paymentMethodEdit->insertItem(i18n("Manual deposit"), (int)Schedule::PaymentType::ManualDeposit);
     ui->m_paymentMethodEdit->insertItem(i18n("Direct debit"), (int)Schedule::PaymentType::DirectDebit);
     ui->m_paymentMethodEdit->insertItem(i18n("Standing order"), (int)Schedule::PaymentType::StandingOrder);
     ui->m_paymentMethodEdit->insertItem(i18n("Bank transfer"), (int)Schedule::PaymentType::BankTransfer);
     ui->m_paymentMethodEdit->insertItem(i18n("Write check"), (int)Schedule::PaymentType::WriteChecque);
     ui->m_paymentMethodEdit->insertItem(i18nc("Other payment method", "Other"), (int)Schedule::PaymentType::Other);
 
     auto method = m_schedule.paymentType();
     if (method == Schedule::PaymentType::Any)
       method = Schedule::PaymentType::Other;
     ui->m_paymentMethodEdit->setCurrentItem((int)method);
 
     switch (m_schedule.weekendOption()) {
       case Schedule::WeekendOption::MoveNothing:
         ui->m_weekendOptionEdit->setCurrentIndex(0);
         break;
       case Schedule::WeekendOption::MoveBefore:
         ui->m_weekendOptionEdit->setCurrentIndex(1);
         break;
       case Schedule::WeekendOption::MoveAfter:
         ui->m_weekendOptionEdit->setCurrentIndex(2);
         break;
     }
     ui->m_estimateEdit->setChecked(!m_schedule.isFixed());
     ui->m_lastDayInMonthEdit->setChecked(m_schedule.lastDayInMonth());
     ui->m_autoEnterEdit->setChecked(m_schedule.autoEnter());
     ui->m_endSeriesEdit->setChecked(m_schedule.willEnd());
 
     ui->m_endOptionsFrame->setEnabled(m_schedule.willEnd());
     if (m_schedule.willEnd()) {
       ui->m_RemainingEdit->setValue(m_schedule.transactionsRemaining());
       ui->m_FinalPaymentEdit->setDate(m_schedule.endDate());
     }
 
     q->connect(ui->m_RemainingEdit, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
             q, &KEditScheduleDlg::slotRemainingChanged);
     q->connect(ui->m_FinalPaymentEdit, &KMyMoneyDateInput::dateChanged,
             q, &KEditScheduleDlg::slotEndDateChanged);
     q->connect(ui->m_frequencyEdit, &KMyMoneyGeneralCombo::itemSelected,
             q, &KEditScheduleDlg::slotFrequencyChanged);
     q->connect(ui->m_frequencyNoEdit, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
             q, &KEditScheduleDlg::slotOccurrenceMultiplierChanged);
     q->connect(ui->buttonBox, &QDialogButtonBox::helpRequested, q, &KEditScheduleDlg::slotShowHelp);
 
     q->setModal(true);
     // force the initial height to be as small as possible
     QTimer::singleShot(0, q, SLOT(slotSetupSize()));
 
     // we just hide the variation field for now and enable the logic
     // once we have a respective member in the MyMoneySchedule object
     ui->m_variation->hide();
   }
 
   /**
     * Helper method to recalculate and update Transactions Remaining
     * when other values are changed
     */
   void updateTransactionsRemaining()
   {
     auto remain = m_schedule.transactionsRemaining();
     if (remain != ui->m_RemainingEdit->value()) {
       ui->m_RemainingEdit->blockSignals(true);
       ui->m_RemainingEdit->setValue(remain);
       ui->m_RemainingEdit->blockSignals(false);
     }
   }
 
   MyMoneyTransaction transaction() const
   {
     auto t = m_schedule.transaction();
 
     if (m_editor) {
       m_editor->createTransaction(t, m_schedule.transaction(), m_schedule.transaction().splits().isEmpty() ? MyMoneySplit() : m_schedule.transaction().splits().front(), false);
     }
 
     t.clearId();
     t.setEntryDate(QDate());
     return t;
   }
 
   KEditScheduleDlg              *q_ptr;
   Ui::KEditScheduleDlg          *ui;
   MyMoneySchedule                m_schedule;
   KMyMoneyRegister::Transaction* m_item;
   QWidgetList                    m_tabOrderWidgets;
   TransactionEditor*             m_editor;
   KMandatoryFieldGroup*          m_requiredFields;
 };
 
 KEditScheduleDlg::KEditScheduleDlg(const MyMoneySchedule& schedule, QWidget *parent) :
   QDialog(parent),
   d_ptr(new KEditScheduleDlgPrivate(this))
 {
   Q_D(KEditScheduleDlg);
   d->m_schedule = schedule;
   d->m_editor = 0;
   d->init();
 }
 
 KEditScheduleDlg::~KEditScheduleDlg()
 {
   Q_D(KEditScheduleDlg);
   delete d;
 }
 
 void KEditScheduleDlg::slotSetupSize()
 {
   resize(width(), minimumSizeHint().height());
 }
 
 TransactionEditor* KEditScheduleDlg::startEdit()
 {
   Q_D(KEditScheduleDlg);
   KMyMoneyRegister::SelectedTransactions list(d->ui->m_register);
   TransactionEditor* editor = d->m_item->createEditor(d->ui->m_form, list, QDate());
 
   // check that we use the same transaction commodity in all selected transactions
   // if not, we need to update this in the editor's list. The user can also bail out
   // of this operation which means that we have to stop editing here.
   if (editor && !d->m_schedule.account().id().isEmpty()) {
     if (!editor->fixTransactionCommodity(d->m_schedule.account())) {
       // if the user wants to quit, we need to destroy the editor
       // and bail out
       delete editor;
       editor = 0;
     }
   }
 
   if (editor) {
     editor->setScheduleInfo(d->ui->m_nameEdit->text());
     connect(editor, &TransactionEditor::transactionDataSufficient, d->ui->buttonBox->button(QDialogButtonBox::Ok), &QWidget::setEnabled);
     connect(editor, &TransactionEditor::escapePressed, d->ui->buttonBox->button(QDialogButtonBox::Cancel), &QAbstractButton::animateClick);
     connect(editor, &TransactionEditor::returnPressed, d->ui->buttonBox->button(QDialogButtonBox::Ok), &QAbstractButton::animateClick);
 
     connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, editor, &TransactionEditor::slotReloadEditWidgets);
     // connect(editor, SIGNAL(finishEdit(KMyMoneyRegister::SelectedTransactions)), this, SLOT(slotLeaveEditMode(KMyMoneyRegister::SelectedTransactions)));
     connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, editor, &TransactionEditor::slotReloadEditWidgets);
 
     // create the widgets, place them in the parent and load them with data
     // setup tab order
     d->m_tabOrderWidgets.clear();
     eWidgets::eRegister::Action action = eWidgets::eRegister::Action::Withdrawal;
     switch (d->m_schedule.type()) {
       case Schedule::Type::Deposit:
         action = eWidgets::eRegister::Action::Deposit;
         break;
       case Schedule::Type::Bill:
         action = eWidgets::eRegister::Action::Withdrawal;
         editor->setPaymentMethod(d->m_schedule.paymentType());
         break;
       case Schedule::Type::Transfer:
         action = eWidgets::eRegister::Action::Transfer;
         break;
       default:
         // if we end up here, we don't have a known schedule type (yet). in this case, we just glimpse
         // into the transaction and determine the type. in case we don't have a transaction with splits
         // we stick with the default action already set up
         if (d->m_schedule.transaction().splits().count() > 0) {
           auto isDeposit = false;
           auto isTransfer = false;
           auto splits = d->m_schedule.transaction().splits();
           foreach (const auto split, splits) {
             if (split.accountId() == d->m_schedule.account().id()) {
               isDeposit = !(split.shares().isNegative());
             } else {
               auto acc = MyMoneyFile::instance()->account(split.accountId());
               if (acc.isAssetLiability() && d->m_schedule.transaction().splits().count() == 2) {
                 isTransfer = true;
               }
             }
           }
 
           if (isTransfer)
             action = eWidgets::eRegister::Action::Transfer;
           else if (isDeposit)
             action = eWidgets::eRegister::Action::Deposit;
         }
         break;
     }
     editor->setup(d->m_tabOrderWidgets, d->m_schedule.account(), action);
 
     // if it's not a check, then we need to clear
     // a possibly assigned check number
     if (d->m_schedule.paymentType() != Schedule::PaymentType::WriteChecque) {
       QWidget* w = editor->haveWidget("number");
       if (w) {
         if (auto numberWidget = dynamic_cast<KMyMoneyLineEdit*>(w))
           numberWidget->loadText(QString());
       }
     }
 
     Q_ASSERT(!d->m_tabOrderWidgets.isEmpty());
 
     d->m_tabOrderWidgets.push_front(d->ui->m_paymentMethodEdit);
 
     // editor->setup() leaves the tabbar as the last widget in the stack, but we
     // need it as first here. So we move it around.
     QWidget* w = editor->haveWidget("tabbar");
     if (w) {
       int idx = d->m_tabOrderWidgets.indexOf(w);
       if (idx != -1) {
         d->m_tabOrderWidgets.removeAt(idx);
         d->m_tabOrderWidgets.push_front(w);
       }
     }
 
     // don't forget our three buttons and additional widgets
     // make sure to use the correct order
     d->m_tabOrderWidgets.push_front(d->ui->m_frequencyEdit);
     d->m_tabOrderWidgets.push_front(d->ui->m_frequencyNoEdit);
     d->m_tabOrderWidgets.push_front(d->ui->m_nameEdit);
 
     d->m_tabOrderWidgets.append(d->ui->m_weekendOptionEdit);
     d->m_tabOrderWidgets.append(d->ui->m_estimateEdit);
     d->m_tabOrderWidgets.append(d->ui->m_variation);
     d->m_tabOrderWidgets.append(d->ui->m_lastDayInMonthEdit);
     d->m_tabOrderWidgets.append(d->ui->m_autoEnterEdit);
     d->m_tabOrderWidgets.append(d->ui->m_endSeriesEdit);
     d->m_tabOrderWidgets.append(d->ui->m_RemainingEdit);
     d->m_tabOrderWidgets.append(d->ui->m_FinalPaymentEdit);
 
     d->m_tabOrderWidgets.append(d->ui->buttonBox->button(QDialogButtonBox::Ok));
     d->m_tabOrderWidgets.append(d->ui->buttonBox->button(QDialogButtonBox::Cancel));
     d->m_tabOrderWidgets.append(d->ui->buttonBox->button(QDialogButtonBox::Help));
     for (auto i = 0; i < d->m_tabOrderWidgets.size(); ++i) {
       w = d->m_tabOrderWidgets.at(i);
       if (w) {
         w->installEventFilter(this);
         w->installEventFilter(editor);
       }
     }
 
     // connect the postdate modification signal to our update routine
     if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(editor->haveWidget("postdate")))
       connect(dateEdit, &KMyMoneyDateInput::dateChanged, this, &KEditScheduleDlg::slotPostDateChanged);
 
     d->ui->m_nameEdit->setFocus();
 
     // add the required fields to the mandatory group
     d->m_requiredFields->add(d->ui->m_nameEdit);
     d->m_requiredFields->add(editor->haveWidget("account"));
     d->m_requiredFields->add(editor->haveWidget("category"));
 
     // fix labels
     if (auto label = dynamic_cast<QLabel*>(editor->haveWidget("date-label")))
       label->setText(i18n("Next due date"));
 
     d->m_editor = editor;
     slotSetPaymentMethod((int)d->m_schedule.paymentType());
 
     connect(d->ui->m_paymentMethodEdit, &KMyMoneyGeneralCombo::itemSelected, this, &KEditScheduleDlg::slotSetPaymentMethod);
     connect(editor, &TransactionEditor::operationTypeChanged, this, &KEditScheduleDlg::slotFilterPaymentType);
   }
 
   return editor;
 }
 
 void KEditScheduleDlg::accept()
 {
   Q_D(KEditScheduleDlg);
   // Force the focus to be on the OK button. This will trigger creation
   // of any unknown objects (payees, categories etc.)
   d->ui->buttonBox->button(QDialogButtonBox::Ok)->setFocus();
 
   // only accept if the button is really still enabled. We could end
   // up here, if the user filled all fields, the focus is on the category
   // field, but the category is not yet existent. When the user presses the
   // OK button in this context, he will be asked if he wants to create
   // the category or not. In case he decides no, we end up here with no
   // category filled in, so we don't run through the final acceptance.
   if (d->ui->buttonBox->button(QDialogButtonBox::Ok)->isEnabled())
     QDialog::accept();
 }
 
 const MyMoneySchedule& KEditScheduleDlg::schedule()
 {
   Q_D(KEditScheduleDlg);
   if (d->m_editor) {
     auto t = d->transaction();
     if (d->m_schedule.nextDueDate() != t.postDate()) {
       d->m_schedule.setNextDueDate(t.postDate());
       d->m_schedule.setStartDate(t.postDate());
     }
     d->m_schedule.setTransaction(t);
     d->m_schedule.setName(d->ui->m_nameEdit->text());
     d->m_schedule.setFixed(!d->ui->m_estimateEdit->isChecked());
     d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(d->ui->m_frequencyEdit->currentItem()));
     d->m_schedule.setOccurrenceMultiplier(d->ui->m_frequencyNoEdit->value());
 
     switch (d->ui->m_weekendOptionEdit->currentIndex())  {
       case 0:
         d->m_schedule.setWeekendOption(Schedule::WeekendOption::MoveNothing);
         break;
       case 1:
         d->m_schedule.setWeekendOption(Schedule::WeekendOption::MoveBefore);
         break;
       case 2:
         d->m_schedule.setWeekendOption(Schedule::WeekendOption::MoveAfter);
         break;
     }
 
     d->m_schedule.setType(Schedule::Type::Bill);
 
     if (auto tabbar = dynamic_cast<KMyMoneyTransactionForm::TabBar*>(d->m_editor->haveWidget("tabbar"))) {
       switch (static_cast<eWidgets::eRegister::Action>(tabbar->currentIndex())) {
         case eWidgets::eRegister::Action::Deposit:
           d->m_schedule.setType(Schedule::Type::Deposit);
           break;
         default:
         case eWidgets::eRegister::Action::Withdrawal:
           d->m_schedule.setType(Schedule::Type::Bill);
           break;
         case eWidgets::eRegister::Action::Transfer:
           d->m_schedule.setType(Schedule::Type::Transfer);
           break;
       }
     } else {
       qDebug("No tabbar found in KEditScheduleDlg::schedule(). Defaulting type to BILL");
     }
 
     if(d->ui->m_lastDayInMonthEdit->isEnabled())
       d->m_schedule.setLastDayInMonth(d->ui->m_lastDayInMonthEdit->isChecked());
     else
       d->m_schedule.setLastDayInMonth(false);
     d->m_schedule.setAutoEnter(d->ui->m_autoEnterEdit->isChecked());
     d->m_schedule.setPaymentType(static_cast<Schedule::PaymentType>(d->ui->m_paymentMethodEdit->currentItem()));
     if (d->ui->m_endSeriesEdit->isEnabled() && d->ui->m_endSeriesEdit->isChecked()) {
       d->m_schedule.setEndDate(d->ui->m_FinalPaymentEdit->date());
     } else {
       d->m_schedule.setEndDate(QDate());
     }
   }
   return d->m_schedule;
 }
 
 void KEditScheduleDlg::newSchedule(const MyMoneyTransaction& _t, eMyMoney::Schedule::Occurrence occurrence)
 {
   MyMoneySchedule schedule;
   schedule.setOccurrence(occurrence);
 
   // if the schedule is based on an existing transaction,
   // we take the post date and project it to the next
   // schedule in a month.
   if (_t != MyMoneyTransaction()) {
     MyMoneyTransaction t(_t);
     schedule.setTransaction(t);
     if (occurrence != eMyMoney::Schedule::Occurrence::Once)
       schedule.setNextDueDate(schedule.nextPayment(t.postDate()));
   }
 
   QPointer<KEditScheduleDlg> dlg = new KEditScheduleDlg(schedule, nullptr);
   QPointer<TransactionEditor> transactionEditor = dlg->startEdit();
   if (transactionEditor) {
     KMyMoneyMVCCombo::setSubstringSearchForChildren(dlg, !KMyMoneySettings::stringMatchFromStart());
     if (dlg->exec() == QDialog::Accepted && dlg != 0) {
       MyMoneyFileTransaction ft;
       try {
         schedule = dlg->schedule();
         MyMoneyFile::instance()->addSchedule(schedule);
         ft.commit();
 
       } catch (const MyMoneyException &e) {
-        KMessageBox::error(nullptr, i18n("Unable to add scheduled transaction: %1", e.what()), i18n("Add scheduled transaction"));
+        KMessageBox::error(nullptr, i18n("Unable to add scheduled transaction: %1", QString::fromLatin1(e.what())), i18n("Add scheduled transaction"));
       }
     }
   }
   delete transactionEditor;
   delete dlg;
 }
 
 void KEditScheduleDlg::editSchedule(const MyMoneySchedule& inputSchedule)
 {
     try {
       auto schedule = MyMoneyFile::instance()->schedule(inputSchedule.id());
 
       KEditScheduleDlg* sched_dlg = nullptr;
       KEditLoanWizard* loan_wiz = nullptr;
 
       switch (schedule.type()) {
         case eMyMoney::Schedule::Type::Bill:
         case eMyMoney::Schedule::Type::Deposit:
         case eMyMoney::Schedule::Type::Transfer:
         {
           sched_dlg = new KEditScheduleDlg(schedule, nullptr);
           QPointer<TransactionEditor> transactionEditor = sched_dlg->startEdit();
           if (transactionEditor) {
             KMyMoneyMVCCombo::setSubstringSearchForChildren(sched_dlg, !KMyMoneySettings::stringMatchFromStart());
             if (sched_dlg->exec() == QDialog::Accepted) {
               MyMoneyFileTransaction ft;
               try {
                 MyMoneySchedule sched = sched_dlg->schedule();
                 // Check whether the new Schedule Date
                 // is at or before the lastPaymentDate
                 // If it is, ask the user whether to clear the
                 // lastPaymentDate
                 const auto& next = sched.nextDueDate();
                 const auto& last = sched.lastPayment();
                 if (next.isValid() && last.isValid() && next <= last) {
                   // Entered a date effectively no later
                   // than previous payment.  Date would be
                   // updated automatically so we probably
                   // want to clear it.  Let's ask the user.
                   if (KMessageBox::questionYesNo(nullptr, i18n("<qt>You have entered a scheduled transaction date of <b>%1</b>.  Because the scheduled transaction was last paid on <b>%2</b>, KMyMoney will automatically adjust the scheduled transaction date to the next date unless the last payment date is reset.  Do you want to reset the last payment date?</qt>", QLocale().toString(next, QLocale::ShortFormat), QLocale().toString(last, QLocale::ShortFormat)), i18n("Reset Last Payment Date"), KStandardGuiItem::yes(), KStandardGuiItem::no()) == KMessageBox::Yes) {
                     sched.setLastPayment(QDate());
                   }
                 }
                 MyMoneyFile::instance()->modifySchedule(sched);
                 // delete the editor before we emit the dataChanged() signal from the
                 // engine. Calling this twice in a row does not hurt.
                 delete transactionEditor;
                 ft.commit();
               } catch (const MyMoneyException &e) {
-                KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), e.what());
+                KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), QString::fromLatin1(e.what()));
               }
             }
             delete transactionEditor;
           }
           delete sched_dlg;
           break;
         }
         case eMyMoney::Schedule::Type::LoanPayment:
         {
           loan_wiz = new KEditLoanWizard(schedule.account(2));
           if (loan_wiz->exec() == QDialog::Accepted) {
             MyMoneyFileTransaction ft;
             try {
               MyMoneyFile::instance()->modifySchedule(loan_wiz->schedule());
               MyMoneyFile::instance()->modifyAccount(loan_wiz->account());
               ft.commit();
             } catch (const MyMoneyException &e) {
-              KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), e.what());
+              KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), QString::fromLatin1(e.what()));
             }
           }
           delete loan_wiz;
           break;
         }
         case eMyMoney::Schedule::Type::Any:
           break;
       }
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), e.what());
+      KMessageBox::detailedSorry(nullptr, i18n("Unable to modify scheduled transaction '%1'", inputSchedule.name()), QString::fromLatin1(e.what()));
     }
 }
 
 bool KEditScheduleDlg::focusNextPrevChild(bool next)
 {
   Q_D(KEditScheduleDlg);
   auto rc = false;
 
   auto w = qApp->focusWidget();
   auto currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
   while (w && currentWidgetIndex == -1) {
     // qDebug("'%s' not in list, use parent", qPrintable(w->objectName()));
     w = w->parentWidget();
     currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
   }
 
   if (currentWidgetIndex != -1) {
     do {
       // if(w) qDebug("tab order is at '%s (%d/%d)'", qPrintable(w->objectName()), currentWidgetIndex, d->m_tabOrderWidgets.size());
       currentWidgetIndex += next ? 1 : -1;
       if (currentWidgetIndex < 0)
         currentWidgetIndex = d->m_tabOrderWidgets.size() - 1;
       else if (currentWidgetIndex >= d->m_tabOrderWidgets.size())
         currentWidgetIndex = 0;
 
       w = d->m_tabOrderWidgets[currentWidgetIndex];
       // qDebug("currentWidgetIndex = %d, w = %p", currentWidgetIndex, w);
 
       if (((w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus) && w->isVisible() && w->isEnabled()) {
         // qDebug("Selecting '%s' as focus", qPrintable(w->objectName()));
         w->setFocus();
         rc = true;
       }
     } while (rc == false);
   }
   return rc;
 }
 
 void KEditScheduleDlg::resizeEvent(QResizeEvent* ev)
 {
   Q_D(KEditScheduleDlg);
   d->ui->m_register->resize((int)eWidgets::eTransaction::Column::Detail);
   d->ui->m_form->resize((int)eWidgets::eTransactionForm::Column::Value1);
   QDialog::resizeEvent(ev);
 }
 
 
 void KEditScheduleDlg::slotRemainingChanged(int value)
 {
   Q_D(KEditScheduleDlg);
   // Make sure the required fields are set
   if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(d->m_editor->haveWidget("postdate")))
     d->m_schedule.setNextDueDate(dateEdit->date());
   d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(d->ui->m_frequencyEdit->currentItem()));
   d->m_schedule.setOccurrenceMultiplier(d->ui->m_frequencyNoEdit->value());
 
   if (d->m_schedule.transactionsRemaining() != value) {
     d->ui->m_FinalPaymentEdit->blockSignals(true);
     d->ui->m_FinalPaymentEdit->setDate(d->m_schedule.dateAfter(value));
     d->ui->m_FinalPaymentEdit->blockSignals(false);
   }
 }
 
 void KEditScheduleDlg::slotEndDateChanged(const QDate& date)
 {
   Q_D(KEditScheduleDlg);
   // Make sure the required fields are set
   if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(d->m_editor->haveWidget("postdate")))
     d->m_schedule.setNextDueDate(dateEdit->date());
   d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(d->ui->m_frequencyEdit->currentItem()));
   d->m_schedule.setOccurrenceMultiplier(d->ui->m_frequencyNoEdit->value());
 
   if (d->m_schedule.endDate() != date) {
     d->m_schedule.setEndDate(date);
     d->updateTransactionsRemaining();
   }
 }
 
 void KEditScheduleDlg::slotPostDateChanged(const QDate& date)
 {
   Q_D(KEditScheduleDlg);
   if (d->m_schedule.nextDueDate() != date) {
     if (d->ui->m_endOptionsFrame->isEnabled()) {
       d->m_schedule.setNextDueDate(date);
       d->m_schedule.setOccurrenceMultiplier(d->ui->m_frequencyNoEdit->value());
       d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(d->ui->m_frequencyEdit->currentItem()));
       d->m_schedule.setEndDate(d->ui->m_FinalPaymentEdit->date());
       d->updateTransactionsRemaining();
     }
   }
 }
 
 void KEditScheduleDlg::slotSetPaymentMethod(int item)
 {
   Q_D(KEditScheduleDlg);
   if (auto dateEdit = dynamic_cast<KMyMoneyLineEdit*>(d->m_editor->haveWidget("number"))) {
     dateEdit->setVisible(item == (int)Schedule::PaymentType::WriteChecque);
 
     // hiding the label does not work, because the label underneath will shine
     // through. So we either write the label or a blank
     if (auto label = dynamic_cast<QLabel *>(d->m_editor->haveWidget("number-label")))
       label->setText((item == (int)Schedule::PaymentType::WriteChecque) ? i18n("Number") : " ");
   }
 }
 
 void KEditScheduleDlg::slotFrequencyChanged(int item)
 {
   Q_D(KEditScheduleDlg);
   d->ui->m_endSeriesEdit->setEnabled(item != (int)Schedule::Occurrence::Once);
   bool isEndSeries = d->ui->m_endSeriesEdit->isChecked();
   if (isEndSeries)
     d->ui->m_endOptionsFrame->setEnabled(item != (int)Schedule::Occurrence::Once);
   switch (item) {
     case (int)Schedule::Occurrence::Daily:
     case (int)Schedule::Occurrence::Weekly:
       d->ui->m_frequencyNoEdit->setEnabled(true);
       d->ui->m_lastDayInMonthEdit->setEnabled(false);
       break;
 
     case (int)Schedule::Occurrence::EveryHalfMonth:
     case (int)Schedule::Occurrence::Monthly:
     case (int)Schedule::Occurrence::Yearly:
       // Supports Frequency Number
       d->ui->m_frequencyNoEdit->setEnabled(true);
       d->ui->m_lastDayInMonthEdit->setEnabled(true);
       break;
 
     default:
       // Multiplier is always 1
       d->ui->m_frequencyNoEdit->setEnabled(false);
       d->ui->m_frequencyNoEdit->setValue(1);
       d->ui->m_lastDayInMonthEdit->setEnabled(true);
       break;
   }
   if (isEndSeries && (item != (int)Schedule::Occurrence::Once)) {
     // Changing the frequency changes the number
     // of remaining transactions
     if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(d->m_editor->haveWidget("postdate")))
       d->m_schedule.setNextDueDate(dateEdit->date());
     d->m_schedule.setOccurrenceMultiplier(d->ui->m_frequencyNoEdit->value());
     d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(item));
     d->m_schedule.setEndDate(d->ui->m_FinalPaymentEdit->date());
     d->updateTransactionsRemaining();
   }
 }
 
 void KEditScheduleDlg::slotOccurrenceMultiplierChanged(int multiplier)
 {
   Q_D(KEditScheduleDlg);
   // Make sure the required fields are set
   auto oldOccurrenceMultiplier = d->m_schedule.occurrenceMultiplier();
   if (multiplier != oldOccurrenceMultiplier) {
     if (d->ui->m_endOptionsFrame->isEnabled()) {
       if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(d->m_editor->haveWidget("postdate")))
         d->m_schedule.setNextDueDate(dateEdit->date());
       d->m_schedule.setOccurrenceMultiplier(multiplier);
       d->m_schedule.setOccurrencePeriod(static_cast<Schedule::Occurrence>(d->ui->m_frequencyEdit->currentItem()));
       d->m_schedule.setEndDate(d->ui->m_FinalPaymentEdit->date());
       d->updateTransactionsRemaining();
     }
   }
 }
 
 void KEditScheduleDlg::slotShowHelp()
 {
   KHelpClient::invokeHelp("details.schedules.intro");
 }
 
 void KEditScheduleDlg::slotFilterPaymentType(int index)
 {
   Q_D(KEditScheduleDlg);
   //save selected item to reload if possible
   auto selectedId = d->ui->m_paymentMethodEdit->itemData(d->ui->m_paymentMethodEdit->currentIndex(), Qt::UserRole).toInt();
 
   //clear and reload the widget with the correct items
   d->ui->m_paymentMethodEdit->clear();
 
   // load option widgets
   eWidgets::eRegister::Action action = static_cast<eWidgets::eRegister::Action>(index);
   if (action != eWidgets::eRegister::Action::Withdrawal) {
     d->ui->m_paymentMethodEdit->insertItem(i18n("Direct deposit"), (int)Schedule::PaymentType::DirectDeposit);
     d->ui->m_paymentMethodEdit->insertItem(i18n("Manual deposit"), (int)Schedule::PaymentType::ManualDeposit);
   }
   if (action != eWidgets::eRegister::Action::Deposit) {
     d->ui->m_paymentMethodEdit->insertItem(i18n("Direct debit"), (int)Schedule::PaymentType::DirectDebit);
     d->ui->m_paymentMethodEdit->insertItem(i18n("Write check"), (int)Schedule::PaymentType::WriteChecque);
   }
   d->ui->m_paymentMethodEdit->insertItem(i18n("Standing order"), (int)Schedule::PaymentType::StandingOrder);
   d->ui->m_paymentMethodEdit->insertItem(i18n("Bank transfer"), (int)Schedule::PaymentType::BankTransfer);
   d->ui->m_paymentMethodEdit->insertItem(i18nc("Other payment method", "Other"), (int)Schedule::PaymentType::Other);
 
   auto newIndex = d->ui->m_paymentMethodEdit->findData(QVariant(selectedId), Qt::UserRole, Qt::MatchExactly);
   if (newIndex > -1) {
     d->ui->m_paymentMethodEdit->setCurrentIndex(newIndex);
   } else {
     d->ui->m_paymentMethodEdit->setCurrentIndex(0);
   }
 
 }
diff --git a/kmymoney/dialogs/kenterscheduledlg.cpp b/kmymoney/dialogs/kenterscheduledlg.cpp
index b80cf54ac..f97e07d89 100644
--- a/kmymoney/dialogs/kenterscheduledlg.cpp
+++ b/kmymoney/dialogs/kenterscheduledlg.cpp
@@ -1,387 +1,387 @@
 /***************************************************************************
                           kenterscheduledlg.cpp
                              -------------------
     begin                : Sat Apr  7 2007
     copyright            : (C) 2007 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kenterscheduledlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QWidget>
 #include <QLabel>
 #include <QPushButton>
 #include <QIcon>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KHelpClient>
 #include <KLocalizedString>
 #include <KGuiItem>
 #include <KStandardGuiItem>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kenterscheduledlg.h"
 
 #include "tabbar.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneyschedule.h"
 #include "register.h"
 #include "transactionform.h"
 #include "transaction.h"
 #include "selectedtransactions.h"
 #include "transactioneditor.h"
 #include "kmymoneyutils.h"
 #include "kmymoneylineedit.h"
 #include "kmymoneydateinput.h"
 #include "knewaccountdlg.h"
 #include "knewinvestmentwizard.h"
 #include "mymoneyexception.h"
 #include "icons/icons.h"
 #include "mymoneyenums.h"
 #include "dialogenums.h"
 #include "widgetenums.h"
 
 using namespace Icons;
 
 class KEnterScheduleDlgPrivate
 {
   Q_DISABLE_COPY(KEnterScheduleDlgPrivate)
 
 public:
   KEnterScheduleDlgPrivate() :
     ui(new Ui::KEnterScheduleDlg),
     m_item(nullptr),
     m_showWarningOnce(true),
     m_extendedReturnCode(eDialogs::ScheduleResultCode::Cancel)
   {
   }
 
   ~KEnterScheduleDlgPrivate()
   {
     delete ui;
   }
 
   Ui::KEnterScheduleDlg         *ui;
   MyMoneySchedule                m_schedule;
   KMyMoneyRegister::Transaction* m_item;
   QWidgetList                    m_tabOrderWidgets;
   bool                           m_showWarningOnce;
   eDialogs::ScheduleResultCode m_extendedReturnCode;
 };
 
 KEnterScheduleDlg::KEnterScheduleDlg(QWidget *parent, const MyMoneySchedule& schedule) :
   QDialog(parent),
   d_ptr(new KEnterScheduleDlgPrivate)
 {
   Q_D(KEnterScheduleDlg);
   d->ui->setupUi(this);
   d->m_schedule = schedule;
   d->m_extendedReturnCode = eDialogs::ScheduleResultCode::Enter;
   d->ui->buttonOk->setIcon(Icons::get(Icon::KeyEnter));
   d->ui->buttonSkip->setIcon(Icons::get(Icon::MediaSeekForward));
   KGuiItem::assign(d->ui->buttonCancel, KStandardGuiItem::cancel());
   KGuiItem::assign(d->ui->buttonHelp, KStandardGuiItem::help());
   d->ui->buttonIgnore->setHidden(true);
   d->ui->buttonSkip->setHidden(true);
 
   // make sure, we have a tabbar with the form
   KMyMoneyTransactionForm::TabBar* tabbar = d->ui->m_form->getTabBar(d->ui->m_form->parentWidget());
 
   // we never need to see the register
   d->ui->m_register->hide();
 
   // ... setup the form ...
   d->ui->m_form->setupForm(d->m_schedule.account());
 
   // ... and the register ...
   d->ui->m_register->clear();
 
   // ... now add the transaction to register and form ...
   MyMoneyTransaction t = transaction();
   d->m_item = KMyMoneyRegister::Register::transactionFactory(d->ui->m_register, t,
               d->m_schedule.transaction().splits().isEmpty() ? MyMoneySplit() : d->m_schedule.transaction().splits().front(), 0);
   d->ui->m_register->selectItem(d->m_item);
   // show the account row
   d->m_item->setShowRowInForm(0, true);
 
   d->ui->m_form->slotSetTransaction(d->m_item);
 
   // no need to see the tabbar
   tabbar->hide();
 
   // setup name and type
   d->ui->m_scheduleName->setText(d->m_schedule.name());
   d->ui->m_type->setText(KMyMoneyUtils::scheduleTypeToString(d->m_schedule.type()));
 
   connect(d->ui->buttonHelp, &QAbstractButton::clicked, this, &KEnterScheduleDlg::slotShowHelp);
   connect(d->ui->buttonIgnore, &QAbstractButton::clicked, this, &KEnterScheduleDlg::slotIgnore);
   connect(d->ui->buttonSkip, &QAbstractButton::clicked, this, &KEnterScheduleDlg::slotSkip);
 }
 
 KEnterScheduleDlg::~KEnterScheduleDlg()
 {
   Q_D(KEnterScheduleDlg);
   delete d;
 }
 
 eDialogs::ScheduleResultCode KEnterScheduleDlg::resultCode() const
 {
   Q_D(const KEnterScheduleDlg);
   if (result() == QDialog::Accepted)
     return d->m_extendedReturnCode;
   return eDialogs::ScheduleResultCode::Cancel;
 }
 
 void KEnterScheduleDlg::showExtendedKeys(bool visible)
 {
   Q_D(KEnterScheduleDlg);
   d->ui->buttonIgnore->setVisible(visible);
   d->ui->buttonSkip->setVisible(visible);
 }
 
 void KEnterScheduleDlg::slotIgnore()
 {
   Q_D(KEnterScheduleDlg);
   d->m_extendedReturnCode = eDialogs::ScheduleResultCode::Ignore;
   accept();
 }
 
 void KEnterScheduleDlg::slotSkip()
 {
   Q_D(KEnterScheduleDlg);
   d->m_extendedReturnCode = eDialogs::ScheduleResultCode::Skip;
   accept();
 }
 
 MyMoneyTransaction KEnterScheduleDlg::transaction()
 {
   Q_D(KEnterScheduleDlg);
   auto t = d->m_schedule.transaction();
 
   try {
     if (d->m_schedule.type() == eMyMoney::Schedule::Type::LoanPayment) {
       KMyMoneyUtils::calculateAutoLoan(d->m_schedule, t, QMap<QString, MyMoneyMoney>());
     }
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedError(this, i18n("Unable to load schedule details"), e.what());
+    KMessageBox::detailedError(this, i18n("Unable to load schedule details"), QString::fromLatin1(e.what()));
   }
 
   t.clearId();
   t.setEntryDate(QDate());
   return t;
 }
 
 QDate KEnterScheduleDlg::date(const QDate& _date) const
 {
   Q_D(const KEnterScheduleDlg);
   auto date(_date);
   return d->m_schedule.adjustedDate(date, d->m_schedule.weekendOption());
 }
 
 void KEnterScheduleDlg::resizeEvent(QResizeEvent* ev)
 {
   Q_UNUSED(ev)
   Q_D(KEnterScheduleDlg);
   d->ui->m_register->resize((int)eWidgets::eTransaction::Column::Detail);
   d->ui->m_form->resize((int)eWidgets::eTransactionForm::Column::Value1);
   QDialog::resizeEvent(ev);
 }
 
 void KEnterScheduleDlg::slotSetupSize()
 {
   resize(width(), minimumSizeHint().height());
 }
 
 int KEnterScheduleDlg::exec()
 {
   Q_D(KEnterScheduleDlg);
   if (d->m_showWarningOnce) {
     d->m_showWarningOnce = false;
     KMessageBox::information(this, QString("<qt>") + i18n("<p>Please check that all the details in the following dialog are correct and press OK.</p><p>Editable data can be changed and can either be applied to just this occurrence or for all subsequent occurrences for this schedule.  (You will be asked what you intend after pressing OK in the following dialog)</p>") + QString("</qt>"), i18n("Enter scheduled transaction"), "EnterScheduleDlgInfo");
   }
 
   // force the initial height to be as small as possible
   QTimer::singleShot(0, this, SLOT(slotSetupSize()));
   return QDialog::exec();
 }
 
 TransactionEditor* KEnterScheduleDlg::startEdit()
 {
   Q_D(KEnterScheduleDlg);
   KMyMoneyRegister::SelectedTransactions list(d->ui->m_register);
   auto editor = d->m_item->createEditor(d->ui->m_form, list, QDate());
   if (editor) {
     editor->setScheduleInfo(d->m_schedule.name());
     editor->setPaymentMethod(d->m_schedule.paymentType());
   }
 
   // check that we use the same transaction commodity in all selected transactions
   // if not, we need to update this in the editor's list. The user can also bail out
   // of this operation which means that we have to stop editing here.
   if (editor) {
     if (!editor->fixTransactionCommodity(d->m_schedule.account())) {
       // if the user wants to quit, we need to destroy the editor
       // and bail out
       delete editor;
       editor = 0;
     }
   }
 
   if (editor) {
     connect(editor, &TransactionEditor::transactionDataSufficient, d->ui->buttonOk, &QWidget::setEnabled);
     connect(editor, &TransactionEditor::escapePressed, d->ui->buttonCancel, &QAbstractButton::animateClick);
     connect(editor, &TransactionEditor::returnPressed, d->ui->buttonOk, &QAbstractButton::animateClick);
 
     connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, editor, &TransactionEditor::slotReloadEditWidgets);
     // connect(editor, SIGNAL(finishEdit(KMyMoneyRegister::SelectedTransactions)), this, SLOT(slotLeaveEditMode(KMyMoneyRegister::SelectedTransactions)));
     connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, editor, &TransactionEditor::slotReloadEditWidgets);
 
     // create the widgets, place them in the parent and load them with data
     // setup tab order
     d->m_tabOrderWidgets.clear();
     eWidgets::eRegister::Action action = eWidgets::eRegister::Action::Withdrawal;
     switch (d->m_schedule.type()) {
       case eMyMoney::Schedule::Type::Transfer:
         action = eWidgets::eRegister::Action::Transfer;
         break;
       case eMyMoney::Schedule::Type::Deposit:
         action = eWidgets::eRegister::Action::Deposit;
         break;
       case eMyMoney::Schedule::Type::LoanPayment:
         switch (d->m_schedule.paymentType()) {
           case eMyMoney::Schedule::PaymentType::DirectDeposit:
           case eMyMoney::Schedule::PaymentType::ManualDeposit:
             action = eWidgets::eRegister::Action::Deposit;
             break;
           default:
             break;
         }
         break;
       default:
         break;
     }
     editor->setup(d->m_tabOrderWidgets, d->m_schedule.account(), action);
 
     MyMoneyTransaction t = d->m_schedule.transaction();
     QString num = t.splits().first().number();
     QWidget* w = editor->haveWidget("number");
     if (d->m_schedule.paymentType() == eMyMoney::Schedule::PaymentType::WriteChecque) {
       auto file = MyMoneyFile::instance();
       if (file->checkNoUsed(d->m_schedule.account().id(), num)) {
         //  increment and try again
         num = KMyMoneyUtils::getAdjacentNumber(num);
       }
       num = KMyMoneyUtils::nextCheckNumber(d->m_schedule.account());
       KMyMoneyUtils::updateLastNumberUsed(d->m_schedule.account(), num);
       d->m_schedule.account().setValue("lastNumberUsed", num);
       if (w)
         if (auto numberWidget = dynamic_cast<KMyMoneyLineEdit*>(w))
           numberWidget->loadText(num);
     } else {
       // if it's not a check, then we need to clear
       // a possibly assigned check number
       if (w)
         if (auto numberWidget = dynamic_cast<KMyMoneyLineEdit*>(w))
           numberWidget->loadText(QString());
     }
 
     Q_ASSERT(!d->m_tabOrderWidgets.isEmpty());
 
     // editor->setup() leaves the tabbar as the last widget in the stack, but we
     // need it as first here. So we move it around.
     w = editor->haveWidget("tabbar");
     if (w) {
       int idx = d->m_tabOrderWidgets.indexOf(w);
       if (idx != -1) {
         d->m_tabOrderWidgets.removeAt(idx);
         d->m_tabOrderWidgets.push_front(w);
       }
     }
 
     // don't forget our three buttons
     d->m_tabOrderWidgets.append(d->ui->buttonOk);
     d->m_tabOrderWidgets.append(d->ui->buttonCancel);
     d->m_tabOrderWidgets.append(d->ui->buttonHelp);
 
     for (auto i = 0; i < d->m_tabOrderWidgets.size(); ++i) {
       w = d->m_tabOrderWidgets.at(i);
       if (w) {
         w->installEventFilter(this);
         w->installEventFilter(editor);
       }
     }
     // Check if the editor has some preference on where to set the focus
     // If not, set the focus to the first widget in the tab order
     QWidget* focusWidget = editor->firstWidget();
     if (!focusWidget)
       focusWidget = d->m_tabOrderWidgets.first();
     focusWidget->setFocus();
 
     // Make sure, we use the adjusted date
     if (auto dateEdit = dynamic_cast<KMyMoneyDateInput*>(editor->haveWidget("postdate")))
       dateEdit->setDate(d->m_schedule.adjustedNextDueDate());
   }
 
   return editor;
 }
 
 bool KEnterScheduleDlg::focusNextPrevChild(bool next)
 {
   Q_D(KEnterScheduleDlg);
   auto rc = false;
 
   auto w = qApp->focusWidget();
   int currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
   while (w && currentWidgetIndex == -1) {
     // qDebug("'%s' not in list, use parent", w->className());
     w = w->parentWidget();
     currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
   }
 
   if (currentWidgetIndex != -1) {
     // if(w) qDebug("tab order is at '%s'", w->className());
     currentWidgetIndex += next ? 1 : -1;
     if (currentWidgetIndex < 0)
       currentWidgetIndex = d->m_tabOrderWidgets.size() - 1;
     else if (currentWidgetIndex >= d->m_tabOrderWidgets.size())
       currentWidgetIndex = 0;
 
     w = d->m_tabOrderWidgets[currentWidgetIndex];
     // qDebug("currentWidgetIndex = %d, w = %p", currentWidgetIndex, w);
 
     if (((w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus) && w->isVisible() && w->isEnabled()) {
       // qDebug("Selecting '%s' as focus", w->className());
       w->setFocus();
       rc = true;
     }
   }
   return rc;
 }
 
 void KEnterScheduleDlg::slotShowHelp()
 {
   KHelpClient::invokeHelp("details.schedules.entering");
 }
diff --git a/kmymoney/dialogs/kequitypriceupdatedlg.cpp b/kmymoney/dialogs/kequitypriceupdatedlg.cpp
index 1a5a6abf7..22347a57e 100644
--- a/kmymoney/dialogs/kequitypriceupdatedlg.cpp
+++ b/kmymoney/dialogs/kequitypriceupdatedlg.cpp
@@ -1,818 +1,818 @@
 /***************************************************************************
                           kequitypriceupdatedlg.cpp  -  description
                              -------------------
     begin                : Mon Sep 1 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kequitypriceupdatedlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPushButton>
 #include <QTimer>
 #include <QList>
 #include <QPointer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KTextEdit>
 #include <KConfig>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 #include <KLocalizedString>
 #include <KColorScheme>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kequitypriceupdatedlg.h"
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "webpricequote.h"
 #include "kequitypriceupdateconfdlg.h"
 #include "kmymoneyutils.h"
 #include "mymoneyexception.h"
 #include "dialogenums.h"
 
 #define WEBID_COL       0
 #define NAME_COL        1
 #define PRICE_COL       2
 #define DATE_COL        3
 #define KMMID_COL       4
 #define SOURCE_COL      5
 
 class KEquityPriceUpdateDlgPrivate
 {
   Q_DISABLE_COPY(KEquityPriceUpdateDlgPrivate)
   Q_DECLARE_PUBLIC(KEquityPriceUpdateDlg)
 
 public:
   explicit KEquityPriceUpdateDlgPrivate(KEquityPriceUpdateDlg *qq) :
     q_ptr(qq),
     ui(new Ui::KEquityPriceUpdateDlg),
     m_fUpdateAll(false),
     m_updatingPricePolicy(eDialogs::UpdatePrice::All)
   {
   }
 
   ~KEquityPriceUpdateDlgPrivate()
   {
     delete ui;
   }
 
   void init(const QString& securityId)
   {
     Q_Q(KEquityPriceUpdateDlg);
     ui->setupUi(q);
     m_fUpdateAll = false;
     QStringList headerList;
     headerList << i18n("ID") << i18nc("Equity name", "Name")
     << i18n("Price") << i18n("Date");
 
     ui->lvEquityList->header()->setSortIndicator(0, Qt::AscendingOrder);
     ui->lvEquityList->setColumnWidth(NAME_COL, 125);
 
     // This is a "get it up and running" hack.  Will replace this in the future.
     headerList << i18nc("Internal identifier", "Internal ID")
     << i18nc("Online quote source", "Source");
     ui->lvEquityList->setColumnWidth(KMMID_COL, 0);
 
     ui->lvEquityList->setHeaderLabels(headerList);
 
     ui->lvEquityList->setSelectionMode(QAbstractItemView::MultiSelection);
     ui->lvEquityList->setAllColumnsShowFocus(true);
 
     ui->btnUpdateAll->setEnabled(false);
 
     auto file = MyMoneyFile::instance();
 
     //
     // Add each price pair that we know about
     //
 
     // send in securityId == "XXX YYY" to get a single-shot update for XXX to YYY.
     // for consistency reasons, this accepts the same delimiters as WebPriceQuote::launch()
     QRegExp splitrx("([0-9a-z\\.]+)[^a-z0-9]+([0-9a-z\\.]+)", Qt::CaseInsensitive);
     MyMoneySecurityPair currencyIds;
     if (splitrx.indexIn(securityId) != -1) {
       currencyIds = MyMoneySecurityPair(splitrx.cap(1), splitrx.cap(2));
     }
 
     MyMoneyPriceList prices = file->priceList();
     for (MyMoneyPriceList::ConstIterator it_price = prices.constBegin(); it_price != prices.constEnd(); ++it_price) {
       const MyMoneySecurityPair& pair = it_price.key();
       if (file->security(pair.first).isCurrency() && (securityId.isEmpty() || (pair == currencyIds))) {
         const MyMoneyPriceEntries& entries = (*it_price);
         if (entries.count() > 0 && entries.begin().key() <= QDate::currentDate()) {
           addPricePair(pair, false);
           ui->btnUpdateAll->setEnabled(true);
         }
       }
     }
 
     //
     // Add each investment
     //
 
     QList<MyMoneySecurity> securities = file->securityList();
     for (QList<MyMoneySecurity>::const_iterator it = securities.constBegin(); it != securities.constEnd(); ++it) {
       if (!(*it).isCurrency()
           && (securityId.isEmpty() || ((*it).id() == securityId))
           && !(*it).value("kmm-online-source").isEmpty()
          ) {
         addInvestment(*it);
         ui->btnUpdateAll->setEnabled(true);
       }
     }
 
     // if list is empty, add the request price pair
     if (ui->lvEquityList->invisibleRootItem()->childCount() == 0) {
       addPricePair(currencyIds, true);
     }
 
     q->connect(ui->btnUpdateSelected, &QAbstractButton::clicked, q, &KEquityPriceUpdateDlg::slotUpdateSelectedClicked);
     q->connect(ui->btnUpdateAll, &QAbstractButton::clicked, q, &KEquityPriceUpdateDlg::slotUpdateAllClicked);
 
     q->connect(ui->m_fromDate, &KMyMoneyDateInput::dateChanged, q, &KEquityPriceUpdateDlg::slotDateChanged);
     q->connect(ui->m_toDate, &KMyMoneyDateInput::dateChanged, q, &KEquityPriceUpdateDlg::slotDateChanged);
 
     q->connect(&m_webQuote, &WebPriceQuote::csvquote,
             q, &KEquityPriceUpdateDlg::slotReceivedCSVQuote);
     q->connect(&m_webQuote, &WebPriceQuote::quote,
             q, &KEquityPriceUpdateDlg::slotReceivedQuote);
     q->connect(&m_webQuote, &WebPriceQuote::failed,
             q, &KEquityPriceUpdateDlg::slotQuoteFailed);
     q->connect(&m_webQuote, &WebPriceQuote::status,
             q, &KEquityPriceUpdateDlg::logStatusMessage);
     q->connect(&m_webQuote, &WebPriceQuote::error,
             q, &KEquityPriceUpdateDlg::logErrorMessage);
 
     q->connect(ui->lvEquityList, &QTreeWidget::itemSelectionChanged, q, &KEquityPriceUpdateDlg::slotUpdateSelection);
 
     q->connect(ui->btnConfigure, &QAbstractButton::clicked, q, &KEquityPriceUpdateDlg::slotConfigureClicked);
 
     if (!securityId.isEmpty()) {
       ui->btnUpdateSelected->hide();
       ui->btnUpdateAll->hide();
       // delete layout1;
 
       QTimer::singleShot(100, q, SLOT(slotUpdateAllClicked()));
     }
 
     // Hide OK button until we have received the first update
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 
     q->slotUpdateSelection();
 
     // previous versions of this dialog allowed to store a "Don't ask again" switch.
     // Since we don't support it anymore, we just get rid of it
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup grp = config->group("Notification Messages");
     grp.deleteEntry("KEquityPriceUpdateDlg::slotQuoteFailed::Price Update Failed");
     grp.sync();
     grp = config->group("Equity Price Update");
     int policyValue = grp.readEntry("PriceUpdatingPolicy", (int)eDialogs::UpdatePrice::Missing);
     if (policyValue > (int)eDialogs::UpdatePrice::Ask || policyValue < (int)eDialogs::UpdatePrice::All)
       m_updatingPricePolicy = eDialogs::UpdatePrice::Missing;
     else
       m_updatingPricePolicy = static_cast<eDialogs::UpdatePrice>(policyValue);
   }
 
   void addPricePair(const MyMoneySecurityPair& pair, bool dontCheckExistance)
   {
     auto file = MyMoneyFile::instance();
 
     const auto symbol = QString::fromLatin1("%1 > %2").arg(pair.first, pair.second);
     const auto id = QString::fromLatin1("%1 %2").arg(pair.first, pair.second);
     // Check that the pair does not already exist
     if (ui->lvEquityList->findItems(id, Qt::MatchExactly, KMMID_COL).empty()) {
       const MyMoneyPrice &pr = file->price(pair.first, pair.second);
       if (pr.source() != QLatin1String("KMyMoney")) {
         bool keep = true;
         if ((pair.first == file->baseCurrency().id())
             || (pair.second == file->baseCurrency().id())) {
           const QString& foreignCurrency = file->foreignCurrency(pair.first, pair.second);
           // check that the foreign currency is still in use
           QList<MyMoneyAccount>::const_iterator it_a;
           QList<MyMoneyAccount> list;
           file->accountList(list);
           for (it_a = list.constBegin(); !dontCheckExistance && it_a != list.constEnd(); ++it_a) {
             // if it's an account denominated in the foreign currency
             // keep it
             if (((*it_a).currencyId() == foreignCurrency)
                 && !(*it_a).isClosed())
               break;
             // if it's an investment traded in the foreign currency
             // keep it
             if ((*it_a).isInvest() && !(*it_a).isClosed()) {
               MyMoneySecurity sec = file->security((*it_a).currencyId());
               if (sec.tradingCurrency() == foreignCurrency)
                 break;
             }
           }
           // if it is in use, it_a is not equal to list.end()
           if (it_a == list.constEnd() && !dontCheckExistance)
             keep = false;
         }
 
         if (keep) {
           auto item = new QTreeWidgetItem();
           item->setText(WEBID_COL, symbol);
           item->setText(NAME_COL, i18n("%1 units in %2", pair.first, pair.second));
           if (pr.isValid()) {
             MyMoneySecurity fromCurrency = file->currency(pair.second);
             MyMoneySecurity toCurrency = file->currency(pair.first);
             item->setText(PRICE_COL, pr.rate(pair.second).formatMoney(fromCurrency.tradingSymbol(), toCurrency.pricePrecision()));
             item->setText(DATE_COL, pr.date().toString(Qt::ISODate));
           }
           item->setText(KMMID_COL, id);
           item->setText(SOURCE_COL, "KMyMoney Currency");  // This string value should not be localized
           ui->lvEquityList->invisibleRootItem()->addChild(item);
         }
       }
     }
   }
 
   void addInvestment(const MyMoneySecurity& inv)
   {
     const auto id = inv.id();
     // Check that the pair does not already exist
     if (ui->lvEquityList->findItems(id, Qt::MatchExactly, KMMID_COL).empty()) {
       auto file = MyMoneyFile::instance();
       // check that the security is still in use
       QList<MyMoneyAccount>::const_iterator it_a;
       QList<MyMoneyAccount> list;
       file->accountList(list);
       for (it_a = list.constBegin(); it_a != list.constEnd(); ++it_a) {
         if ((*it_a).isInvest()
             && ((*it_a).currencyId() == inv.id())
             && !(*it_a).isClosed())
           break;
       }
       // if it is in use, it_a is not equal to list.end()
       if (it_a != list.constEnd()) {
         QString webID;
         WebPriceQuoteSource onlineSource(inv.value("kmm-online-source"));
         if (onlineSource.m_webIDBy == WebPriceQuoteSource::identifyBy::IdentificationNumber)
           webID = inv.value("kmm-security-id");   // insert ISIN number...
         else if (onlineSource.m_webIDBy == WebPriceQuoteSource::identifyBy::Name)
           webID = inv.name();                     // ...or name...
         else
           webID = inv.tradingSymbol();            // ...or symbol
 
         QTreeWidgetItem* item = new QTreeWidgetItem();
         item->setForeground(WEBID_COL, KColorScheme(QPalette::Normal).foreground(KColorScheme::NormalText));
         if (webID.isEmpty()) {
           webID = i18n("[No identifier]");
           item->setForeground(WEBID_COL, KColorScheme(QPalette::Normal).foreground(KColorScheme::NegativeText));
         }
         item->setText(WEBID_COL, webID);
         item->setText(NAME_COL, inv.name());
         MyMoneySecurity currency = file->currency(inv.tradingCurrency());
         const MyMoneyPrice &pr = file->price(id.toUtf8(), inv.tradingCurrency());
         if (pr.isValid()) {
           item->setText(PRICE_COL, pr.rate(currency.id()).formatMoney(currency.tradingSymbol(), inv.pricePrecision()));
           item->setText(DATE_COL, pr.date().toString(Qt::ISODate));
         }
         item->setText(KMMID_COL, id);
         if (inv.value("kmm-online-quote-system") == "Finance::Quote")
           item->setText(SOURCE_COL, QString("Finance::Quote %1").arg(inv.value("kmm-online-source")));
         else
           item->setText(SOURCE_COL, inv.value("kmm-online-source"));
 
         ui->lvEquityList->invisibleRootItem()->addChild(item);
 
         // If this investment is denominated in a foreign currency, ensure that
         // the appropriate price pair is also on the list
 
         if (currency.id() != file->baseCurrency().id()) {
           addPricePair(MyMoneySecurityPair(currency.id(), file->baseCurrency().id()), false);
         }
       }
     }
   }
 
   KEquityPriceUpdateDlg      *q_ptr;
   Ui::KEquityPriceUpdateDlg  *ui;
   bool                        m_fUpdateAll;
   eDialogs::UpdatePrice        m_updatingPricePolicy;
   WebPriceQuote               m_webQuote;
 };
 
 KEquityPriceUpdateDlg::KEquityPriceUpdateDlg(QWidget *parent, const QString& securityId) :
   QDialog(parent),
   d_ptr(new KEquityPriceUpdateDlgPrivate(this))
 {
   Q_D(KEquityPriceUpdateDlg);
   d->init(securityId);
 }
 
 KEquityPriceUpdateDlg::KEquityPriceUpdateDlg(QWidget *parent) :
   KEquityPriceUpdateDlg(parent, QString())
 {
 }
 
 KEquityPriceUpdateDlg::~KEquityPriceUpdateDlg()
 {
   Q_D(KEquityPriceUpdateDlg);
   auto config = KSharedConfig::openConfig();
   auto grp = config->group("Equity Price Update");
   grp.writeEntry("PriceUpdatingPolicy", static_cast<int>(d->m_updatingPricePolicy));
   grp.sync();
   delete d;
 }
 
 void KEquityPriceUpdateDlg::logErrorMessage(const QString& message)
 {
   logStatusMessage(QString("<font color=\"red\"><b>") + message + QString("</b></font>"));
 }
 
 void KEquityPriceUpdateDlg::logStatusMessage(const QString& message)
 {
   Q_D(KEquityPriceUpdateDlg);
   d->ui->lbStatus->append(message);
 }
 
 MyMoneyPrice KEquityPriceUpdateDlg::price(const QString& id) const
 {
   Q_D(const KEquityPriceUpdateDlg);
   MyMoneyPrice price;
   QTreeWidgetItem* item = nullptr;
   QList<QTreeWidgetItem*> foundItems = d->ui->lvEquityList->findItems(id, Qt::MatchExactly, KMMID_COL);
 
   if (! foundItems.empty())
     item = foundItems.at(0);
 
   if (item) {
     MyMoneyMoney rate(item->text(PRICE_COL));
     if (!rate.isZero()) {
       QString kmm_id = item->text(KMMID_COL).toUtf8();
 
       // if the ID has a space, then this is TWO ID's, so it's a currency quote
       if (kmm_id.contains(" ")) {
         QStringList ids = kmm_id.split(' ', QString::SkipEmptyParts);
         QString fromid = ids[0].toUtf8();
         QString toid = ids[1].toUtf8();
         price = MyMoneyPrice(fromid, toid, QDate().fromString(item->text(DATE_COL), Qt::ISODate), rate, item->text(SOURCE_COL));
       } else
         // otherwise, it's a security quote
       {
         MyMoneySecurity security = MyMoneyFile::instance()->security(kmm_id);
         price = MyMoneyPrice(kmm_id, security.tradingCurrency(), QDate().fromString(item->text(DATE_COL), Qt::ISODate), rate, item->text(SOURCE_COL));
       }
     }
   }
   return price;
 }
 
 void KEquityPriceUpdateDlg::storePrices()
 {
   Q_D(KEquityPriceUpdateDlg);
   // update the new prices into the equities
 
   auto file = MyMoneyFile::instance();
   QString name;
 
   MyMoneyFileTransaction ft;
   try {
     for (auto i = 0; i < d->ui->lvEquityList->invisibleRootItem()->childCount(); ++i) {
       QTreeWidgetItem* item = d->ui->lvEquityList->invisibleRootItem()->child(i);
       // turn on signals before we modify the last entry in the list
       file->blockSignals(i < d->ui->lvEquityList->invisibleRootItem()->childCount() - 1);
 
       MyMoneyMoney rate(item->text(PRICE_COL));
       if (!rate.isZero()) {
         QString id = item->text(KMMID_COL);
         QString fromid;
         QString toid;
 
         // if the ID has a space, then this is TWO ID's, so it's a currency quote
         if (id.contains(QLatin1Char(' '))) {
           QStringList ids = id.split(QLatin1Char(' '), QString::SkipEmptyParts);
           fromid = ids.at(0);
           toid = ids.at(1);
           name = QString::fromLatin1("%1 --> %2").arg(fromid, toid);
         } else { // otherwise, it's a security quote
           MyMoneySecurity security = file->security(id);
           name = security.name();
           fromid = id;
           toid = security.tradingCurrency();
         }
         // TODO (Ace) Better handling of the case where there is already a price
         // for this date.  Currently, it just overrides the old value.  Really it
         // should check to see if the price is the same and prompt the user.
         file->addPrice(MyMoneyPrice(fromid, toid, QDate::fromString(item->text(DATE_COL), Qt::ISODate), rate, item->text(SOURCE_COL)));
       }
     }
     ft.commit();
 
   } catch (const MyMoneyException &) {
     qDebug("Unable to add price information for %s", qPrintable(name));
   }
 }
 
 void KEquityPriceUpdateDlg::slotConfigureClicked()
 {
   Q_D(KEquityPriceUpdateDlg);
   QPointer<EquityPriceUpdateConfDlg> dlg = new EquityPriceUpdateConfDlg(d->m_updatingPricePolicy);
   if (dlg->exec() == QDialog::Accepted)
     d->m_updatingPricePolicy = dlg->policy();
   delete dlg;
 }
 
 void KEquityPriceUpdateDlg::slotUpdateSelection()
 {
   Q_D(KEquityPriceUpdateDlg);
   // Only enable the update button if there is a selection
   d->ui->btnUpdateSelected->setEnabled(false);
 
   if (! d->ui->lvEquityList->selectedItems().empty())
     d->ui->btnUpdateSelected->setEnabled(true);
 }
 
 void KEquityPriceUpdateDlg::slotUpdateSelectedClicked()
 {
   Q_D(KEquityPriceUpdateDlg);
   // disable sorting while the update is running to maintain the current order of items on which
   // the update process depends and which could be changed with sorting enabled due to the updated values
   d->ui->lvEquityList->setSortingEnabled(false);
   auto item = d->ui->lvEquityList->invisibleRootItem()->child(0);
   auto skipCnt = 1;
   while (item && !item->isSelected()) {
     item = d->ui->lvEquityList->invisibleRootItem()->child(skipCnt);
     ++skipCnt;
   }
   d->m_webQuote.setDate(d->ui->m_fromDate->date(), d->ui->m_toDate->date());
   if (item) {
     d->ui->prgOnlineProgress->setMaximum(1 + d->ui->lvEquityList->invisibleRootItem()->childCount());
     d->ui->prgOnlineProgress->setValue(skipCnt);
     d->m_webQuote.launch(item->text(WEBID_COL), item->text(KMMID_COL), item->text(SOURCE_COL));
 
   } else {
 
     logErrorMessage("No security selected.");
   }
 }
 
 void KEquityPriceUpdateDlg::slotUpdateAllClicked()
 {
   Q_D(KEquityPriceUpdateDlg);
   // disable sorting while the update is running to maintain the current order of items on which
   // the update process depends and which could be changed with sorting enabled due to the updated values
   d->ui->lvEquityList->setSortingEnabled(false);
   QTreeWidgetItem* item = d->ui->lvEquityList->invisibleRootItem()->child(0);
   if (item) {
     d->ui->prgOnlineProgress->setMaximum(1 + d->ui->lvEquityList->invisibleRootItem()->childCount());
     d->ui->prgOnlineProgress->setValue(1);
     d->m_fUpdateAll = true;
     d->m_webQuote.launch(item->text(WEBID_COL), item->text(KMMID_COL), item->text(SOURCE_COL));
 
   } else {
     logErrorMessage("Security list is empty.");
   }
 }
 
 void KEquityPriceUpdateDlg::slotDateChanged()
 {
   Q_D(KEquityPriceUpdateDlg);
   d->ui->m_fromDate->blockSignals(true);
   d->ui->m_toDate->blockSignals(true);
   if (d->ui->m_toDate->date() > QDate::currentDate())
     d->ui->m_toDate->setDate(QDate::currentDate());
   if (d->ui->m_fromDate->date() > d->ui->m_toDate->date())
     d->ui->m_fromDate->setDate(d->ui->m_toDate->date());
   d->ui->m_fromDate->blockSignals(false);
   d->ui->m_toDate->blockSignals(false);
 }
 
 void KEquityPriceUpdateDlg::slotQuoteFailed(const QString& _kmmID, const QString& _webID)
 {
   Q_D(KEquityPriceUpdateDlg);
   auto foundItems = d->ui->lvEquityList->findItems(_kmmID, Qt::MatchExactly, KMMID_COL);
   QTreeWidgetItem* item = nullptr;
 
   if (! foundItems.empty())
     item = foundItems.at(0);
 
   // Give the user some options
   int result;
   if (_kmmID.contains(" ")) {
     if (item)
       result = KMessageBox::warningContinueCancel(this, i18n("Failed to retrieve an exchange rate for %1 from %2. It will be skipped this time.", _webID, item->text(SOURCE_COL)), i18n("Price Update Failed"));
     else
       return;
   } else if (!item) {
     return;
   } else {
     result = KMessageBox::questionYesNoCancel(this, QString::fromLatin1("<qt>%1</qt>").arg(i18n("Failed to retrieve a quote for %1 from %2.  Press <b>No</b> to remove the online price source from this security permanently, <b>Yes</b> to continue updating this security during future price updates or <b>Cancel</b> to stop the current update operation.", _webID, item->text(SOURCE_COL))), i18n("Price Update Failed"), KStandardGuiItem::yes(), KStandardGuiItem::no());
   }
 
 
   if (result == KMessageBox::No) {
     // Disable price updates for this security
 
     MyMoneyFileTransaction ft;
     try {
       // Get this security (by ID)
       MyMoneySecurity security = MyMoneyFile::instance()->security(_kmmID.toUtf8());
 
       // Set the quote source to blank
       security.setValue("kmm-online-source", QString());
       security.setValue("kmm-online-quote-system", QString());
 
       // Re-commit the security
       MyMoneyFile::instance()->modifySecurity(security);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(this, QString("<qt>") + i18n("Cannot update security <b>%1</b>: %2", _webID, e.what()) + QString("</qt>"), i18n("Price Update Failed"));
+      KMessageBox::error(this, QString("<qt>") + i18n("Cannot update security <b>%1</b>: %2", _webID, QString::fromLatin1(e.what())) + QString("</qt>"), i18n("Price Update Failed"));
     }
   }
 
   // As long as the user doesn't want to cancel, move on!
   if (result != KMessageBox::Cancel) {
     QTreeWidgetItem* next = nullptr;
     d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
     item->setSelected(false);
 
     // launch the NEXT one ... in case of m_fUpdateAll == false, we
     // need to parse the list to find the next selected one
     next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(item) + 1);
     if (!d->m_fUpdateAll) {
       while (next && !next->isSelected()) {
         d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
         next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(next) + 1);
       }
     }
     if (next) {
       d->m_webQuote.launch(next->text(WEBID_COL), next->text(KMMID_COL), next->text(SOURCE_COL));
     } else {
       finishUpdate();
     }
   } else {
     finishUpdate();
   }
 }
 
 void KEquityPriceUpdateDlg::slotReceivedCSVQuote(const QString& _kmmID, const QString& _webID, MyMoneyStatement& st)
 {
   Q_D(KEquityPriceUpdateDlg);
   auto foundItems = d->ui->lvEquityList->findItems(_kmmID, Qt::MatchExactly, KMMID_COL);
   QTreeWidgetItem* item = nullptr;
 
   if (! foundItems.empty())
     item = foundItems.at(0);
 
   QTreeWidgetItem* next = nullptr;
 
   if (item) {
     auto file = MyMoneyFile::instance();
     MyMoneySecurity fromCurrency, toCurrency;
 
     if (!_kmmID.contains(QLatin1Char(' '))) {
       try {
         toCurrency = MyMoneyFile::instance()->security(_kmmID);
         fromCurrency = MyMoneyFile::instance()->security(toCurrency.tradingCurrency());
       } catch (const MyMoneyException &) {
         fromCurrency = toCurrency = MyMoneySecurity();
       }
 
     } else {
       QRegExp splitrx("([0-9a-z\\.]+)[^a-z0-9]+([0-9a-z\\.]+)", Qt::CaseInsensitive);
       if (splitrx.indexIn(_kmmID) != -1) {
         try {
           fromCurrency = MyMoneyFile::instance()->security(splitrx.cap(2).toUtf8());
           toCurrency = MyMoneyFile::instance()->security(splitrx.cap(1).toUtf8());
         } catch (const MyMoneyException &) {
           fromCurrency = toCurrency = MyMoneySecurity();
         }
       }
     }
 
     if (d->m_updatingPricePolicy != eDialogs::UpdatePrice::All) {
       QStringList qSources = WebPriceQuote::quoteSources();
       for (auto it = st.m_listPrices.begin(); it != st.m_listPrices.end();) {
         MyMoneyPrice storedPrice = file->price(toCurrency.id(), fromCurrency.id(), (*it).m_date, true);
         bool priceValid = storedPrice.isValid();
         if (!priceValid)
           ++it;
         else {
           switch(d->m_updatingPricePolicy) {
             case eDialogs::UpdatePrice::Missing:
               it = st.m_listPrices.erase(it);
               break;
             case eDialogs::UpdatePrice::Downloaded:
               if (!qSources.contains(storedPrice.source()))
                 it = st.m_listPrices.erase(it);
               else
                 ++it;
               break;
             case eDialogs::UpdatePrice::SameSource:
               if (storedPrice.source().compare((*it).m_sourceName) != 0)
                 it = st.m_listPrices.erase(it);
               else
                 ++it;
               break;
             case eDialogs::UpdatePrice::Ask:
             {
               auto result = KMessageBox::questionYesNoCancel(this,
                                                             i18n("For <b>%1</b> on <b>%2</b> price <b>%3</b> already exists.<br>"
                                                                  "Do you want to replace it with <b>%4</b>?",
                                                                  storedPrice.from(), storedPrice.date().toString(Qt::ISODate),
                                                                  QString().setNum(storedPrice.rate(storedPrice.to()).toDouble(), 'g', 10),
                                                                  QString().setNum((*it).m_amount.toDouble(), 'g', 10)),
                                                             i18n("Price Already Exists"));
               switch(result) {
                 case KMessageBox::ButtonCode::Yes:
                   ++it;
                   break;
                 case KMessageBox::ButtonCode::No:
                   it = st.m_listPrices.erase(it);
                   break;
                 default:
                 case KMessageBox::ButtonCode::Cancel:
                   finishUpdate();
                   return;
                   break;
               }
               break;
             }
             default:
               ++it;
               break;
           }
         }
       }
     }
 
     if (!st.m_listPrices.isEmpty()) {
       MyMoneyFileTransaction ft;
       KMyMoneyUtils::processPriceList(st);
       ft.commit();
 
       // latest price could be in the last or in the first row
       MyMoneyStatement::Price priceClass;
       if (st.m_listPrices.first().m_date > st.m_listPrices.last().m_date)
         priceClass = st.m_listPrices.first();
       else
         priceClass = st.m_listPrices.last();
 
       // update latest price in dialog if applicable
       auto latestDate = QDate::fromString(item->text(DATE_COL),Qt::ISODate);
       if (latestDate <= priceClass.m_date && priceClass.m_amount.isPositive()) {
         item->setText(PRICE_COL, priceClass.m_amount.formatMoney(fromCurrency.tradingSymbol(), toCurrency.pricePrecision()));
         item->setText(DATE_COL, priceClass.m_date.toString(Qt::ISODate));
         item->setText(SOURCE_COL, priceClass.m_sourceName);
       }
       logStatusMessage(i18n("Price for %1 updated (id %2)", _webID, _kmmID));
       // make sure to make OK button available
     }
     d->ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 
     d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
     item->setSelected(false);
 
     // launch the NEXT one ... in case of m_fUpdateAll == false, we
     // need to parse the list to find the next selected one
     next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(item) + 1);
     if (!d->m_fUpdateAll) {
       while (next && !next->isSelected()) {
         d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
         next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(next) + 1);
       }
     }
   } else {
     logErrorMessage(i18n("Received a price for %1 (id %2), but this symbol is not on the list. Aborting entire update.", _webID, _kmmID));
   }
 
   if (next) {
     d->m_webQuote.launch(next->text(WEBID_COL), next->text(KMMID_COL), next->text(SOURCE_COL));
   } else {
     finishUpdate();
   }
 }
 
 void KEquityPriceUpdateDlg::slotReceivedQuote(const QString& _kmmID, const QString& _webID, const QDate& _date, const double& _price)
 {
   Q_D(KEquityPriceUpdateDlg);
   auto foundItems = d->ui->lvEquityList->findItems(_kmmID, Qt::MatchExactly, KMMID_COL);
   QTreeWidgetItem* item = nullptr;
 
   if (! foundItems.empty())
     item = foundItems.at(0);
 
   QTreeWidgetItem* next = 0;
 
   if (item) {
     if (_price > 0.0f && _date.isValid()) {
       QDate date = _date;
       if (date > QDate::currentDate())
         date = QDate::currentDate();
 
       MyMoneyMoney price = MyMoneyMoney::ONE;
       QString id = _kmmID.toUtf8();
       MyMoneySecurity fromCurrency, toCurrency;
       if (_kmmID.contains(" ") == 0) {
         MyMoneySecurity security = MyMoneyFile::instance()->security(id);
         QString factor = security.value("kmm-online-factor");
         if (!factor.isEmpty()) {
           price = price * MyMoneyMoney(factor);
         }
         try {
           toCurrency = MyMoneyFile::instance()->security(id);
           fromCurrency = MyMoneyFile::instance()->security(toCurrency.tradingCurrency());
         } catch (const MyMoneyException &) {
           fromCurrency = toCurrency = MyMoneySecurity();
         }
 
       } else {
         QRegExp splitrx("([0-9a-z\\.]+)[^a-z0-9]+([0-9a-z\\.]+)", Qt::CaseInsensitive);
         if (splitrx.indexIn(_kmmID) != -1) {
           try {
             fromCurrency = MyMoneyFile::instance()->security(splitrx.cap(2).toUtf8());
             toCurrency = MyMoneyFile::instance()->security(splitrx.cap(1).toUtf8());
           } catch (const MyMoneyException &) {
             fromCurrency = toCurrency = MyMoneySecurity();
           }
         }
       }
       price *= MyMoneyMoney(_price, MyMoneyMoney::precToDenom(toCurrency.pricePrecision()));
 
       item->setText(PRICE_COL, price.formatMoney(fromCurrency.tradingSymbol(), toCurrency.pricePrecision()));
       item->setText(DATE_COL, date.toString(Qt::ISODate));
       logStatusMessage(i18n("Price for %1 updated (id %2)", _webID, _kmmID));
       // make sure to make OK button available
       d->ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     } else {
       logErrorMessage(i18n("Received an invalid price for %1, unable to update.", _webID));
     }
 
     d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
     item->setSelected(false);
 
     // launch the NEXT one ... in case of m_fUpdateAll == false, we
     // need to parse the list to find the next selected one
     next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(item) + 1);
     if (!d->m_fUpdateAll) {
       while (next && !next->isSelected()) {
         d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->value() + 1);
         next = d->ui->lvEquityList->invisibleRootItem()->child(d->ui->lvEquityList->invisibleRootItem()->indexOfChild(next) + 1);
       }
     }
   } else {
     logErrorMessage(i18n("Received a price for %1 (id %2), but this symbol is not on the list. Aborting entire update.", _webID, _kmmID));
   }
 
   if (next) {
     d->m_webQuote.launch(next->text(WEBID_COL), next->text(KMMID_COL), next->text(SOURCE_COL));
   } else {
     finishUpdate();
   }
 }
 
 void KEquityPriceUpdateDlg::finishUpdate()
 {
   Q_D(KEquityPriceUpdateDlg);
   // we've run past the end, reset to the default value.
   d->m_fUpdateAll = false;
   // force progress bar to show 100%
   d->ui->prgOnlineProgress->setValue(d->ui->prgOnlineProgress->maximum());
   // re-enable the sorting that was disabled during the update process
   d->ui->lvEquityList->setSortingEnabled(true);
 }
 
 // Make sure, that these definitions are only used within this file
 // this does not seem to be necessary, but when building RPMs the
 // build option 'final' is used and all CPP files are concatenated.
 // So it could well be, that in another CPP file these definitions
 // are also used.
 #undef WEBID_COL
 #undef NAME_COL
 #undef PRICE_COL
 #undef DATE_COL
 #undef KMMID_COL
 #undef SOURCE_COL
diff --git a/kmymoney/dialogs/kmymoneysplittable.cpp b/kmymoney/dialogs/kmymoneysplittable.cpp
index 2d18bc1e1..07e932487 100644
--- a/kmymoney/dialogs/kmymoneysplittable.cpp
+++ b/kmymoney/dialogs/kmymoneysplittable.cpp
@@ -1,1092 +1,1092 @@
 /***************************************************************************
                           kmymoneysplittable.cpp  -  description
                              -------------------
     begin                : Thu Jan 10 2002
     copyright            : (C) 2000-2002 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kmymoneysplittable.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QCursor>
 #include <QApplication>
 #include <QTimer>
 #include <QHBoxLayout>
 #include <QKeyEvent>
 #include <QFrame>
 #include <QMouseEvent>
 #include <QEvent>
 #include <QPushButton>
 #include <QMenu>
 #include <QIcon>
 #include <QHeaderView>
 #include <QPointer>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KCompletionBox>
 #include <KSharedConfig>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyaccount.h"
 #include "mymoneyfile.h"
 #include "mymoneyprice.h"
 #include "kmymoneyedit.h"
 #include "kmymoneycategory.h"
 #include "kmymoneyaccountselector.h"
 #include "kmymoneylineedit.h"
 #include "mymoneysecurity.h"
 #include "kmymoneysettings.h"
 #include "kcurrencycalculator.h"
 #include "mymoneyutils.h"
 #include "mymoneytracer.h"
 #include "mymoneyexception.h"
 #include "icons.h"
 #include "mymoneyenums.h"
 
 using namespace Icons;
 
 class KMyMoneySplitTablePrivate
 {
   Q_DISABLE_COPY(KMyMoneySplitTablePrivate)
 
 public:
   KMyMoneySplitTablePrivate() :
     m_currentRow(0),
     m_maxRows(0),
     m_precision(2),
     m_contextMenu(nullptr),
     m_contextMenuDelete(nullptr),
     m_contextMenuDuplicate(nullptr),
     m_editCategory(0),
     m_editMemo(0),
     m_editAmount(0)
   {
   }
 
   ~KMyMoneySplitTablePrivate()
   {
   }
 
   /// the currently selected row (will be printed as selected)
   int                 m_currentRow;
 
   /// the number of rows filled with data
   int                 m_maxRows;
 
   MyMoneyTransaction  m_transaction;
   MyMoneyAccount      m_account;
   MyMoneySplit        m_split;
   MyMoneySplit        m_hiddenSplit;
 
   /**
     * This member keeps the precision for the values
     */
   int                 m_precision;
 
   /**
     * This member keeps a pointer to the context menu
     */
   QMenu*         m_contextMenu;
 
   /// keeps the QAction of the delete entry in the context menu
   QAction*       m_contextMenuDelete;
 
   /// keeps the QAction of the duplicate entry in the context menu
   QAction*       m_contextMenuDuplicate;
 
   /**
     * This member contains a pointer to the input widget for the category.
     * The widget will be created and destroyed dynamically in createInputWidgets()
     * and destroyInputWidgets().
     */
   QPointer<KMyMoneyCategory> m_editCategory;
 
   /**
     * This member contains a pointer to the input widget for the memo.
     * The widget will be created and destroyed dynamically in createInputWidgets()
     * and destroyInputWidgets().
     */
   QPointer<KMyMoneyLineEdit> m_editMemo;
 
   /**
     * This member contains a pointer to the input widget for the amount.
     * The widget will be created and destroyed dynamically in createInputWidgets()
     * and destroyInputWidgets().
     */
   QPointer<KMyMoneyEdit>     m_editAmount;
 
   /**
     * This member keeps the tab order for the above widgets
     */
   QWidgetList         m_tabOrderWidgets;
 
   QPointer<QFrame>           m_registerButtonFrame;
   QPointer<QPushButton>      m_registerEnterButton;
   QPointer<QPushButton>      m_registerCancelButton;
 
   QMap<QString, MyMoneyMoney>  m_priceInfo;
 };
 
 KMyMoneySplitTable::KMyMoneySplitTable(QWidget *parent) :
     QTableWidget(parent),
     d_ptr(new KMyMoneySplitTablePrivate)
 {
   Q_D(KMyMoneySplitTable);
   // used for custom coloring with the help of the application's stylesheet
   setObjectName(QLatin1String("splittable"));
 
   // setup the transactions table
   setRowCount(1);
   setColumnCount(3);
   QStringList labels;
   labels << i18n("Category") << i18n("Memo") << i18n("Amount");
   setHorizontalHeaderLabels(labels);
   setSelectionMode(QAbstractItemView::SingleSelection);
   setSelectionBehavior(QAbstractItemView::SelectRows);
   int left, top, right, bottom;
   getContentsMargins(&left, &top, &right, &bottom);
   setContentsMargins(0, top, right, bottom);
 
   setFont(KMyMoneySettings::listCellFontEx());
 
   setAlternatingRowColors(true);
 
   verticalHeader()->hide();
   horizontalHeader()->setSectionsMovable(false);
   horizontalHeader()->setFont(KMyMoneySettings::listHeaderFontEx());
 
   KConfigGroup grp = KSharedConfig::openConfig()->group("SplitTable");
   QByteArray columns;
   columns = grp.readEntry("HeaderState", columns);
   horizontalHeader()->restoreState(columns);
   horizontalHeader()->setStretchLastSection(true);
 
   setShowGrid(KMyMoneySettings::showGrid());
 
   setEditTriggers(QAbstractItemView::NoEditTriggers);
 
   // setup the context menu
   d->m_contextMenu = new QMenu(this);
   d->m_contextMenu->setTitle(i18n("Split Options"));
   d->m_contextMenu->setIcon(Icons::get(Icon::ViewFinancialTransfer));
   d->m_contextMenu->addAction(Icons::get(Icon::DocumentEdit), i18n("Edit..."), this, SLOT(slotStartEdit()));
   d->m_contextMenuDuplicate = d->m_contextMenu->addAction(Icons::get(Icon::EditCopy), i18nc("To duplicate a split", "Duplicate"), this, SLOT(slotDuplicateSplit()));
   d->m_contextMenuDelete = d->m_contextMenu->addAction(Icons::get(Icon::EditDelete),
                         i18n("Delete..."),
                         this, SLOT(slotDeleteSplit()));
 
   connect(this, &QAbstractItemView::clicked,
           this, static_cast<void (KMyMoneySplitTable::*)(const QModelIndex&)>(&KMyMoneySplitTable::slotSetFocus));
 
   connect(this, &KMyMoneySplitTable::transactionChanged,
           this, &KMyMoneySplitTable::slotUpdateData);
 
   installEventFilter(this);
 }
 
 KMyMoneySplitTable::~KMyMoneySplitTable()
 {
   Q_D(KMyMoneySplitTable);
   auto grp = KSharedConfig::openConfig()->group("SplitTable");
   QByteArray columns = horizontalHeader()->saveState();
   grp.writeEntry("HeaderState", columns);
   grp.sync();
   delete d;
 }
 
 int KMyMoneySplitTable::currentRow() const
 {
   Q_D(const KMyMoneySplitTable);
   return d->m_currentRow;
 }
 
 void KMyMoneySplitTable::setup(const QMap<QString, MyMoneyMoney>& priceInfo, int precision)
 {
   Q_D(KMyMoneySplitTable);
   d->m_priceInfo = priceInfo;
   d->m_precision = precision;
 }
 
 bool KMyMoneySplitTable::eventFilter(QObject *o, QEvent *e)
 {
   Q_D(KMyMoneySplitTable);
   // MYMONEYTRACER(tracer);
   QKeyEvent *k = static_cast<QKeyEvent *>(e);
   bool rc = false;
   int row = currentRow();
   int lines = viewport()->height() / rowHeight(0);
 
   if (e->type() == QEvent::KeyPress && !isEditMode()) {
     rc = true;
     switch (k->key()) {
       case Qt::Key_Up:
         if (row)
           slotSetFocus(model()->index(row - 1, 0));
         break;
 
       case Qt::Key_Down:
         if (row < d->m_transaction.splits().count() - 1)
           slotSetFocus(model()->index(row + 1, 0));
         break;
 
       case Qt::Key_Home:
         slotSetFocus(model()->index(0, 0));
         break;
 
       case Qt::Key_End:
         slotSetFocus(model()->index(d->m_transaction.splits().count() - 1, 0));
         break;
 
       case Qt::Key_PageUp:
         if (lines) {
           while (lines-- > 0 && row)
             --row;
           slotSetFocus(model()->index(row, 0));
         }
         break;
 
       case Qt::Key_PageDown:
         if (row < d->m_transaction.splits().count() - 1) {
           while (lines-- > 0 && row < d->m_transaction.splits().count() - 1)
             ++row;
           slotSetFocus(model()->index(row, 0));
         }
         break;
 
       case Qt::Key_Delete:
         slotDeleteSplit();
         break;
 
       case Qt::Key_Return:
       case Qt::Key_Enter:
         if (row < d->m_transaction.splits().count() - 1
             && KMyMoneySettings::enterMovesBetweenFields()) {
           slotStartEdit();
         } else
           emit returnPressed();
         break;
 
       case Qt::Key_Escape:
         emit escapePressed();
         break;
 
       case Qt::Key_F2:
         slotStartEdit();
         break;
 
       default:
         rc = true;
 
         // duplicate split
         if (Qt::Key_C == k->key() && Qt::ControlModifier == k->modifiers()) {
           slotDuplicateSplit();
 
           // new split
         } else if (Qt::Key_Insert == k->key() && Qt::ControlModifier == k->modifiers()) {
           slotSetFocus(model()->index(d->m_transaction.splits().count() - 1, 0));
           slotStartEdit();
 
         } else if (k->text()[ 0 ].isPrint()) {
           KMyMoneyCategory* cat = createEditWidgets(false);
           if (cat) {
             KMyMoneyLineEdit *le = qobject_cast<KMyMoneyLineEdit*>(cat->lineEdit());
             if (le) {
               // make sure, the widget receives the key again
               // and does not select the text this time
               le->setText(k->text());
               le->end(false);
               le->deselect();
               le->skipSelectAll(true);
               le->setFocus();
             }
           }
         }
         break;
     }
 
   } else if (e->type() == QEvent::KeyPress && isEditMode()) {
     bool terminate = true;
     rc = true;
     switch (k->key()) {
         // suppress the F2 functionality to start editing in inline edit mode
       case Qt::Key_F2:
         // suppress the cursor movement in inline edit mode
       case Qt::Key_Up:
       case Qt::Key_Down:
       case Qt::Key_PageUp:
       case Qt::Key_PageDown:
         break;
 
       case Qt::Key_Return:
       case Qt::Key_Enter:
         // we cannot call the slot directly, as it destroys the caller of
         // this method :-(  So we let the event handler take care of calling
         // the respective slot using a timeout. For a KLineEdit derived object
         // it could be, that at this point the user selected a value from
         // a completion list. In this case, we close the completion list and
         // do not end editing of the transaction.
         if (o->inherits("KLineEdit")) {
           if (auto le = dynamic_cast<KLineEdit*>(o)) {
             KCompletionBox* box = le->completionBox(false);
             if (box && box->isVisible()) {
               terminate = false;
               le->completionBox(false)->hide();
             }
           }
         }
 
         // in case we have the 'enter moves focus between fields', we need to simulate
         // a TAB key when the object 'o' points to the category or memo field.
         if (KMyMoneySettings::enterMovesBetweenFields()) {
           if (o == d->m_editCategory->lineEdit() || o == d->m_editMemo) {
             terminate = false;
             QKeyEvent evt(e->type(),
                           Qt::Key_Tab, k->modifiers(), QString(),
                           k->isAutoRepeat(), k->count());
 
             QApplication::sendEvent(o, &evt);
           }
         }
 
         if (terminate) {
           QTimer::singleShot(0, this, SLOT(slotEndEditKeyboard()));
         }
         break;
 
       case Qt::Key_Escape:
         // we cannot call the slot directly, as it destroys the caller of
         // this method :-(  So we let the event handler take care of calling
         // the respective slot using a timeout.
         QTimer::singleShot(0, this, SLOT(slotCancelEdit()));
         break;
 
       default:
         rc = false;
         break;
     }
   } else if (e->type() == QEvent::KeyRelease && !isEditMode()) {
     // for some reason, we only see a KeyRelease event of the Menu key
     // here. In other locations (e.g. Register::eventFilter()) we see
     // a KeyPress event. Strange. (ipwizard - 2008-05-10)
     switch (k->key()) {
       case Qt::Key_Menu:
         // if the very last entry is selected, the delete
         // operation is not available otherwise it is
         d->m_contextMenuDelete->setEnabled(
           row < d->m_transaction.splits().count() - 1);
         d->m_contextMenuDuplicate->setEnabled(
           row < d->m_transaction.splits().count() - 1);
 
         d->m_contextMenu->exec(QCursor::pos());
         rc = true;
         break;
       default:
         break;
     }
   }
 
   // if the event has not been processed here, forward it to
   // the base class implementation if it's not a key event
   if (rc == false) {
     if (e->type() != QEvent::KeyPress
         && e->type() != QEvent::KeyRelease) {
       rc = QTableWidget::eventFilter(o, e);
     }
   }
 
   return rc;
 }
 
 void KMyMoneySplitTable::slotSetFocus(const QModelIndex& index)
 {
   slotSetFocus(index, Qt::LeftButton);
 }
 
 void KMyMoneySplitTable::slotSetFocus(const QModelIndex& index, int button)
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
   auto row = index.row();
 
   // adjust row to used area
   if (row > d->m_transaction.splits().count() - 1)
     row = d->m_transaction.splits().count() - 1;
   if (row < 0)
     row = 0;
 
   // make sure the row will be on the screen
   scrollTo(model()->index(row, 0));
 
   if (isEditMode()) {                   // in edit mode?
     if (isEditSplitValid() && KMyMoneySettings::focusChangeIsEnter())
       endEdit(false/*keyboard driven*/, false/*set focus to next row*/);
     else
       slotCancelEdit();
   }
 
   if (button == Qt::LeftButton) {         // left mouse button
     if (row != currentRow()) {
       // setup new current row and update visible selection
       selectRow(row);
       slotUpdateData(d->m_transaction);
     }
   } else if (button == Qt::RightButton) {
     // context menu is only available when cursor is on
     // an existing transaction or the first line after this area
     if (row == index.row()) {
       // setup new current row and update visible selection
       selectRow(row);
       slotUpdateData(d->m_transaction);
 
       // if the very last entry is selected, the delete
       // operation is not available otherwise it is
       d->m_contextMenuDelete->setEnabled(
         row < d->m_transaction.splits().count() - 1);
       d->m_contextMenuDuplicate->setEnabled(
         row < d->m_transaction.splits().count() - 1);
 
       d->m_contextMenu->exec(QCursor::pos());
     }
   }
 }
 
 void KMyMoneySplitTable::mousePressEvent(QMouseEvent* e)
 {
   slotSetFocus(indexAt(e->pos()), e->button());
 }
 
 /* turn off QTable behaviour */
 void KMyMoneySplitTable::mouseReleaseEvent(QMouseEvent* /* e */)
 {
 }
 
 void KMyMoneySplitTable::mouseDoubleClickEvent(QMouseEvent *e)
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
 
   int col = columnAt(e->pos().x());
   slotSetFocus(model()->index(rowAt(e->pos().y()), col), e->button());
   createEditWidgets(false);
 
   QLineEdit* editWidget = 0;    //krazy:exclude=qmethods
   switch (col) {
     case 0:
       editWidget = d->m_editCategory->lineEdit();
       break;
 
     case 1:
       editWidget = d->m_editMemo;
       break;
 
     case 2:
       editWidget = d->m_editAmount->lineedit();
       break;
 
     default:
       break;
   }
   if (editWidget) {
     editWidget->setFocus();
     editWidget->selectAll();
   }
 }
 
 void KMyMoneySplitTable::selectRow(int row)
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
 
   if (row > d->m_maxRows)
     row = d->m_maxRows;
   d->m_currentRow = row;
   QTableWidget::selectRow(row);
   QList<MyMoneySplit> list = getSplits(d->m_transaction);
   if (row < list.count())
     d->m_split = list[row];
   else
     d->m_split = MyMoneySplit();
 }
 
 void KMyMoneySplitTable::setRowCount(int irows)
 {
   QTableWidget::setRowCount(irows);
 
   // determine row height according to the edit widgets
   // we use the category widget as the base
   QFontMetrics fm(KMyMoneySettings::listCellFontEx());
   int height = fm.lineSpacing() + 6;
 #if 0
   // recalculate row height hint
   KMyMoneyCategory cat;
   height = qMax(cat.sizeHint().height(), height);
 #endif
 
   verticalHeader()->setUpdatesEnabled(false);
 
   for (auto i = 0; i < irows; ++i)
     verticalHeader()->resizeSection(i, height);
 
   verticalHeader()->setUpdatesEnabled(true);
 }
 
 void KMyMoneySplitTable::setTransaction(const MyMoneyTransaction& t, const MyMoneySplit& s, const MyMoneyAccount& acc)
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
   d->m_transaction = t;
   d->m_account = acc;
   d->m_hiddenSplit = s;
   selectRow(0);
   slotUpdateData(d->m_transaction);
 }
 
 MyMoneyTransaction KMyMoneySplitTable::transaction() const
 {
   Q_D(const KMyMoneySplitTable);
   return d->m_transaction;
 }
 
 QList<MyMoneySplit> KMyMoneySplitTable::getSplits(const MyMoneyTransaction& t) const
 {
   Q_D(const KMyMoneySplitTable);
   // get list of splits
   QList<MyMoneySplit> list = t.splits();
 
   // and ignore the one that should be hidden
   QList<MyMoneySplit>::Iterator it;
   for (it = list.begin(); it != list.end(); ++it) {
     if ((*it).id() == d->m_hiddenSplit.id()) {
       list.erase(it);
       break;
     }
   }
   return list;
 }
 
 void KMyMoneySplitTable::slotUpdateData(const MyMoneyTransaction& t)
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
   unsigned long numRows = 0;
   QTableWidgetItem* textItem;
 
   QList<MyMoneySplit> list = getSplits(t);
   updateTransactionTableSize();
 
   // fill the part that is used by transactions
   QList<MyMoneySplit>::Iterator it;
   for (it = list.begin(); it != list.end(); ++it) {
     QString colText;
     MyMoneyMoney value = (*it).value();
     if (!(*it).accountId().isEmpty()) {
       try {
         colText = MyMoneyFile::instance()->accountToCategory((*it).accountId());
       } catch (const MyMoneyException &) {
         qDebug("Unexpected exception in KMyMoneySplitTable::slotUpdateData()");
       }
     }
     QString amountTxt = value.formatMoney(d->m_account.fraction());
     if (value == MyMoneyMoney::autoCalc) {
       amountTxt = i18n("will be calculated");
     }
 
     if (colText.isEmpty() && (*it).memo().isEmpty() && value.isZero())
       amountTxt.clear();
 
     unsigned width = fontMetrics().width(amountTxt);
     KMyMoneyEdit* valfield = new KMyMoneyEdit();
     valfield->setMinimumWidth(width);
     width = valfield->minimumSizeHint().width();
     delete valfield;
 
     textItem = item(numRows, 0);
     if (textItem)
       textItem->setText(colText);
     else
       setItem(numRows, 0, new QTableWidgetItem(colText));
 
     textItem = item(numRows, 1);
     if (textItem)
       textItem->setText((*it).memo());
     else
       setItem(numRows, 1, new QTableWidgetItem((*it).memo()));
 
     textItem = item(numRows, 2);
     if (textItem)
       textItem->setText(amountTxt);
     else
       setItem(numRows, 2, new QTableWidgetItem(amountTxt));
 
     item(numRows, 2)->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
 
     ++numRows;
   }
 
   // now clean out the remainder of the table
   while (numRows < static_cast<unsigned long>(rowCount())) {
     for (auto i = 0 ; i < 3; ++i) {
       textItem = item(numRows, i);
       if (textItem)
         textItem->setText("");
       else
         setItem(numRows, i, new QTableWidgetItem(""));
     }
     item(numRows, 2)->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
     ++numRows;
   }
 }
 
 void KMyMoneySplitTable::updateTransactionTableSize()
 {
   Q_D(KMyMoneySplitTable);
   // get current size of transactions table
   int tableHeight = height();
   int splitCount = d->m_transaction.splits().count() - 1;
 
   if (splitCount < 0)
     splitCount = 0;
 
   // see if we need some extra lines to fill the current size with the grid
   int numExtraLines = (tableHeight / rowHeight(0)) - splitCount;
   if (numExtraLines < 2)
     numExtraLines = 2;
 
   setRowCount(splitCount + numExtraLines);
   d->m_maxRows = splitCount;
 }
 
 void KMyMoneySplitTable::resizeEvent(QResizeEvent* ev)
 {
   QTableWidget::resizeEvent(ev);
   if (!isEditMode()) {
     // update the size of the transaction table only if a split is not being edited
     // otherwise the height of the editors would be altered in an undesired way
     updateTransactionTableSize();
   }
 }
 
 void KMyMoneySplitTable::slotDuplicateSplit()
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
   QList<MyMoneySplit> list = getSplits(d->m_transaction);
   if (d->m_currentRow < list.count()) {
     MyMoneySplit split = list[d->m_currentRow];
     split.clearId();
     try {
       d->m_transaction.addSplit(split);
       emit transactionChanged(d->m_transaction);
     } catch (const MyMoneyException &e) {
-      qDebug("Cannot duplicate split: %s", qPrintable(e.what()));
+      qDebug("Cannot duplicate split: %s", e.what());
     }
   }
 }
 
 void KMyMoneySplitTable::slotDeleteSplit()
 {
   Q_D(KMyMoneySplitTable);
   MYMONEYTRACER(tracer);
   QList<MyMoneySplit> list = getSplits(d->m_transaction);
   if (d->m_currentRow < list.count()) {
     if (KMessageBox::warningContinueCancel(this,
                                            i18n("You are about to delete the selected split. "
                                                 "Do you really want to continue?"),
                                            i18n("KMyMoney")
                                           ) == KMessageBox::Continue) {
       try {
         d->m_transaction.removeSplit(list[d->m_currentRow]);
         // if we removed the last split, select the previous
         if (d->m_currentRow && d->m_currentRow == list.count() - 1)
           selectRow(d->m_currentRow - 1);
         else
           selectRow(d->m_currentRow);
         emit transactionChanged(d->m_transaction);
       } catch (const MyMoneyException &e) {
-        qDebug("Cannot remove split: %s", qPrintable(e.what()));
+        qDebug("Cannot remove split: %s", e.what());
       }
     }
   }
 }
 
 KMyMoneyCategory* KMyMoneySplitTable::slotStartEdit()
 {
   MYMONEYTRACER(tracer);
   return createEditWidgets(true);
 }
 
 void KMyMoneySplitTable::slotEndEdit()
 {
   endEdit(false);
 }
 
 void KMyMoneySplitTable::slotEndEditKeyboard()
 {
   endEdit(true);
 }
 
 void KMyMoneySplitTable::endEdit(bool keyboardDriven, bool setFocusToNextRow)
 {
   Q_D(KMyMoneySplitTable);
   auto file = MyMoneyFile::instance();
 
   MYMONEYTRACER(tracer);
   MyMoneySplit s1 = d->m_split;
 
   if (!isEditSplitValid()) {
     KMessageBox::information(this, i18n("You need to assign a category to this split before it can be entered."), i18n("Enter split"), "EnterSplitWithEmptyCategory");
     d->m_editCategory->setFocus();
     return;
   }
 
   bool needUpdate = false;
   if (d->m_editCategory->selectedItem() != d->m_split.accountId()) {
     s1.setAccountId(d->m_editCategory->selectedItem());
     needUpdate = true;
   }
   if (d->m_editMemo->text() != d->m_split.memo()) {
     s1.setMemo(d->m_editMemo->text());
     needUpdate = true;
   }
   if (d->m_editAmount->value() != d->m_split.value()) {
     s1.setValue(d->m_editAmount->value());
     needUpdate = true;
   }
 
   if (needUpdate) {
     if (!s1.value().isZero()) {
       MyMoneyAccount cat = file->account(s1.accountId());
       if (cat.currencyId() != d->m_transaction.commodity()) {
 
         MyMoneySecurity fromCurrency, toCurrency;
         MyMoneyMoney fromValue, toValue;
         fromCurrency = file->security(d->m_transaction.commodity());
         toCurrency = file->security(cat.currencyId());
 
         // determine the fraction required for this category
         int fract = toCurrency.smallestAccountFraction();
         if (cat.accountType() == eMyMoney::Account::Type::Cash)
           fract = toCurrency.smallestCashFraction();
 
         // display only positive values to the user
         fromValue = s1.value().abs();
 
         // if we had a price info in the beginning, we use it here
         if (d->m_priceInfo.find(cat.currencyId()) != d->m_priceInfo.end()) {
           toValue = (fromValue * d->m_priceInfo[cat.currencyId()]).convert(fract);
         }
 
         // if the shares are still 0, we need to change that
         if (toValue.isZero()) {
           const MyMoneyPrice &price = MyMoneyFile::instance()->price(fromCurrency.id(), toCurrency.id());
           // if the price is valid calculate the shares. If it is invalid
           // assume a conversion rate of 1.0
           if (price.isValid()) {
             toValue = (price.rate(toCurrency.id()) * fromValue).convert(fract);
           } else {
             toValue = fromValue;
           }
         }
 
         // now present all that to the user
         QPointer<KCurrencyCalculator> calc =
           new KCurrencyCalculator(fromCurrency,
                                   toCurrency,
                                   fromValue,
                                   toValue,
                                   d->m_transaction.postDate(),
                                   fract,
                                   this);
 
         if (calc->exec() == QDialog::Rejected) {
           delete calc;
           return;
         } else {
           s1.setShares((s1.value() * calc->price()).convert(fract));
           delete calc;
         }
 
       } else {
         s1.setShares(s1.value());
       }
     } else
       s1.setShares(s1.value());
 
     d->m_split = s1;
     try {
       if (d->m_split.id().isEmpty()) {
         d->m_transaction.addSplit(d->m_split);
       } else {
         d->m_transaction.modifySplit(d->m_split);
       }
       emit transactionChanged(d->m_transaction);
     } catch (const MyMoneyException &e) {
-      qDebug("Cannot add/modify split: %s", qPrintable(e.what()));
+      qDebug("Cannot add/modify split: %s", e.what());
     }
   }
   this->setFocus();
   destroyEditWidgets();
   if (setFocusToNextRow) {
     slotSetFocus(model()->index(currentRow() + 1, 0));
   }
 
   // if we still have more splits, we start editing right away
   // in case we have selected 'enter moves between fields'
   if (keyboardDriven
       && currentRow() < d->m_transaction.splits().count() - 1
       && KMyMoneySettings::enterMovesBetweenFields()) {
     slotStartEdit();
   }
 
 }
 
 void KMyMoneySplitTable::slotCancelEdit()
 {
   MYMONEYTRACER(tracer);
   if (isEditMode()) {
     destroyEditWidgets();
     this->setFocus();
   }
 }
 
 bool KMyMoneySplitTable::isEditMode() const
 {
   Q_D(const KMyMoneySplitTable);
   // while the edit widgets exist we're in edit mode
   return d->m_editAmount || d->m_editMemo || d->m_editCategory;
 }
 
 bool KMyMoneySplitTable::isEditSplitValid() const
 {
   Q_D(const KMyMoneySplitTable);
   return isEditMode() && !d->m_editCategory->selectedItem().isEmpty();
 }
 
 void KMyMoneySplitTable::destroyEditWidgets()
 {
   MYMONEYTRACER(tracer);
 
   Q_D(KMyMoneySplitTable);
   emit editFinished();
 
   disconnect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, this, &KMyMoneySplitTable::slotLoadEditWidgets);
 
   destroyEditWidget(d->m_currentRow, 0);
   destroyEditWidget(d->m_currentRow, 1);
   destroyEditWidget(d->m_currentRow, 2);
   destroyEditWidget(d->m_currentRow + 1, 0);
 }
 
 void KMyMoneySplitTable::destroyEditWidget(int r, int c)
 {
   if (QWidget* cw = cellWidget(r, c))
     cw->hide();
   removeCellWidget(r, c);
 }
 
 KMyMoneyCategory* KMyMoneySplitTable::createEditWidgets(bool setFocus)
 {
   MYMONEYTRACER(tracer);
 
   emit editStarted();
 
   Q_D(KMyMoneySplitTable);
   auto cellFont = KMyMoneySettings::listCellFontEx();
   d->m_tabOrderWidgets.clear();
 
   // create the widgets
   d->m_editAmount = new KMyMoneyEdit(0);
   d->m_editAmount->setFont(cellFont);
   d->m_editAmount->setResetButtonVisible(false);
   d->m_editAmount->setPrecision(d->m_precision);
 
   d->m_editCategory = new KMyMoneyCategory();
   d->m_editCategory->setPlaceholderText(i18n("Category"));
   d->m_editCategory->setFont(cellFont);
   connect(d->m_editCategory, SIGNAL(createItem(QString,QString&)), this, SIGNAL(createCategory(QString,QString&)));
   connect(d->m_editCategory, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool)));
 
   d->m_editMemo = new KMyMoneyLineEdit(0, false, Qt::AlignLeft | Qt::AlignVCenter);
   d->m_editMemo->setPlaceholderText(i18n("Memo"));
   d->m_editMemo->setFont(cellFont);
 
   // create buttons for the mouse users
   d->m_registerButtonFrame = new QFrame(this);
   d->m_registerButtonFrame->setContentsMargins(0, 0, 0, 0);
   d->m_registerButtonFrame->setAutoFillBackground(true);
 
   QHBoxLayout* l = new QHBoxLayout(d->m_registerButtonFrame);
   l->setContentsMargins(0, 0, 0, 0);
   l->setSpacing(0);
   d->m_registerEnterButton = new QPushButton(Icons::get(Icon::DialogOK)
                                           , QString(), d->m_registerButtonFrame);
   d->m_registerCancelButton = new QPushButton(Icons::get(Icon::DialogCancel)
                                            , QString(), d->m_registerButtonFrame);
 
   l->addWidget(d->m_registerEnterButton);
   l->addWidget(d->m_registerCancelButton);
   l->addStretch(2);
 
   connect(d->m_registerEnterButton.data(), &QAbstractButton::clicked, this, &KMyMoneySplitTable::slotEndEdit);
   connect(d->m_registerCancelButton.data(), &QAbstractButton::clicked, this, &KMyMoneySplitTable::slotCancelEdit);
 
   // setup tab order
   addToTabOrder(d->m_editCategory);
   addToTabOrder(d->m_editMemo);
   addToTabOrder(d->m_editAmount);
   addToTabOrder(d->m_registerEnterButton);
   addToTabOrder(d->m_registerCancelButton);
 
   if (!d->m_split.accountId().isEmpty()) {
     d->m_editCategory->setSelectedItem(d->m_split.accountId());
   } else {
     // check if the transaction is balanced or not. If not,
     // assign the remainder to the amount.
     MyMoneyMoney diff;
     QList<MyMoneySplit> list = d->m_transaction.splits();
     QList<MyMoneySplit>::ConstIterator it_s;
     for (it_s = list.constBegin(); it_s != list.constEnd(); ++it_s) {
       if (!(*it_s).accountId().isEmpty())
         diff += (*it_s).value();
     }
     d->m_split.setValue(-diff);
   }
 
   d->m_editMemo->loadText(d->m_split.memo());
   // don't allow automatically calculated values to be modified
   if (d->m_split.value() == MyMoneyMoney::autoCalc) {
     d->m_editAmount->setEnabled(false);
     d->m_editAmount->loadText("will be calculated");
   } else
     d->m_editAmount->setValue(d->m_split.value());
 
   setCellWidget(d->m_currentRow, 0, d->m_editCategory);
   setCellWidget(d->m_currentRow, 1, d->m_editMemo);
   setCellWidget(d->m_currentRow, 2, d->m_editAmount);
   setCellWidget(d->m_currentRow + 1, 0, d->m_registerButtonFrame);
 
   // load e.g. the category widget with the account list
   slotLoadEditWidgets();
   connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, this, &KMyMoneySplitTable::slotLoadEditWidgets);
 
   foreach (QWidget* w, d->m_tabOrderWidgets) {
     if (w) {
       w->installEventFilter(this);
     }
   }
 
   if (setFocus) {
     d->m_editCategory->lineEdit()->setFocus();
     d->m_editCategory->lineEdit()->selectAll();
   }
 
   // resize the rows so the added edit widgets would fit appropriately
   resizeRowsToContents();
 
   return d->m_editCategory;
 }
 
 void KMyMoneySplitTable::slotLoadEditWidgets()
 {
   Q_D(KMyMoneySplitTable);
   // reload category widget
   auto categoryId = d->m_editCategory->selectedItem();
 
   AccountSet aSet;
   aSet.addAccountGroup(eMyMoney::Account::Type::Asset);
   aSet.addAccountGroup(eMyMoney::Account::Type::Liability);
   aSet.addAccountGroup(eMyMoney::Account::Type::Income);
   aSet.addAccountGroup(eMyMoney::Account::Type::Expense);
   if (KMyMoneySettings::expertMode())
     aSet.addAccountGroup(eMyMoney::Account::Type::Equity);
 
   // remove the accounts with invalid types at this point
   aSet.removeAccountType(eMyMoney::Account::Type::CertificateDep);
   aSet.removeAccountType(eMyMoney::Account::Type::Investment);
   aSet.removeAccountType(eMyMoney::Account::Type::Stock);
   aSet.removeAccountType(eMyMoney::Account::Type::MoneyMarket);
 
   aSet.load(d->m_editCategory->selector());
 
   // if an account is specified then remove it from the widget so that the user
   // cannot create a transfer with from and to account being the same account
   if (!d->m_account.id().isEmpty())
     d->m_editCategory->selector()->removeItem(d->m_account.id());
 
   if (!categoryId.isEmpty())
     d->m_editCategory->setSelectedItem(categoryId);
 }
 
 void KMyMoneySplitTable::addToTabOrder(QWidget* w)
 {
   Q_D(KMyMoneySplitTable);
   if (w) {
     while (w->focusProxy())
       w = w->focusProxy();
     d->m_tabOrderWidgets.append(w);
   }
 }
 
 bool KMyMoneySplitTable::focusNextPrevChild(bool next)
 {
   MYMONEYTRACER(tracer);
   Q_D(KMyMoneySplitTable);
   auto rc = false;
   if (isEditMode()) {
     QWidget *w = 0;
 
     w = qApp->focusWidget();
     int currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
     while (w && currentWidgetIndex == -1) {
       // qDebug("'%s' not in list, use parent", w->className());
       w = w->parentWidget();
       currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
     }
 
     if (currentWidgetIndex != -1) {
       // if(w) qDebug("tab order is at '%s'", w->className());
       currentWidgetIndex += next ? 1 : -1;
       if (currentWidgetIndex < 0)
         currentWidgetIndex = d->m_tabOrderWidgets.size() - 1;
       else if (currentWidgetIndex >= d->m_tabOrderWidgets.size())
         currentWidgetIndex = 0;
 
       w = d->m_tabOrderWidgets[currentWidgetIndex];
 
       if (((w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus) && w->isVisible() && w->isEnabled()) {
         // qDebug("Selecting '%s' as focus", w->className());
         w->setFocus();
         rc = true;
       }
     }
   } else
     rc = QTableWidget::focusNextPrevChild(next);
   return rc;
 }
diff --git a/kmymoney/dialogs/knewaccountdlg.cpp b/kmymoney/dialogs/knewaccountdlg.cpp
index ac8ff1291..fc54603cd 100644
--- a/kmymoney/dialogs/knewaccountdlg.cpp
+++ b/kmymoney/dialogs/knewaccountdlg.cpp
@@ -1,962 +1,962 @@
 /***************************************************************************
                           knewaccountdlg.cpp
                              -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                                2004 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "knewaccountdlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPushButton>
 #include <QLabel>
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QTabWidget>
 #include <QRadioButton>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <KMessageBox>
 #include <KComboBox>
 #include <kguiutils.h>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_knewaccountdlg.h"
 
 #include "kmymoneyedit.h"
 #include "kmymoneydateinput.h"
 #include <mymoneyexception.h>
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "kmymoneysettings.h"
 #include "kmymoneycurrencyselector.h"
 #include "knewbankdlg.h"
 #include "models.h"
 #include "accountsmodel.h"
 #include "hierarchyfilterproxymodel.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 
 using namespace eMyMoney;
 
 class KNewAccountDlgPrivate
 {
   Q_DISABLE_COPY(KNewAccountDlgPrivate)
   Q_DECLARE_PUBLIC(KNewAccountDlg)
 
 public:
   explicit KNewAccountDlgPrivate(KNewAccountDlg *qq) :
     q_ptr(qq),
     ui(new Ui::KNewAccountDlg),
     m_filterProxyModel(nullptr),
     m_categoryEditor(false),
     m_isEditing(false)
   {
   }
 
   ~KNewAccountDlgPrivate()
   {
     delete ui;
   }
 
   void init()
   {
     Q_Q(KNewAccountDlg);
     ui->setupUi(q);
 
     auto file = MyMoneyFile::instance();
 
     // initialize the m_parentAccount member
     QVector<Account::Type> filterAccountGroup {m_account.accountGroup()};
     switch (m_account.accountGroup()) {
       case Account::Type::Asset:
         m_parentAccount = file->asset();
         break;
       case Account::Type::Liability:
         m_parentAccount = file->liability();
         break;
       case Account::Type::Income:
         m_parentAccount = file->income();
         break;
       case Account::Type::Expense:
         m_parentAccount = file->expense();
         break;
       case Account::Type::Equity:
         m_parentAccount = file->equity();
         break;
       default:
         qDebug("Seems we have an account that hasn't been mapped to the top five");
         if (m_categoryEditor) {
           m_parentAccount = file->income();
           filterAccountGroup[0] = Account::Type::Income;
         } else {
           m_parentAccount = file->asset();
           filterAccountGroup[0] = Account::Type::Asset;
         }
     }
 
     ui->m_amountGroup->setId(ui->m_grossAmount, 0);
     ui->m_amountGroup->setId(ui->m_netAmount, 1);
 
     // the proxy filter model
     m_filterProxyModel = new HierarchyFilterProxyModel(q);
     m_filterProxyModel->setHideClosedAccounts(true);
     m_filterProxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
     m_filterProxyModel->addAccountGroup(filterAccountGroup);
     m_filterProxyModel->setCurrentAccountId(m_account.id());
     auto const model = Models::instance()->accountsModel();
     m_filterProxyModel->setSourceModel(model);
     m_filterProxyModel->setSourceColumns(model->getColumns());
     m_filterProxyModel->setDynamicSortFilter(true);
 
     ui->m_parentAccounts->setModel(m_filterProxyModel);
     ui->m_parentAccounts->sortByColumn((int)eAccountsModel::Column::Account, Qt::AscendingOrder);
 
     ui->m_subAccountLabel->setText(i18n("Is a sub account"));
 
     ui->accountNameEdit->setText(m_account.name());
     ui->descriptionEdit->setText(m_account.description());
 
     ui->typeCombo->setEnabled(true);
 
     // load the price mode combo
     ui->m_priceMode->insertItem(i18nc("default price mode", "(default)"), 0);
     ui->m_priceMode->insertItem(i18n("Price per share"), 1);
     ui->m_priceMode->insertItem(i18n("Total for all shares"), 2);
 
     int priceMode = 0;
     if (m_account.accountType() == Account::Type::Investment) {
       ui->m_priceMode->setEnabled(true);
       if (!m_account.value("priceMode").isEmpty())
         priceMode = m_account.value("priceMode").toInt();
     }
     ui->m_priceMode->setCurrentItem(priceMode);
 
     bool haveMinBalance = false;
     bool haveMaxCredit = false;
     if (!m_account.openingDate().isValid()) {
       m_account.setOpeningDate(KMyMoneySettings::firstFiscalDate());
     }
     ui->m_openingDateEdit->setDate(m_account.openingDate());
 
     handleOpeningBalanceCheckbox(m_account.currencyId());
 
     if (m_categoryEditor) {
       // get rid of the tabs that are not used for categories
       int tab = ui->m_tab->indexOf(ui->m_institutionTab);
       if (tab != -1)
         ui->m_tab->removeTab(tab);
       tab = ui->m_tab->indexOf(ui->m_limitsTab);
       if (tab != -1)
         ui->m_tab->removeTab(tab);
 
       //m_qlistviewParentAccounts->setEnabled(true);
       ui->accountNoEdit->setEnabled(false);
 
       ui->m_institutionBox->hide();
       ui->m_qcheckboxNoVat->hide();
 
       ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Income), (int)Account::Type::Income);
       ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Expense), (int)Account::Type::Expense);
 
       // Hardcoded but acceptable - if above we set the default to income do the same here
       switch (m_account.accountType()) {
         case Account::Type::Expense:
           ui->typeCombo->setCurrentItem(MyMoneyAccount::accountTypeToString(Account::Type::Expense), false);
           break;
 
         case Account::Type::Income:
         default:
           ui->typeCombo->setCurrentItem(MyMoneyAccount::accountTypeToString(Account::Type::Income), false);
           break;
       }
       ui->m_currency->setEnabled(true);
       if (m_isEditing) {
         ui->typeCombo->setEnabled(false);
         ui->m_currency->setDisabled(MyMoneyFile::instance()->isReferenced(m_account));
       }
       ui->m_qcheckboxPreferred->hide();
 
       ui->m_qcheckboxTax->setChecked(m_account.value("Tax").toLower() == "yes");
       ui->m_costCenterRequiredCheckBox->setChecked(m_account.isCostCenterRequired());
 
       loadVatAccounts();
     } else {
       // get rid of the tabs that are not used for accounts
       int taxtab = ui->m_tab->indexOf(ui->m_taxTab);
       if (taxtab != -1) {
           ui->m_vatCategory->setText(i18n("VAT account"));
           ui->m_qcheckboxTax->setChecked(m_account.value("Tax") == "Yes");
           loadVatAccounts();
       } else {
           ui->m_tab->removeTab(taxtab);
       }
 
       ui->m_costCenterRequiredCheckBox->hide();
 
       switch (m_account.accountType()) {
         case Account::Type::Savings:
         case Account::Type::Cash:
           haveMinBalance = true;
           break;
 
         case Account::Type::Checkings:
           haveMinBalance = true;
           haveMaxCredit = true;
           break;
 
         case Account::Type::CreditCard:
           haveMaxCredit = true;
           break;
 
         default:
           // no limit available, so we might get rid of the tab
           int tab = ui->m_tab->indexOf(ui->m_limitsTab);
           if (tab != -1)
             ui->m_tab->removeTab(tab);
           // don't try to hide the widgets we just wiped
           // in the next step
           haveMaxCredit = haveMinBalance = true;
           break;
       }
 
       if (!haveMaxCredit) {
         ui->m_maxCreditLabel->setEnabled(false);
         ui->m_maxCreditLabel->hide();
         ui->m_maxCreditEarlyEdit->hide();
         ui->m_maxCreditAbsoluteEdit->hide();
       }
       if (!haveMinBalance) {
         ui->m_minBalanceLabel->setEnabled(false);
         ui->m_minBalanceLabel->hide();
         ui->m_minBalanceEarlyEdit->hide();
         ui->m_minBalanceAbsoluteEdit->hide();
       }
 
       QString typeString = MyMoneyAccount::accountTypeToString(m_account.accountType());
 
       if (m_isEditing) {
         if (m_account.isLiquidAsset()) {
           ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Checkings), (int)Account::Type::Checkings);
           ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Savings), (int)Account::Type::Savings);
           ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Cash), (int)Account::Type::Cash);
         } else {
           ui->typeCombo->addItem(typeString, (int)m_account.accountType());
           // Once created, accounts of other account types are not
           // allowed to be changed.
           ui->typeCombo->setEnabled(false);
         }
         // Once created, a currency cannot be changed if it is referenced.
         ui->m_currency->setDisabled(MyMoneyFile::instance()->isReferenced(m_account));
       } else {
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Checkings), (int)Account::Type::Checkings);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Savings), (int)Account::Type::Savings);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Cash), (int)Account::Type::Cash);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::CreditCard), (int)Account::Type::CreditCard);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Loan), (int)Account::Type::Loan);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Investment), (int)Account::Type::Investment);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Asset), (int)Account::Type::Asset);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Liability), (int)Account::Type::Liability);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Stock), (int)Account::Type::Stock);
         /*
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::CertificateDep), (int)Account::Type::CertificateDep);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::MoneyMarket), (int)Account::Type::MoneyMarket);
         ui->typeCombo->addItem(MyMoneyAccount::accountTypeToString(Account::Type::Currency), (int)Account::Type::Currency);
         */
         // Do not create account types that are not supported
         // by the current engine.
         if (m_account.accountType() == Account::Type::Unknown ||
             m_account.accountType() == Account::Type::CertificateDep ||
             m_account.accountType() == Account::Type::MoneyMarket ||
             m_account.accountType() == Account::Type::Currency)
           typeString = MyMoneyAccount::accountTypeToString(Account::Type::Checkings);
       }
 
       ui->typeCombo->setCurrentItem(typeString, false);
 
       if (m_account.isInvest())
         ui->m_institutionBox->hide();
 
       ui->accountNoEdit->setText(m_account.number());
       ui->m_qcheckboxPreferred->setChecked(m_account.value("PreferredAccount") == "Yes");
       ui->m_qcheckboxNoVat->setChecked(m_account.value("NoVat") == "Yes");
       loadKVP("iban", ui->ibanEdit);
       loadKVP("minBalanceAbsolute", ui->m_minBalanceAbsoluteEdit);
       loadKVP("minBalanceEarly", ui->m_minBalanceEarlyEdit);
       loadKVP("maxCreditAbsolute", ui->m_maxCreditAbsoluteEdit);
       loadKVP("maxCreditEarly", ui->m_maxCreditEarlyEdit);
       // reverse the sign for display purposes
       if (!ui->m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
         ui->m_maxCreditAbsoluteEdit->setValue(ui->m_maxCreditAbsoluteEdit->value()*MyMoneyMoney::MINUS_ONE);
       if (!ui->m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
         ui->m_maxCreditEarlyEdit->setValue(ui->m_maxCreditEarlyEdit->value()*MyMoneyMoney::MINUS_ONE);
       loadKVP("lastNumberUsed", ui->m_lastCheckNumberUsed);
 
       if (m_account.isInvest()) {
         ui->typeCombo->setEnabled(false);
         ui->m_qcheckboxPreferred->hide();
         ui->m_currencyText->hide();
         ui->m_currency->hide();
       } else {
         // use the old field and override a possible new value
         if (!MyMoneyMoney(m_account.value("minimumBalance")).isZero()) {
           ui->m_minBalanceAbsoluteEdit->setValue(MyMoneyMoney(m_account.value("minimumBalance")));
         }
       }
 
   //    ui->m_qcheckboxTax->hide(); TODO should only be visible for VAT category/account
     }
 
     ui->m_currency->setSecurity(file->currency(m_account.currencyId()));
 
     // Load the institutions
     // then the accounts
     QString institutionName;
 
     try {
       if (m_isEditing && !m_account.institutionId().isEmpty())
         institutionName = file->institution(m_account.institutionId()).name();
       else
         institutionName.clear();
     } catch (const MyMoneyException &e) {
-      qDebug("exception in init for account dialog: %s", qPrintable(e.what()));
+      qDebug("exception in init for account dialog: %s", e.what());
     }
 
     if (m_account.isInvest())
       ui->m_parentAccounts->setEnabled(false);
 
     if (!m_categoryEditor)
       q->slotLoadInstitutions(institutionName);
 
     ui->accountNameEdit->setFocus();
 
     q->connect(ui->buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
     q->connect(ui->buttonBox, &QDialogButtonBox::accepted, q, &KNewAccountDlg::okClicked);
     q->connect(ui->m_parentAccounts->selectionModel(), &QItemSelectionModel::selectionChanged,
             q, &KNewAccountDlg::slotSelectionChanged);
     q->connect(ui->m_qbuttonNew, &QAbstractButton::clicked, q, &KNewAccountDlg::slotNewClicked);
     q->connect(ui->typeCombo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), q, &KNewAccountDlg::slotAccountTypeChanged);
 
     q->connect(ui->accountNameEdit, &QLineEdit::textChanged, q, &KNewAccountDlg::slotCheckFinished);
 
     q->connect(ui->m_vatCategory,   &QAbstractButton::toggled,       q, &KNewAccountDlg::slotVatChanged);
     q->connect(ui->m_vatAssignment, &QAbstractButton::toggled,       q, &KNewAccountDlg::slotVatAssignmentChanged);
     q->connect(ui->m_vatCategory,   &QAbstractButton::toggled,       q, &KNewAccountDlg::slotCheckFinished);
     q->connect(ui->m_vatAssignment, &QAbstractButton::toggled,       q, &KNewAccountDlg::slotCheckFinished);
     q->connect(ui->m_vatRate,       &KMyMoneyEdit::textChanged,      q, &KNewAccountDlg::slotCheckFinished);
     q->connect(ui->m_vatAccount,    &KMyMoneySelector::stateChanged, q, &KNewAccountDlg::slotCheckFinished);
     q->connect(ui->m_currency, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), q, &KNewAccountDlg::slotCheckCurrency);
 
     q->connect(ui->m_minBalanceEarlyEdit,     &KMyMoneyEdit::valueChanged, q, &KNewAccountDlg::slotAdjustMinBalanceAbsoluteEdit);
     q->connect(ui->m_minBalanceAbsoluteEdit,  &KMyMoneyEdit::valueChanged, q, &KNewAccountDlg::slotAdjustMinBalanceEarlyEdit);
     q->connect(ui->m_maxCreditEarlyEdit,      &KMyMoneyEdit::valueChanged, q, &KNewAccountDlg::slotAdjustMaxCreditAbsoluteEdit);
     q->connect(ui->m_maxCreditAbsoluteEdit,   &KMyMoneyEdit::valueChanged, q, &KNewAccountDlg::slotAdjustMaxCreditEarlyEdit);
 
     q->connect(ui->m_qcomboboxInstitutions, static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::activated), q, &KNewAccountDlg::slotLoadInstitutions);
 
     auto parentIndex = m_filterProxyModel->getSelectedParentAccountIndex();
     ui->m_parentAccounts->expand(parentIndex);
     ui->m_parentAccounts->selectionModel()->select(parentIndex, QItemSelectionModel::SelectCurrent);
     ui->m_parentAccounts->scrollTo(parentIndex, QAbstractItemView::PositionAtTop);
 
     ui->m_vatCategory->setChecked(false);
     ui->m_vatAssignment->setChecked(false);
 
     // make sure our account does not have an id and no parent assigned
     // and certainly no children in case we create a new account
     if (!m_isEditing) {
       m_account.clearId();
       m_account.setParentAccountId(QString());
       m_account.removeAccountIds();
     } else {
       if (!m_account.value("VatRate").isEmpty()) {
         ui->m_vatCategory->setChecked(true);
         ui->m_vatRate->setValue(MyMoneyMoney(m_account.value("VatRate"))*MyMoneyMoney(100, 1));
       } else {
         if (!m_account.value("VatAccount").isEmpty()) {
           QString accId = m_account.value("VatAccount").toLatin1();
           try {
             // make sure account exists
             MyMoneyFile::instance()->account(accId);
             ui->m_vatAssignment->setChecked(true);
             ui->m_vatAccount->setSelected(accId);
             ui->m_grossAmount->setChecked(true);
             if (m_account.value("VatAmount") == "Net")
               ui->m_netAmount->setChecked(true);
           } catch (const MyMoneyException &) {
           }
         }
       }
     }
     q->slotVatChanged(ui->m_vatCategory->isChecked());
     q->slotVatAssignmentChanged(ui->m_vatAssignment->isChecked());
     q->slotCheckFinished();
 
     auto requiredFields = new KMandatoryFieldGroup(q);
     requiredFields->setOkButton(ui->buttonBox->button(QDialogButtonBox::Ok)); // button to be enabled when all fields present
     requiredFields->add(ui->accountNameEdit);
   }
 
   void loadKVP(const QString& key, KMyMoneyEdit* widget)
   {
     if (!widget)
       return;
 
     if (m_account.value(key).isEmpty()) {
       widget->clearText();
     } else {
       widget->setValue(MyMoneyMoney(m_account.value(key)));
     }
   }
 
   void loadKVP(const QString& key, KLineEdit* widget)
   {
     if (!widget)
       return;
 
     widget->setText(m_account.value(key));
   }
 
   void storeKVP(const QString& key, const QString& text, const QString& value)
   {
     if (text.isEmpty())
       m_account.deletePair(key);
     else
       m_account.setValue(key, value);
   }
 
   void storeKVP(const QString& key, QCheckBox* widget)
   {
     if (widget) {
       if(widget->isChecked()) {
         m_account.setValue(key, "Yes");;
       } else {
         m_account.deletePair(key);
       }
     }
   }
 
   void storeKVP(const QString& key, KMyMoneyEdit* widget)
   {
     storeKVP(key, widget->lineedit()->text(), widget->text());
   }
 
   void storeKVP(const QString& key, KLineEdit* widget)
   {
     storeKVP(key, widget->text(), widget->text());
   }
 
   void loadVatAccounts()
   {
     QList<MyMoneyAccount> list;
     MyMoneyFile::instance()->accountList(list);
     QList<MyMoneyAccount>::Iterator it;
     QStringList loadListExpense;
     QStringList loadListIncome;
     QStringList loadListAsset;
     QStringList loadListLiability;
     for (it = list.begin(); it != list.end(); ++it) {
       if (!(*it).value("VatRate").isEmpty()) {
         if ((*it).accountType() == Account::Type::Expense)
           loadListExpense += (*it).id();
         else if ((*it).accountType() == Account::Type::Income)
           loadListIncome += (*it).id();
         else if ((*it).accountType() == Account::Type::Asset)
           loadListAsset += (*it).id();
         else if ((*it).accountType() == Account::Type::Liability)
           loadListLiability += (*it).id();
       }
     }
     AccountSet vatSet;
     if (!loadListAsset.isEmpty())
       vatSet.load(ui->m_vatAccount, i18n("Asset"), loadListAsset, true);
     if (!loadListLiability.isEmpty())
       vatSet.load(ui->m_vatAccount, i18n("Liability"), loadListLiability, false);
     if (!loadListIncome.isEmpty())
       vatSet.load(ui->m_vatAccount, i18n("Income"), loadListIncome, false);
     if (!loadListExpense.isEmpty())
       vatSet.load(ui->m_vatAccount, i18n("Expense"), loadListExpense, false);
   }
 
   void adjustEditWidgets(KMyMoneyEdit* dst, KMyMoneyEdit* src, char mode, int corr)
   {
     MyMoneyMoney factor(corr, 1);
     if (m_account.accountGroup() == Account::Type::Asset)
       factor = -factor;
 
     switch (mode) {
       case '<':
         if (src->value()*factor < dst->value()*factor)
           dst->setValue(src->value());
         break;
 
       case '>':
         if (src->value()*factor > dst->value()*factor)
           dst->setValue(src->value());
         break;
     }
   }
 
   void handleOpeningBalanceCheckbox(const QString &currencyId)
   {
     if (m_account.accountType() == Account::Type::Equity) {
       // check if there is another opening balance account with the same currency
       bool isOtherOpenBalancingAccount = false;
       QList<MyMoneyAccount> list;
       MyMoneyFile::instance()->accountList(list);
       QList<MyMoneyAccount>::Iterator it;
       for (it = list.begin(); it != list.end(); ++it) {
         if (it->id() == m_account.id() || currencyId != it->currencyId()
             || it->accountType() != Account::Type::Equity)
           continue;
         if (it->value("OpeningBalanceAccount") == "Yes") {
           isOtherOpenBalancingAccount = true;
           break;
         }
       }
       if (!isOtherOpenBalancingAccount) {
         bool isOpenBalancingAccount = m_account.value("OpeningBalanceAccount") == "Yes";
         ui->m_qcheckboxOpeningBalance->setChecked(isOpenBalancingAccount);
         if (isOpenBalancingAccount) {
           // let only allow state change if no transactions are assigned to this account
           bool hasTransactions = MyMoneyFile::instance()->transactionCount(m_account.id()) != 0;
           ui->m_qcheckboxOpeningBalance->setEnabled(!hasTransactions);
           if (hasTransactions)
             ui->m_qcheckboxOpeningBalance->setToolTip(i18n("Option has been disabled because there are transactions assigned to this account"));
         }
       } else {
         ui->m_qcheckboxOpeningBalance->setChecked(false);
         ui->m_qcheckboxOpeningBalance->setEnabled(false);
         ui->m_qcheckboxOpeningBalance->setToolTip(i18n("Option has been disabled because there is another account flagged to be an opening balance account for this currency"));
       }
     } else {
       ui->m_qcheckboxOpeningBalance->setVisible(false);
     }
   }
 
   KNewAccountDlg             *q_ptr;
   Ui::KNewAccountDlg         *ui;
   MyMoneyAccount              m_account;
   MyMoneyAccount              m_parentAccount;
   HierarchyFilterProxyModel  *m_filterProxyModel;
 
   bool m_categoryEditor;
   bool m_isEditing;
 };
 
 KNewAccountDlg::KNewAccountDlg(const MyMoneyAccount& account, bool isEditing, bool categoryEditor, QWidget *parent, const QString& title) :
   QDialog(parent),
   d_ptr(new KNewAccountDlgPrivate(this))
 {
   Q_D(KNewAccountDlg);
   d->m_account = account;
   d->m_categoryEditor = categoryEditor;
   d->m_isEditing = isEditing;
   if (!title.isEmpty())
     setWindowTitle(title);
   d->init();
 }
 
 MyMoneyMoney KNewAccountDlg::openingBalance() const
 {
   Q_D(const KNewAccountDlg);
   return d->ui->m_openingBalanceEdit->value();
 }
 
 void KNewAccountDlg::setOpeningBalance(const MyMoneyMoney& balance)
 {
   Q_D(KNewAccountDlg);
   d->ui->m_openingBalanceEdit->setValue(balance);
 }
 
 void KNewAccountDlg::setOpeningBalanceShown(bool shown)
 {
   Q_D(KNewAccountDlg);
   d->ui->m_openingBalanceLabel->setVisible(shown);
   d->ui->m_openingBalanceEdit->setVisible(shown);
 }
 
 void KNewAccountDlg::setOpeningDateShown(bool shown)
 {
   Q_D(KNewAccountDlg);
   d->ui->m_openingDateLabel->setVisible(shown);
   d->ui->m_openingDateEdit->setVisible(shown);
 }
 
 void KNewAccountDlg::okClicked()
 {
   Q_D(KNewAccountDlg);
   auto file = MyMoneyFile::instance();
 
   QString accountNameText = d->ui->accountNameEdit->text();
   if (accountNameText.isEmpty()) {
     KMessageBox::error(this, i18n("You have not specified a name.\nPlease fill in this field."));
     d->ui->accountNameEdit->setFocus();
     return;
   }
 
   MyMoneyAccount parent = parentAccount();
   if (parent.name().length() == 0) {
     KMessageBox::error(this, i18n("Please select a parent account."));
     return;
   }
 
   if (!d->m_categoryEditor) {
     QString institutionNameText = d->ui->m_qcomboboxInstitutions->currentText();
     if (institutionNameText != i18n("(No Institution)")) {
       try {
         QList<MyMoneyInstitution> list = file->institutionList();
         QList<MyMoneyInstitution>::ConstIterator institutionIterator;
         for (institutionIterator = list.constBegin(); institutionIterator != list.constEnd(); ++institutionIterator) {
           if ((*institutionIterator).name() == institutionNameText)
             d->m_account.setInstitutionId((*institutionIterator).id());
         }
       } catch (const MyMoneyException &e) {
-        qDebug("Exception in account institution set: %s", qPrintable(e.what()));
+        qDebug("Exception in account institution set: %s", e.what());
       }
     } else {
       d->m_account.setInstitutionId(QString());
     }
   }
 
   d->m_account.setName(accountNameText);
   d->m_account.setNumber(d->ui->accountNoEdit->text());
   d->storeKVP("iban", d->ui->ibanEdit);
   d->storeKVP("minBalanceAbsolute", d->ui->m_minBalanceAbsoluteEdit);
   d->storeKVP("minBalanceEarly", d->ui->m_minBalanceEarlyEdit);
 
   // the figures for credit line with reversed sign
   if (!d->ui->m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
     d->ui->m_maxCreditAbsoluteEdit->setValue(d->ui->m_maxCreditAbsoluteEdit->value()*MyMoneyMoney::MINUS_ONE);
   if (!d->ui->m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
     d->ui->m_maxCreditEarlyEdit->setValue(d->ui->m_maxCreditEarlyEdit->value()*MyMoneyMoney::MINUS_ONE);
   d->storeKVP("maxCreditAbsolute", d->ui->m_maxCreditAbsoluteEdit);
   d->storeKVP("maxCreditEarly", d->ui->m_maxCreditEarlyEdit);
   if (!d->ui->m_maxCreditAbsoluteEdit->lineedit()->text().isEmpty())
     d->ui->m_maxCreditAbsoluteEdit->setValue(d->ui->m_maxCreditAbsoluteEdit->value()*MyMoneyMoney::MINUS_ONE);
   if (!d->ui->m_maxCreditEarlyEdit->lineedit()->text().isEmpty())
     d->ui->m_maxCreditEarlyEdit->setValue(d->ui->m_maxCreditEarlyEdit->value()*MyMoneyMoney::MINUS_ONE);
 
   d->storeKVP("lastNumberUsed", d->ui->m_lastCheckNumberUsed);
   // delete a previous version of the minimumbalance information
   d->storeKVP("minimumBalance", QString(), QString());
 
   Account::Type acctype;
   if (!d->m_categoryEditor) {
     acctype = static_cast<Account::Type>(d->ui->typeCombo->currentData().toInt());
     // If it's a loan, check if the parent is asset or liability. In
     // case of asset, we change the account type to be AssetLoan
     if (acctype == Account::Type::Loan
         && parent.accountGroup() == Account::Type::Asset)
       acctype = Account::Type::AssetLoan;
   } else {
     acctype = parent.accountGroup();
     QString newName;
     if (!MyMoneyFile::instance()->isStandardAccount(parent.id())) {
       newName = MyMoneyFile::instance()->accountToCategory(parent.id()) + MyMoneyFile::AccountSeparator;
     }
     newName += accountNameText;
     if (!file->categoryToAccount(newName, acctype).isEmpty()
         && (file->categoryToAccount(newName, acctype) != d->m_account.id())) {
       KMessageBox::error(this, QString("<qt>") + i18n("A category named <b>%1</b> already exists. You cannot create a second category with the same name.", newName) + QString("</qt>"));
       return;
     }
   }
   d->m_account.setAccountType(acctype);
 
   d->m_account.setDescription(d->ui->descriptionEdit->toPlainText());
 
   d->m_account.setOpeningDate(d->ui->m_openingDateEdit->date());
 
   if (!d->m_categoryEditor) {
     d->m_account.setCurrencyId(d->ui->m_currency->security().id());
 
     d->storeKVP("PreferredAccount", d->ui->m_qcheckboxPreferred);
     d->storeKVP("NoVat", d->ui->m_qcheckboxNoVat);
 
     if (d->ui->m_minBalanceAbsoluteEdit->isVisible()) {
       d->m_account.setValue("minimumBalance", d->ui->m_minBalanceAbsoluteEdit->value().toString());
     }
   } else {
     if (KMyMoneySettings::hideUnusedCategory() && !d->m_isEditing) {
       KMessageBox::information(this, i18n("You have selected to suppress the display of unused categories in the KMyMoney configuration dialog. The category you just created will therefore only be shown if it is used. Otherwise, it will be hidden in the accounts/categories view."), i18n("Hidden categories"), "NewHiddenCategory");
     }
     d->m_account.setCostCenterRequired(d->ui->m_costCenterRequiredCheckBox->isChecked());
   }
 
   d->storeKVP("Tax", d->ui->m_qcheckboxTax);
 
   if (d->ui->m_qcheckboxOpeningBalance->isChecked())
     d->m_account.setValue("OpeningBalanceAccount", "Yes");
   else
     d->m_account.deletePair("OpeningBalanceAccount");
 
   d->m_account.deletePair("VatAccount");
   d->m_account.deletePair("VatAmount");
   d->m_account.deletePair("VatRate");
 
   if (d->ui->m_vatCategory->isChecked()) {
     d->m_account.setValue("VatRate", (d->ui->m_vatRate->value().abs() / MyMoneyMoney(100, 1)).toString());
   } else {
     if (d->ui->m_vatAssignment->isChecked() && !d->ui->m_vatAccount->selectedItems().isEmpty()) {
       d->m_account.setValue("VatAccount", d->ui->m_vatAccount->selectedItems().first());
       if (d->ui->m_netAmount->isChecked())
         d->m_account.setValue("VatAmount", "Net");
     }
   }
 
   accept();
 }
 
 
 MyMoneyAccount KNewAccountDlg::account()
 {
   Q_D(KNewAccountDlg);
   // assign the right currency to the account
   d->m_account.setCurrencyId(d->ui->m_currency->security().id());
 
   // and the price mode
   switch (d->ui->m_priceMode->currentItem()) {
     case 0:
       d->m_account.deletePair("priceMode");
       break;
     case 1:
     case 2:
       d->m_account.setValue("priceMode", QString("%1").arg(d->ui->m_priceMode->currentItem()));
       break;
   }
 
   return d->m_account;
 }
 
 MyMoneyAccount KNewAccountDlg::parentAccount() const
 {
   Q_D(const KNewAccountDlg);
   return d->m_parentAccount;
 }
 
 void KNewAccountDlg::slotSelectionChanged(const QItemSelection &current, const QItemSelection &previous)
 {
   Q_UNUSED(previous)
   Q_D(KNewAccountDlg);
   if (!current.indexes().empty()) {
     QVariant account = d->ui->m_parentAccounts->model()->data(current.indexes().front(), (int)eAccountsModel::Role::Account);
     if (account.isValid()) {
       d->m_parentAccount = account.value<MyMoneyAccount>();
       d->ui->m_subAccountLabel->setText(i18n("Is a sub account of %1", d->m_parentAccount.name()));
     }
   }
 }
 
 void KNewAccountDlg::slotLoadInstitutions(const QString& name)
 {
   Q_D(KNewAccountDlg);
   d->ui->m_qcomboboxInstitutions->clear();
   QString bic;
   // Are we forcing the user to use institutions?
   d->ui->m_qcomboboxInstitutions->addItem(i18n("(No Institution)"));
   d->ui->m_bicValue->setText(" ");
   d->ui->ibanEdit->setEnabled(false);
   d->ui->accountNoEdit->setEnabled(false);
   try {
     auto file = MyMoneyFile::instance();
 
     QList<MyMoneyInstitution> list = file->institutionList();
     QList<MyMoneyInstitution>::ConstIterator institutionIterator;
     for (institutionIterator = list.constBegin(); institutionIterator != list.constEnd(); ++institutionIterator) {
       if ((*institutionIterator).name() == name) {
         d->ui->ibanEdit->setEnabled(true);
         d->ui->accountNoEdit->setEnabled(true);
         d->ui->m_bicValue->setText((*institutionIterator).value("bic"));
       }
       d->ui->m_qcomboboxInstitutions->addItem((*institutionIterator).name());
     }
 
     d->ui->m_qcomboboxInstitutions->setCurrentItem(name, false);
   } catch (const MyMoneyException &e) {
-    qDebug("Exception in institution load: %s", qPrintable(e.what()));
+    qDebug("Exception in institution load: %s", e.what());
   }
 }
 
 void KNewAccountDlg::slotNewClicked()
 {
   MyMoneyInstitution institution;
 
   QPointer<KNewBankDlg> dlg = new KNewBankDlg(institution, this);
   if (dlg->exec()) {
     MyMoneyFileTransaction ft;
     try {
       auto file = MyMoneyFile::instance();
 
       institution = dlg->institution();
       file->addInstitution(institution);
       ft.commit();
       slotLoadInstitutions(institution.name());
     } catch (const MyMoneyException &) {
       KMessageBox::information(this, i18n("Cannot add institution"));
     }
   }
   delete dlg;
 }
 
 void KNewAccountDlg::slotAccountTypeChanged(int index)
 {
   Q_D(KNewAccountDlg);
   Account::Type oldType;
 
   auto type = d->ui->typeCombo->itemData(index).value<Account::Type>();
   try {
     oldType = d->m_account.accountType();
     if (oldType != type) {
       d->m_account.setAccountType(type);
       // update the account group displayed in the accounts hierarchy
       d->m_filterProxyModel->clear();
       d->m_filterProxyModel->addAccountGroup(QVector<Account::Type> {d->m_account.accountGroup()});
     }
   } catch (const MyMoneyException &) {
     qWarning("Unexpected exception in KNewAccountDlg::slotAccountTypeChanged()");
   }
 }
 
 void KNewAccountDlg::slotCheckFinished()
 {
   Q_D(KNewAccountDlg);
   auto showButton = true;
 
   if (d->ui->accountNameEdit->text().length() == 0) {
     showButton = false;
   }
 
   if (d->ui->m_vatCategory->isChecked() && d->ui->m_vatRate->value() <= MyMoneyMoney()) {
     showButton = false;
   } else {
     if (d->ui->m_vatAssignment->isChecked() && d->ui->m_vatAccount->selectedItems().isEmpty())
       showButton = false;
   }
   d->ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(showButton);
 }
 
 void KNewAccountDlg::slotVatChanged(bool state)
 {
   Q_D(KNewAccountDlg);
   if (state) {
     d->ui->m_vatCategoryFrame->show();
     d->ui->m_vatAssignmentFrame->hide();
   } else {
     d->ui->m_vatCategoryFrame->hide();
     if (!d->m_account.isAssetLiability()) {
       d->ui->m_vatAssignmentFrame->show();
     }
   }
 }
 
 void KNewAccountDlg::slotVatAssignmentChanged(bool state)
 {
   Q_D(KNewAccountDlg);
   d->ui->m_vatAccount->setEnabled(state);
   d->ui->m_amountGroupBox->setEnabled(state);
 }
 
 void KNewAccountDlg::slotAdjustMinBalanceAbsoluteEdit(const QString&)
 {
   Q_D(KNewAccountDlg);
   d->adjustEditWidgets(d->ui->m_minBalanceAbsoluteEdit, d->ui->m_minBalanceEarlyEdit, '<', -1);
 }
 
 void KNewAccountDlg::slotAdjustMinBalanceEarlyEdit(const QString&)
 {
   Q_D(KNewAccountDlg);
   d->adjustEditWidgets(d->ui->m_minBalanceEarlyEdit, d->ui->m_minBalanceAbsoluteEdit, '>', -1);
 }
 
 void KNewAccountDlg::slotAdjustMaxCreditAbsoluteEdit(const QString&)
 {
   Q_D(KNewAccountDlg);
   d->adjustEditWidgets(d->ui->m_maxCreditAbsoluteEdit, d->ui->m_maxCreditEarlyEdit, '>', 1);
 }
 
 void KNewAccountDlg::slotAdjustMaxCreditEarlyEdit(const QString&)
 {
   Q_D(KNewAccountDlg);
   d->adjustEditWidgets(d->ui->m_maxCreditEarlyEdit, d->ui->m_maxCreditAbsoluteEdit, '<', 1);
 }
 
 void KNewAccountDlg::slotCheckCurrency(int index)
 {
   Q_D(KNewAccountDlg);
   Q_UNUSED(index)
   d->handleOpeningBalanceCheckbox(d->ui->m_currency->security().id());
 }
 
 void KNewAccountDlg::addTab(QWidget* w, const QString& name)
 {
   Q_D(KNewAccountDlg);
   if (w) {
     w->setParent(d->ui->m_tab);
     d->ui->m_tab->addTab(w, name);
   }
 }
 
 void KNewAccountDlg::newCategory(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   if (KMessageBox::questionYesNo(nullptr,
                                  QString::fromLatin1("<qt>%1</qt>").arg(i18n("<p>The category <b>%1</b> currently does not exist. Do you want to create it?</p><p><i>The parent account will default to <b>%2</b> but can be changed in the following dialog</i>.</p>", account.name(), parent.name())), i18n("Create category"),
                                  KStandardGuiItem::yes(), KStandardGuiItem::no(), "CreateNewCategories") == KMessageBox::Yes) {
     KNewAccountDlg::createCategory(account, parent);
   } else {
     // we should not keep the 'no' setting because that can confuse people like
     // I have seen in some usability tests. So we just delete it right away.
     KSharedConfigPtr kconfig = KSharedConfig::openConfig();
     if (kconfig) {
       kconfig->group(QLatin1String("Notification Messages")).deleteEntry(QLatin1String("CreateNewCategories"));
     }
   }
 }
 
 void KNewAccountDlg::createCategory(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   if (!parent.id().isEmpty()) {
     try {
       // make sure parent account exists
       MyMoneyFile::instance()->account(parent.id());
       account.setParentAccountId(parent.id());
       account.setAccountType(parent.accountType());
     } catch (const MyMoneyException &) {
     }
   }
 
   QPointer<KNewAccountDlg> dialog =
     new KNewAccountDlg(account, false, true, 0, i18n("Create a new Category"));
 
   dialog->setOpeningBalanceShown(false);
   dialog->setOpeningDateShown(false);
 
   if (dialog->exec() == QDialog::Accepted && dialog != 0) {
     MyMoneyAccount parentAccount, brokerageAccount;
     account = dialog->account();
     parentAccount = dialog->parentAccount();
 
     MyMoneyFile::instance()->createAccount(account, parentAccount, brokerageAccount, MyMoneyMoney());
   }
   delete dialog;
 }
diff --git a/kmymoney/dialogs/transactioneditor.cpp b/kmymoney/dialogs/transactioneditor.cpp
index 8b9626abc..20239668c 100644
--- a/kmymoney/dialogs/transactioneditor.cpp
+++ b/kmymoney/dialogs/transactioneditor.cpp
@@ -1,853 +1,853 @@
 /***************************************************************************
                              transactioneditor.cpp
                              ----------
     begin                : Wed Jun 07 2006
     copyright            : (C) 2006 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "transactioneditor.h"
 #include "transactioneditor_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QApplication>
 #include <QEventLoop>
 #include <QKeyEvent>
 #include <QList>
 #include <QEvent>
 #include <QIcon>
 #include <QTimer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KTextEdit>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KGuiItem>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneytagcombo.h"
 #include "knewinvestmentwizard.h"
 #include "knewaccountdlg.h"
 #include "ktagcontainer.h"
 #include "tabbar.h"
 #include "mymoneyutils.h"
 #include "mymoneyexception.h"
 #include "kmymoneycategory.h"
 #include "kmymoneymvccombo.h"
 #include "kmymoneyedit.h"
 #include "kmymoneylineedit.h"
 #include "mymoneyfile.h"
 #include "mymoneyprice.h"
 #include "mymoneysecurity.h"
 #include "kmymoneyutils.h"
 #include "kmymoneycompletion.h"
 #include "transaction.h"
 #include "transactionform.h"
 #include "kmymoneysettings.h"
 #include "transactioneditorcontainer.h"
 
 #include "kcurrencycalculator.h"
 #include "icons.h"
 
 using namespace KMyMoneyRegister;
 using namespace KMyMoneyTransactionForm;
 using namespace Icons;
 
 TransactionEditor::TransactionEditor() :
   d_ptr(new TransactionEditorPrivate(this))
 {
   Q_D(TransactionEditor);
   d->init();
 }
 
 TransactionEditor::TransactionEditor(TransactionEditorPrivate &dd,
                                      TransactionEditorContainer* regForm,
                                      KMyMoneyRegister::Transaction* item,
                                      const KMyMoneyRegister::SelectedTransactions& list,
                                      const QDate& lastPostDate) :
   d_ptr(&dd)
 //  d_ptr(new TransactionEditorPrivate)
 {
   Q_D(TransactionEditor);
   d->m_paymentMethod = eMyMoney::Schedule::PaymentType::Any;
   d->m_transactions = list;
   d->m_regForm = regForm;
   d->m_item = item;
   d->m_transaction = item->transaction();
   d->m_split = item->split();
   d->m_lastPostDate = lastPostDate;
   d->m_initialAction = eWidgets::eRegister::Action::None;
   d->m_openEditSplits = false;
   d->m_memoChanged = false;
   d->m_item->startEditMode();
   connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, this, static_cast<void (TransactionEditor::*)()>(&TransactionEditor::slotUpdateAccount));
 }
 
 TransactionEditor::TransactionEditor(TransactionEditorPrivate &dd) :
   d_ptr(&dd)
 {
   Q_D(TransactionEditor);
   d->init();
 }
 
 TransactionEditor::~TransactionEditor()
 {
   Q_D(TransactionEditor);
   // Make sure the widgets do not send out signals to the editor anymore
   // After all, the editor is about to die
 
   //disconnect first tagCombo:
   auto w = dynamic_cast<KTagContainer*>(haveWidget("tag"));
   if (w && w->tagCombo()) {
     w->tagCombo()->disconnect(this);
   }
 
   QMap<QString, QWidget*>::iterator it_w;
   for (it_w = d->m_editWidgets.begin(); it_w != d->m_editWidgets.end(); ++it_w) {
     (*it_w)->disconnect(this);
   }
 
   d->m_regForm->removeEditWidgets(d->m_editWidgets);
   d->m_item->leaveEditMode();
   emit finishEdit(d->m_transactions);
 }
 
 void TransactionEditor::slotUpdateAccount(const QString& id)
 {
   Q_D(TransactionEditor);
   d->m_account = MyMoneyFile::instance()->account(id);
   setupPrecision();
 }
 
 void TransactionEditor::slotUpdateAccount()
 {
   Q_D(TransactionEditor);
   // reload m_account as it might have been changed
   d->m_account = MyMoneyFile::instance()->account(d->m_account.id());
   setupPrecision();
 }
 
 void TransactionEditor::setupPrecision()
 {
   Q_D(TransactionEditor);
   const int prec = (d->m_account.id().isEmpty()) ? 2 : MyMoneyMoney::denomToPrec(d->m_account.fraction());
   QStringList widgets = QString("amount,deposit,payment").split(',');
   QStringList::const_iterator it_w;
   for (it_w = widgets.constBegin(); it_w != widgets.constEnd(); ++it_w) {
     QWidget * w;
     if ((w = haveWidget(*it_w)) != 0) {
       if (auto precisionWidget = dynamic_cast<KMyMoneyEdit*>(w))
         precisionWidget->setPrecision(prec);
     }
   }
 }
 
 void TransactionEditor::setup(QWidgetList& tabOrderWidgets, const MyMoneyAccount& account, eWidgets::eRegister::Action action)
 {
   Q_D(TransactionEditor);
   d->m_account = account;
   d->m_initialAction = action;
   createEditWidgets();
   d->m_regForm->arrangeEditWidgets(d->m_editWidgets, d->m_item);
   d->m_regForm->tabOrder(tabOrderWidgets, d->m_item);
   QWidget* w = haveWidget("tabbar");
   if (w) {
     tabOrderWidgets.append(w);
     auto tabbar = dynamic_cast<KMyMoneyTransactionForm::TabBar*>(w);
     if ((tabbar) && (action == eWidgets::eRegister::Action::None)) {
       action = static_cast<eWidgets::eRegister::Action>(tabbar->currentIndex());
     }
   }
   loadEditWidgets(action);
 
   // remove all unused widgets and don't forget to remove them
   // from the tab order list as well
   d->m_editWidgets.removeOrphans();
   QWidgetList::iterator it_w;
   const QWidgetList editWidgets(d->m_editWidgets.values());
   for (it_w = tabOrderWidgets.begin(); it_w != tabOrderWidgets.end();) {
     if (editWidgets.contains(*it_w)) {
       ++it_w;
     } else {
       // before we remove the widget, we make sure it's not a part of a known one.
       // these could be a direct child in case of KMyMoneyDateInput and KMyMoneyEdit
       // where we store the pointer to the surrounding frame in editWidgets
       // or the parent is called "KMyMoneyCategoryFrame"
       if (*it_w) {
         if (editWidgets.contains((*it_w)->parentWidget())
             || ((*it_w)->parentWidget() && (*it_w)->parentWidget()->objectName() == QLatin1String("KMyMoneyCategoryFrame"))) {
           ++it_w;
 
         } else {
           // qDebug("Remove '%s' from taborder", qPrintable((*it_w)->objectName()));
           it_w = tabOrderWidgets.erase(it_w);
         }
       } else {
         it_w = tabOrderWidgets.erase(it_w);
       }
     }
   }
 
   clearFinalWidgets();
   setupFinalWidgets();
   slotUpdateButtonState();
 }
 
 void TransactionEditor::setup(QWidgetList& tabOrderWidgets, const MyMoneyAccount& account)
 {
   setup(tabOrderWidgets, account, eWidgets::eRegister::Action::None);
 }
 
 void TransactionEditor::setup(QWidgetList& tabOrderWidgets)
 {
   setup(tabOrderWidgets, MyMoneyAccount(), eWidgets::eRegister::Action::None);
 }
 
 MyMoneyAccount TransactionEditor::account() const
 {
   Q_D(const TransactionEditor);
   return d->m_account;
 }
 
 void TransactionEditor::setScheduleInfo(const QString& si)
 {
   Q_D(TransactionEditor);
   d->m_scheduleInfo = si;
 }
 
 void TransactionEditor::setPaymentMethod(eMyMoney::Schedule::PaymentType pm)
 {
   Q_D(TransactionEditor);
   d->m_paymentMethod = pm;
 }
 
 void TransactionEditor::clearFinalWidgets()
 {
   Q_D(TransactionEditor);
   d->m_finalEditWidgets.clear();
 }
 
 void TransactionEditor::addFinalWidget(const QWidget* w)
 {
   Q_D(TransactionEditor);
   if (w) {
     d->m_finalEditWidgets << w;
   }
 }
 
 void TransactionEditor::slotReloadEditWidgets()
 {
 }
 
 bool TransactionEditor::eventFilter(QObject* o, QEvent* e)
 {
   Q_D(TransactionEditor);
   bool rc = false;
   if (o == haveWidget("number")) {
     if (e->type() == QEvent::MouseButtonDblClick) {
       emit assignNumber();
       rc = true;
     }
   }
 
   // if the object is a widget, the event is a key press event and
   // the object is one of our edit widgets, then ....
   auto numberWiget = dynamic_cast<QWidget*>(o);
   if (o->isWidgetType()
       && (e->type() == QEvent::KeyPress)
       && numberWiget && d->m_editWidgets.values().contains(numberWiget)) {
     auto k = dynamic_cast<QKeyEvent*>(e);
     if ((k && (k->modifiers() & Qt::KeyboardModifierMask)) == 0
         || (k && (k->modifiers() & Qt::KeypadModifier)) != 0) {
       bool isFinal = false;
       QList<const QWidget*>::const_iterator it_w;
       switch (k->key()) {
         case Qt::Key_Return:
         case Qt::Key_Enter:
           // we check, if the object is one of the m_finalEditWidgets and if it's
           // a KMyMoneyEdit object that the value is not 0. If any of that is the
           // case, it's the final object. In other cases, we convert the enter
           // key into a TAB key to move between the fields. Of course, we only need
           // to do this as long as the appropriate option is set. In all other cases,
           // we treat the return/enter key as such.
           if (KMyMoneySettings::enterMovesBetweenFields()) {
             for (it_w = d->m_finalEditWidgets.constBegin(); !isFinal && it_w != d->m_finalEditWidgets.constEnd(); ++it_w) {
               if (*it_w == o) {
                 if (auto widget = dynamic_cast<const KMyMoneyEdit*>(*it_w)) {
                   isFinal = !(widget->value().isZero());
                 } else
                   isFinal = true;
               }
             }
           } else
             isFinal = true;
 
           // for the non-final objects, we treat the return key as a TAB
           if (!isFinal) {
             QKeyEvent evt(e->type(),
                           Qt::Key_Tab, k->modifiers(), QString(),
                           k->isAutoRepeat(), k->count());
 
             QApplication::sendEvent(o, &evt);
             // in case of a category item and the split button is visible
             // send a second event so that we get passed the button.
             auto widget = dynamic_cast<KMyMoneyCategory*>(o);
             if (widget && widget->splitButton())
               QApplication::sendEvent(o, &evt);
 
           } else {
             QTimer::singleShot(0, this, SIGNAL(returnPressed()));
           }
           // don't process any further
           rc = true;
           break;
 
         case Qt::Key_Escape:
           QTimer::singleShot(0, this, SIGNAL(escapePressed()));
           break;
       }
     }
   }
   return rc;
 }
 
 void TransactionEditor::slotNumberChanged(const QString& txt)
 {
   Q_D(TransactionEditor);
   auto next = txt;
   QString schedInfo;
   if (!d->m_scheduleInfo.isEmpty()) {
     schedInfo = i18n("<center>Processing schedule for %1.</center>", d->m_scheduleInfo);
   }
 
   while (MyMoneyFile::instance()->checkNoUsed(d->m_account.id(), next)) {
     if (KMessageBox::questionYesNo(d->m_regForm, QString("<qt>") + schedInfo + i18n("<center>Check number <b>%1</b> has already been used in account <b>%2</b>.</center>"
                                    "<center>Do you want to replace it with the next available number?</center>", next, d->m_account.name()) + QString("</qt>"), i18n("Duplicate number")) == KMessageBox::Yes) {
       assignNextNumber();
       next = KMyMoneyUtils::nextCheckNumber(d->m_account);
     } else if (auto number = dynamic_cast<KMyMoneyLineEdit*>(haveWidget("number"))) {
       number->setText(QString());
       break;
     }
   }
 }
 
 void TransactionEditor::slotUpdateMemoState()
 {
   Q_D(TransactionEditor);
   KTextEdit* memo = dynamic_cast<KTextEdit*>(d->m_editWidgets["memo"]);
   if (memo) {
     d->m_memoChanged = (memo->toPlainText() != d->m_memoText);
   }
 }
 
 void TransactionEditor::slotUpdateButtonState()
 {
   QString reason;
   emit transactionDataSufficient(isComplete(reason));
 }
 
 QWidget* TransactionEditor::haveWidget(const QString& name) const
 {
   Q_D(const TransactionEditor);
   return d->m_editWidgets.haveWidget(name);
 }
 
 int TransactionEditor::slotEditSplits()
 {
   return QDialog::Rejected;
 }
 
 void TransactionEditor::setTransaction(const MyMoneyTransaction& t, const MyMoneySplit& s)
 {
   Q_D(TransactionEditor);
   d->m_transaction = t;
   d->m_split = s;
   loadEditWidgets();
 }
 
 bool TransactionEditor::isMultiSelection() const
 {
   Q_D(const TransactionEditor);
   return d->m_transactions.count() > 1;
 }
 
 bool TransactionEditor::fixTransactionCommodity(const MyMoneyAccount& account)
 {
   Q_D(TransactionEditor);
   bool rc = true;
   bool firstTimeMultiCurrency = true;
   d->m_account = account;
 
   auto file = MyMoneyFile::instance();
 
   // determine the max fraction for this account
   MyMoneySecurity sec = file->security(d->m_account.currencyId());
   int fract = d->m_account.fraction();
 
   // scan the list of selected transactions
   KMyMoneyRegister::SelectedTransactions::iterator it_t;
   for (it_t = d->m_transactions.begin(); (rc == true) && (it_t != d->m_transactions.end()); ++it_t) {
     // there was a time when the schedule editor did not setup the transaction commodity
     // let's give a helping hand here for those old schedules
     if ((*it_t).transaction().commodity().isEmpty())
       (*it_t).transaction().setCommodity(d->m_account.currencyId());
     // we need to check things only if a different commodity is used
     if (d->m_account.currencyId() != (*it_t).transaction().commodity()) {
       MyMoneySecurity osec = file->security((*it_t).transaction().commodity());
       switch ((*it_t).transaction().splitCount()) {
         case 0:
           // new transaction, guess nothing's here yet ;)
           break;
 
         case 1:
           try {
             // make sure, that the value is equal to the shares, don't forget our own copy
             MyMoneySplit& splitB = (*it_t).split();  // reference usage wanted here
             if (d->m_split == splitB)
               d->m_split.setValue(splitB.shares());
             splitB.setValue(splitB.shares());
             (*it_t).transaction().modifySplit(splitB);
 
           } catch (const MyMoneyException &e) {
-            qDebug("Unable to update commodity to second splits currency in %s: '%s'", qPrintable((*it_t).transaction().id()), qPrintable(e.what()));
+            qDebug("Unable to update commodity to second splits currency in %s: '%s'", qPrintable((*it_t).transaction().id()), e.what());
           }
           break;
 
         case 2:
           // If we deal with multiple currencies we make sure, that for
           // transactions with two splits, the transaction's commodity is the
           // currency of the currently selected account. This saves us from a
           // lot of grieve later on.  We just have to switch the
           // transactions commodity. Let's assume the following scenario:
           // - transactions commodity is CA
           // - splitB and account's currencyId is CB
           // - splitA is of course in CA (otherwise we have a real problem)
           // - Value is V in both splits
           // - Shares in splitB is SB
           // - Shares in splitA is SA (and equal to V)
           //
           // We do the following:
           // - change transactions commodity to CB
           // - set V in both splits to SB
           // - modify the splits in the transaction
           try {
             // retrieve the splits
             MyMoneySplit& splitB = (*it_t).split();  // reference usage wanted here
             MyMoneySplit splitA = (*it_t).transaction().splitByAccount(d->m_account.id(), false);
 
             // - set V in both splits to SB. Don't forget our own copy
             if (d->m_split == splitB) {
               d->m_split.setValue(splitB.shares());
             }
             splitB.setValue(splitB.shares());
             splitA.setValue(-splitB.shares());
             (*it_t).transaction().modifySplit(splitA);
             (*it_t).transaction().modifySplit(splitB);
 
           } catch (const MyMoneyException &e) {
-            qDebug("Unable to update commodity to second splits currency in %s: '%s'", qPrintable((*it_t).transaction().id()), qPrintable(e.what()));
+            qDebug("Unable to update commodity to second splits currency in %s: '%s'", qPrintable((*it_t).transaction().id()), e.what());
           }
           break;
 
         default:
           // TODO: use new logic by adjusting all splits by the price
           // extracted from the selected split. Inform the user that
           // this will happen and allow him to stop the processing (rc = false)
 
           try {
             QString msg;
             if (firstTimeMultiCurrency) {
               firstTimeMultiCurrency = false;
               if (!isMultiSelection()) {
                 msg = i18n("This transaction has more than two splits and is originally based on a different currency (%1). Using this account to modify the transaction may result in rounding errors. Do you want to continue?", osec.name());
               } else {
                 msg = i18n("At least one of the selected transactions has more than two splits and is originally based on a different currency (%1). Using this account to modify the transactions may result in rounding errors. Do you want to continue?", osec.name());
               }
 
               if (KMessageBox::warningContinueCancel(0, QString("<qt>%1</qt>").arg(msg)) == KMessageBox::Cancel) {
                 rc = false;
               }
             }
 
             if (rc == true) {
               MyMoneyMoney price;
               if (!(*it_t).split().shares().isZero() && !(*it_t).split().value().isZero())
                 price = (*it_t).split().shares() / (*it_t).split().value();
               MyMoneySplit& mySplit = (*it_t).split();
               foreach (const auto split, (*it_t).transaction().splits()) {
                 auto s = split;
                 if (s == mySplit) {
                   s.setValue(s.shares());
                   if (mySplit == d->m_split) {
                     d->m_split = s;
                   }
                   mySplit = s;
                 } else {
                   s.setValue((s.value() * price).convert(fract));
                 }
                 (*it_t).transaction().modifySplit(s);
               }
             }
           } catch (const MyMoneyException &e) {
-            qDebug("Unable to update commodity of split currency in %s: '%s'", qPrintable((*it_t).transaction().id()), qPrintable(e.what()));
+            qDebug("Unable to update commodity of split currency in %s: '%s'", qPrintable((*it_t).transaction().id()), e.what());
           }
           break;
       }
 
       // set the transaction's ommodity to this account's currency
       (*it_t).transaction().setCommodity(d->m_account.currencyId());
 
       // update our copy of the transaction that has the focus
       if ((*it_t).transaction().id() == d->m_transaction.id()) {
         d->m_transaction = (*it_t).transaction();
       }
     }
   }
   return rc;
 }
 
 void TransactionEditor::assignNextNumber()
 {
   Q_D(TransactionEditor);
   if (canAssignNumber()) {
     auto number = dynamic_cast<KMyMoneyLineEdit*>(haveWidget("number"));
     QString num = KMyMoneyUtils::nextCheckNumber(d->m_account);
     bool showMessage = true;
     int rc = KMessageBox::No;
     QString schedInfo;
     if (!d->m_scheduleInfo.isEmpty()) {
       schedInfo = i18n("<center>Processing schedule for %1.</center>", d->m_scheduleInfo);
     }
     while (MyMoneyFile::instance()->checkNoUsed(d->m_account.id(), num)) {
       if (showMessage) {
         rc = KMessageBox::questionYesNo(d->m_regForm, QString("<qt>") + schedInfo + i18n("Check number <b>%1</b> has already been used in account <b>%2</b>."
                                         "<center>Do you want to replace it with the next available number?</center>", num, d->m_account.name()) + QString("</qt>"), i18n("Duplicate number"));
         showMessage = false;
       }
       if (rc == KMessageBox::Yes) {
         num = KMyMoneyUtils::nextCheckNumber(d->m_account);
         KMyMoneyUtils::updateLastNumberUsed(d->m_account, num);
         d->m_account.setValue("lastNumberUsed", num);
         if (number)
           number->loadText(num);
       } else {
         num = QString();
         break;
       }
     }
     if (number)
       number->setText(num);
   }
 }
 
 bool TransactionEditor::canAssignNumber() const
 {
   if (dynamic_cast<KMyMoneyLineEdit*>(haveWidget("number")))
     return true;
   return false;
 }
 
 void TransactionEditor::setupCategoryWidget(KMyMoneyCategory* category, const QList<MyMoneySplit>& splits, QString& categoryId, const char* splitEditSlot, bool /* allowObjectCreation */)
 {
   disconnect(category, SIGNAL(focusIn()), this, splitEditSlot);
 #if 0
   // FIXME must deal with the logic that suppressObjectCreation is
   // automatically turned off when the createItem() signal is connected
   if (allowObjectCreation)
     category->setSuppressObjectCreation(false);
 #endif
 
   switch (splits.count()) {
     case 0:
       categoryId.clear();
       if (!category->currentText().isEmpty()) {
         //   category->clearEditText();  //  don't clear as could be from another widget - Bug 322768
         // make sure, we don't see the selector
         category->completion()->hide();
       }
       category->completion()->setSelected(QString());
       break;
 
     case 1:
       categoryId = splits[0].accountId();
       category->completion()->setSelected(categoryId);
       category->slotItemSelected(categoryId);
       break;
 
     default:
       categoryId.clear();
       category->setSplitTransaction();
       connect(category, SIGNAL(focusIn()), this, splitEditSlot);
 #if 0
       // FIXME must deal with the logic that suppressObjectCreation is
       // automatically turned off when the createItem() signal is connected
       if (allowObjectCreation)
         category->setSuppressObjectCreation(true);
 #endif
       break;
   }
 }
 
 bool TransactionEditor::enterTransactions(QString& newId, bool askForSchedule, bool suppressBalanceWarnings)
 {
   Q_D(TransactionEditor);
   newId.clear();
   auto file = MyMoneyFile::instance();
 
   // make sure to run through all stuff that is tied to 'focusout events'.
   d->m_regForm->parentWidget()->setFocus();
   QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 10);
   // we don't need to update our widgets anymore, so we just disconnect the signal
   disconnect(file, &MyMoneyFile::dataChanged, this, &TransactionEditor::slotReloadEditWidgets);
 
   KMyMoneyRegister::SelectedTransactions::iterator it_t;
   MyMoneyTransaction t;
   bool newTransactionCreated = false;
 
   // make sure, that only a single new transaction can be created.
   // we need to update m_transactions to contain the new transaction
   // which is then stored in the variable t when we leave the loop.
   // m_transactions will be sent out in finishEdit() and forces
   // the new transaction to be selected in the ledger view
 
   // collect the transactions to be stored in the engine in a local
   // list first, so that the user has a chance to interrupt the storage
   // process
   QList<MyMoneyTransaction> list;
   auto storeTransactions = true;
 
   // collect transactions
   for (it_t = d->m_transactions.begin(); storeTransactions && !newTransactionCreated && it_t != d->m_transactions.end(); ++it_t) {
     storeTransactions = createTransaction(t, (*it_t).transaction(), (*it_t).split());
     // if the transaction was created successfully, append it to the list
     if (storeTransactions)
       list.append(t);
 
     // if we created a new transaction keep that in mind
     if (t.id().isEmpty())
       newTransactionCreated = true;
   }
 
   // if not interrupted by user, continue to store them in the engine
   if (storeTransactions) {
     auto i = 0;
     emit statusMsg(i18n("Storing transactions"));
     emit statusProgress(0, list.count());
 
     MyMoneyFileTransaction ft;
 
     try {
       QMap<QString, bool> minBalanceEarly;
       QMap<QString, bool> minBalanceAbsolute;
       QMap<QString, bool> maxCreditEarly;
       QMap<QString, bool> maxCreditAbsolute;
       QMap<QString, bool> accountIds;
 
       for (MyMoneyTransaction& transaction : list) {
         // if we have a categorization, make sure we remove
         // the 'imported' flag automagically
         if (transaction.splitCount() > 1)
           transaction.setImported(false);
 
         // create information about min and max balances
         foreach (const auto split, transaction.splits()) {
           auto acc = file->account(split.accountId());
           accountIds[acc.id()] = true;
           MyMoneyMoney balance = file->balance(acc.id());
           if (!acc.value("minBalanceEarly").isEmpty()) {
             minBalanceEarly[acc.id()] = balance < MyMoneyMoney(acc.value("minBalanceEarly"));
           }
           if (!acc.value("minBalanceAbsolute").isEmpty()) {
             minBalanceAbsolute[acc.id()] = balance < MyMoneyMoney(acc.value("minBalanceAbsolute"));
             minBalanceEarly[acc.id()] = false;
           }
           if (!acc.value("maxCreditEarly").isEmpty()) {
             maxCreditEarly[acc.id()] = balance < MyMoneyMoney(acc.value("maxCreditEarly"));
           }
           if (!acc.value("maxCreditAbsolute").isEmpty()) {
             maxCreditAbsolute[acc.id()] = balance < MyMoneyMoney(acc.value("maxCreditAbsolute"));
             maxCreditEarly[acc.id()] = false;
           }
         }
 
         if (transaction.id().isEmpty()) {
           bool enter = true;
           if (askForSchedule && transaction.postDate() > QDate::currentDate()) {
             KGuiItem enterButton(i18n("&Enter"),
                                  Icons::get(Icon::DialogOK),
                                  i18n("Accepts the entered data and stores it"),
                                  i18n("Use this to enter the transaction into the ledger."));
             KGuiItem scheduleButton(i18n("&Schedule"),
                                     Icons::get(Icon::AppointmentNew),
                                     i18n("Accepts the entered data and stores it as schedule"),
                                     i18n("Use this to schedule the transaction for later entry into the ledger."));
 
             enter = KMessageBox::questionYesNo(d->m_regForm, QString("<qt>%1</qt>").arg(i18n("The transaction you are about to enter has a post date in the future.<br/><br/>Do you want to enter it in the ledger or add it to the schedules?")), i18nc("Dialog caption for 'Enter or schedule' dialog", "Enter or schedule?"), enterButton, scheduleButton, "EnterOrScheduleTransactionInFuture") == KMessageBox::Yes;
           }
           if (enter) {
             // add new transaction
             file->addTransaction(transaction);
             // pass the newly assigned id on to the caller
             newId = transaction.id();
             // refresh account object for transactional changes
             // refresh account and transaction object because they might have changed
             d->m_account = file->account(d->m_account.id());
             t = transaction;
 
             // if a new transaction has a valid number, keep it with the account
             d->keepNewNumber(transaction);
           } else {
             // turn object creation on, so that moving the focus does
             // not screw up the dialog that might be popping up
             emit objectCreation(true);
             emit scheduleTransaction(transaction, eMyMoney::Schedule::Occurrence::Once);
             emit objectCreation(false);
 
             newTransactionCreated = false;
           }
 
           // send out the post date of this transaction
           emit lastPostDateUsed(transaction.postDate());
         } else {
           // modify existing transaction
           // its number might have been edited
           // bearing in mind it could contain alpha characters
           d->keepNewNumber(transaction);
           file->modifyTransaction(transaction);
         }
       }
       emit statusProgress(i++, 0);
 
       // update m_transactions to contain the newly created transaction so that
       // it is selected as the current one
       // we need to do that before we commit the transaction to the engine
       // as we need it during the update of the views that is caused by committing already.
       if (newTransactionCreated) {
         d->m_transactions.clear();
         MyMoneySplit s;
         // a transaction w/o a single split should not exist and adding it
         // should throw an exception in MyMoneyFile::addTransaction, but we
         // remain on the save side of things to check for it
         if (t.splitCount() > 0)
           s = t.splits().front();
         KMyMoneyRegister::SelectedTransaction st(t, s, QString());
         d->m_transactions.append(st);
       }
 
       //    Save pricing information
       foreach (const auto split, t.splits()) {
         if ((split.action() != "Buy") &&
             (split.action() != "Reinvest")) {
           continue;
         }
         QString id = split.accountId();
         auto acc = file->account(id);
         MyMoneySecurity sec = file->security(acc.currencyId());
         MyMoneyPrice price(acc.currencyId(),
                            sec.tradingCurrency(),
                            t.postDate(),
                            split.price(), "Transaction");
         file->addPrice(price);
         break;
       }
 
       ft.commit();
 
       // now analyze the balances and spit out warnings to the user
       QMap<QString, bool>::const_iterator it_a;
 
       if (!suppressBalanceWarnings) {
         for (it_a = accountIds.constBegin(); it_a != accountIds.constEnd(); ++it_a) {
           QString msg;
           auto acc = file->account(it_a.key());
           MyMoneyMoney balance = file->balance(acc.id());
           const MyMoneySecurity& sec = file->security(acc.currencyId());
           QString key;
           key = "minBalanceEarly";
           if (!acc.value(key).isEmpty()) {
             if (minBalanceEarly[acc.id()] == false && balance < MyMoneyMoney(acc.value(key))) {
               msg = QString("<qt>%1</qt>").arg(i18n("The balance of account <b>%1</b> dropped below the warning balance of %2.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(acc.value(key)), acc, sec)));
             }
           }
           key = "minBalanceAbsolute";
           if (!acc.value(key).isEmpty()) {
             if (minBalanceAbsolute[acc.id()] == false && balance < MyMoneyMoney(acc.value(key))) {
               msg = QString("<qt>%1</qt>").arg(i18n("The balance of account <b>%1</b> dropped below the minimum balance of %2.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(acc.value(key)), acc, sec)));
             }
           }
           key = "maxCreditEarly";
           if (!acc.value(key).isEmpty()) {
             if (maxCreditEarly[acc.id()] == false && balance < MyMoneyMoney(acc.value(key))) {
               msg = QString("<qt>%1</qt>").arg(i18n("The balance of account <b>%1</b> dropped below the maximum credit warning limit of %2.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(acc.value(key)), acc, sec)));
             }
           }
           key = "maxCreditAbsolute";
           if (!acc.value(key).isEmpty()) {
             if (maxCreditAbsolute[acc.id()] == false && balance < MyMoneyMoney(acc.value(key))) {
               msg = QString("<qt>%1</qt>").arg(i18n("The balance of account <b>%1</b> dropped below the maximum credit limit of %2.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(acc.value(key)), acc, sec)));
             }
           }
 
           if (!msg.isEmpty()) {
             emit balanceWarning(d->m_regForm, acc, msg);
           }
         }
       }
     } catch (const MyMoneyException &e) {
-      qDebug("Unable to store transaction within engine: %s", qPrintable(e.what()));
+      qDebug("Unable to store transaction within engine: %s", e.what());
       newTransactionCreated = false;
     }
 
     emit statusProgress(-1, -1);
     emit statusMsg(QString());
 
   }
   return storeTransactions;
 }
 
 void TransactionEditor::resizeForm()
 {
   Q_D(TransactionEditor);
   // force resizeing of the columns in the form
 
   if (auto form = dynamic_cast<KMyMoneyTransactionForm::TransactionForm*>(d->m_regForm))
     QMetaObject::invokeMethod(form, "resize", Qt::QueuedConnection, QGenericReturnArgument(), Q_ARG(int, (int)eWidgets::eTransactionForm::Column::Value1));
 }
 
 void TransactionEditor::slotNewPayee(const QString& newnameBase, QString& id)
 {
   KMyMoneyUtils::newPayee(newnameBase, id);
 }
 
 void TransactionEditor::slotNewTag(const QString& newnameBase, QString& id)
 {
   KMyMoneyUtils::newTag(newnameBase, id);
 }
 
 void TransactionEditor::slotNewCategory(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   KNewAccountDlg::newCategory(account, parent);
 }
 
 void TransactionEditor::slotNewInvestment(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   KNewInvestmentWizard::newInvestment(account, parent);
 }
diff --git a/kmymoney/dialogs/transactionmatcher.cpp b/kmymoney/dialogs/transactionmatcher.cpp
index 2d94d2480..dfc3651ca 100644
--- a/kmymoney/dialogs/transactionmatcher.cpp
+++ b/kmymoney/dialogs/transactionmatcher.cpp
@@ -1,222 +1,221 @@
 /***************************************************************************
                              transactionmatcher.cpp
                              ----------
     begin                : Tue Jul 08 2008
     copyright            : (C) 2008 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                          : Christian David <christian-david@web.de>
                          (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "transactionmatcher.h"
 
 #include <QDate>
 
 #include <KLocalizedString>
 
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneysecurity.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyutils.h"
 #include "mymoneyfile.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 class TransactionMatcherPrivate
 {
   Q_DISABLE_COPY(TransactionMatcherPrivate)
 
 public:
   TransactionMatcherPrivate()
   {
   }
 
   MyMoneyAccount m_account;
 };
 
 TransactionMatcher::TransactionMatcher(const MyMoneyAccount& acc) :
   d_ptr(new TransactionMatcherPrivate)
 {
   Q_D(TransactionMatcher);
   d->m_account = acc;
 }
 
 TransactionMatcher::~TransactionMatcher()
 {
   Q_D(TransactionMatcher);
   delete d;
 }
 
 void TransactionMatcher::match(MyMoneyTransaction tm, MyMoneySplit sm, MyMoneyTransaction ti, MyMoneySplit si, bool allowImportedTransactions)
 {
   Q_D(TransactionMatcher);
   auto sec = MyMoneyFile::instance()->security(d->m_account.currencyId());
 
   // Now match the transactions.
   //
   // 'Matching' the transactions entails DELETING the end transaction,
   // and MODIFYING the start transaction as needed.
   //
   // There are a variety of ways that a transaction can conflict.
   // Post date, splits, amount are the ones that seem to matter.
   // TODO: Handle these conflicts intelligently, at least warning
   // the user, or better yet letting the user choose which to use.
   //
   // For now, we will just use the transaction details from the start
   // transaction.  The only thing we'll take from the end transaction
   // are the bank ID's.
   //
   // What we have to do here is iterate over the splits in the end
   // transaction, and find the corresponding split in the start
   // transaction.  If there is a bankID in the end split but not the
   // start split, add it to the start split.  If there is a bankID
   // in BOTH, then this transaction cannot be merged (both transactions
   // were imported!!)  If the corresponding start split cannot  be
   // found and the end split has a bankID, we should probably just fail.
   // Although we could ADD it to the transaction.
 
   // ipwizard: Don't know if iterating over the transactions is a good idea.
   // In case of a split transaction recorded with KMyMoney and the transaction
   // data being imported consisting only of a single category assignment, this
   // does not make much sense. The same applies for investment transactions
   // stored in KMyMoney against imported transactions. I think a better solution
   // is to just base the match on the splits referencing the same (currently
   // selected) account.
 
   // verify, that tm is a manual (non-matched) transaction
   // allow matching two manual transactions
 
   if ((!allowImportedTransactions && tm.isImported()) || sm.isMatched())
-    throw MYMONEYEXCEPTION(i18n("First transaction does not match requirement for matching"));
+    throw MYMONEYEXCEPTION_CSTRING("First transaction does not match requirement for matching");
 
   // verify that the amounts are the same, otherwise we should not be matching!
   if (sm.shares() != si.shares()) {
-    throw MYMONEYEXCEPTION(i18n("Splits for %1 have conflicting values (%2,%3)", d->m_account.name(), MyMoneyUtils::formatMoney(sm.shares(), d->m_account, sec), MyMoneyUtils::formatMoney(si.shares(), d->m_account, sec)));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Splits for %1 have conflicting values (%2,%3)").arg(d->m_account.name(), MyMoneyUtils::formatMoney(sm.shares(), d->m_account, sec), MyMoneyUtils::formatMoney(si.shares(), d->m_account, sec)));
   }
 
   // ipwizard: I took over the code to keep the bank id found in the endMatchTransaction
   // This might not work for QIF imports as they don't setup this information. It sure
   // makes sense for OFX and HBCI.
   const QString& bankID = si.bankID();
   if (!bankID.isEmpty()) {
     try {
       if (sm.bankID().isEmpty()) {
         sm.setBankID(bankID);
         tm.modifySplit(sm);
       }
     } catch (const MyMoneyException &e) {
-      QString estr = e.what();
-      throw MYMONEYEXCEPTION(i18n("Unable to match all splits (%1)", estr));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to match all splits (%1)").arg(e.what()));
     }
   }
   //
   //  we now allow matching of two non-imported transactions
   //
 
   // mark the split as cleared if it does not have a reconciliation information yet
   if (sm.reconcileFlag() == eMyMoney::Split::State::NotReconciled) {
     sm.setReconcileFlag(eMyMoney::Split::State::Cleared);
   }
 
   // if we don't have a payee assigned to the manually entered transaction
   // we use the one we found in the imported transaction
   if (sm.payeeId().isEmpty() && !si.payeeId().isEmpty()) {
     sm.setValue("kmm-orig-payee", sm.payeeId());
     sm.setPayeeId(si.payeeId());
   }
 
   // We use the imported postdate and keep the previous one for unmatch
   if (tm.postDate() != ti.postDate()) {
     sm.setValue("kmm-orig-postdate", tm.postDate().toString(Qt::ISODate));
     tm.setPostDate(ti.postDate());
   }
 
   // combine the two memos into one
   QString memo = sm.memo();
   if (!si.memo().isEmpty() && si.memo() != memo) {
     sm.setValue("kmm-orig-memo", memo);
     if (!memo.isEmpty())
       memo += '\n';
     memo += si.memo();
   }
   sm.setMemo(memo);
 
   // remember the split we matched
   sm.setValue("kmm-match-split", si.id());
 
   sm.addMatch(ti);
   tm.modifySplit(sm);
 
   ti.modifySplit(si);///
   MyMoneyFile::instance()->modifyTransaction(tm);
   // Delete the end transaction if it was stored in the engine
   if (!ti.id().isEmpty())
     MyMoneyFile::instance()->removeTransaction(ti);
 }
 
 void TransactionMatcher::unmatch(const MyMoneyTransaction& _t, const MyMoneySplit& _s)
 {
   if (_s.isMatched()) {
     MyMoneyTransaction tm(_t);
     MyMoneySplit sm(_s);
     MyMoneyTransaction ti(sm.matchedTransaction());
     MyMoneySplit si;
     // if we don't have a split, then we don't have a memo
     try {
       si = ti.splitById(sm.value("kmm-match-split"));
     } catch (const MyMoneyException &) {
     }
     sm.removeMatch();
 
     // restore the postdate if modified
     if (!sm.value("kmm-orig-postdate").isEmpty()) {
       tm.setPostDate(QDate::fromString(sm.value("kmm-orig-postdate"), Qt::ISODate));
     }
 
     // restore payee if modified
     if (!sm.value("kmm-orig-payee").isEmpty()) {
       sm.setPayeeId(sm.value("kmm-orig-payee"));
     }
 
     // restore memo if modified
     if (!sm.value("kmm-orig-memo").isEmpty()) {
       sm.setMemo(sm.value("kmm-orig-memo"));
     }
 
     sm.deletePair("kmm-orig-postdate");
     sm.deletePair("kmm-orig-payee");
     sm.deletePair("kmm-orig-memo");
     sm.deletePair("kmm-match-split");
     tm.modifySplit(sm);
 
     MyMoneyFile::instance()->modifyTransaction(tm);
     MyMoneyFile::instance()->addTransaction(ti);
   }
 }
 
 void TransactionMatcher::accept(const MyMoneyTransaction& _t, const MyMoneySplit& _s)
 {
   if (_s.isMatched()) {
     MyMoneyTransaction tm(_t);
     MyMoneySplit sm(_s);
     sm.removeMatch();
     sm.deletePair("kmm-orig-postdate");
     sm.deletePair("kmm-orig-payee");
     sm.deletePair("kmm-orig-memo");
     sm.deletePair("kmm-match-split");
     tm.modifySplit(sm);
 
     MyMoneyFile::instance()->modifyTransaction(tm);
   }
 }
diff --git a/kmymoney/kmymoney.cpp b/kmymoney/kmymoney.cpp
index 154bbd561..92bb2c390 100644
--- a/kmymoney/kmymoney.cpp
+++ b/kmymoney/kmymoney.cpp
@@ -1,4316 +1,4316 @@
 /***************************************************************************
                           kmymoney.cpp
                              -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                            (C) 2007 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017, 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ****************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 <config-kmymoney.h>
 
 #include "kmymoney.h"
 
 // ----------------------------------------------------------------------------
 // Std C++ / STL Includes
 
 #include <typeinfo>
 #include <iostream>
 #include <memory>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDir>
 #include <QDateTime>         // only for performance tests
 #include <QTimer>
 #include <QByteArray>
 #include <QBoxLayout>
 #include <QLabel>
 #include <QMenu>
 #include <QProgressBar>
 #include <QList>
 #include <QUrl>
 #include <QClipboard>
 #include <QKeySequence>
 #include <QIcon>
 #include <QInputDialog>
 #include <QStatusBar>
 #include <QPushButton>
 #include <QListWidget>
 #include <QApplication>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KToolBar>
 #include <KMessageBox>
 #include <KLocalizedString>
 #include <KConfig>
 #include <KStandardAction>
 #include <KActionCollection>
 #include <KTipDialog>
 #include <KRun>
 #include <KConfigDialog>
 #include <KXMLGUIFactory>
 #include <KRecentFilesAction>
 #include <KRecentDirs>
 #include <KProcess>
 #include <KAboutApplicationDialog>
 #include <KIO/StoredTransferJob>
 #include <KJobWidgets>
 #include <KCompressionDevice>
 #include <KBackup>
 #ifdef KF5Holidays_FOUND
 #include <KHolidays/Holiday>
 #include <KHolidays/HolidayRegion>
 #endif
 #ifdef KF5Activities_FOUND
 #include <KActivities/ResourceInstance>
 #endif
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneysettings.h"
 #include "kmymoneyadaptor.h"
 
 #include "dialogs/settings/ksettingskmymoney.h"
 #include "dialogs/kbackupdlg.h"
 #include "dialogs/kenterscheduledlg.h"
 #include "dialogs/kconfirmmanualenterdlg.h"
 #include "dialogs/kmymoneypricedlg.h"
 #include "dialogs/kcurrencyeditdlg.h"
 #include "dialogs/kequitypriceupdatedlg.h"
 #include "dialogs/kmymoneyfileinfodlg.h"
 #include "dialogs/knewbankdlg.h"
 #include "wizards/newinvestmentwizard/knewinvestmentwizard.h"
 #include "dialogs/knewaccountdlg.h"
 #include "dialogs/editpersonaldatadlg.h"
 #include "dialogs/kcurrencycalculator.h"
 #include "dialogs/keditscheduledlg.h"
 #include "wizards/newloanwizard/keditloanwizard.h"
 #include "dialogs/kpayeereassigndlg.h"
 #include "dialogs/kcategoryreassigndlg.h"
 #include "wizards/endingbalancedlg/kendingbalancedlg.h"
 #include "dialogs/kbalancechartdlg.h"
 #include "dialogs/kloadtemplatedlg.h"
 #include "dialogs/kgpgkeyselectiondlg.h"
 #include "dialogs/ktemplateexportdlg.h"
 #include "dialogs/transactionmatcher.h"
 #include "wizards/newuserwizard/knewuserwizard.h"
 #include "wizards/newaccountwizard/knewaccountwizard.h"
 #include "dialogs/kbalancewarning.h"
 #include "widgets/kmymoneyaccountselector.h"
 #include "widgets/kmymoneypayeecombo.h"
 #include "widgets/amountedit.h"
 #include "widgets/kmymoneyedit.h"
 #include "widgets/kmymoneymvccombo.h"
 
 #include "views/kmymoneyview.h"
 #include "models/models.h"
 #include "models/accountsmodel.h"
 #include "models/equitiesmodel.h"
 #include "models/securitiesmodel.h"
 
 #include "mymoney/mymoneyobject.h"
 #include "mymoney/mymoneyfile.h"
 #include "mymoney/mymoneyinstitution.h"
 #include "mymoney/mymoneyaccount.h"
 #include "mymoney/mymoneyaccountloan.h"
 #include "mymoney/mymoneysecurity.h"
 #include "mymoney/mymoneypayee.h"
 #include "mymoney/mymoneyprice.h"
 #include "mymoney/mymoneytag.h"
 #include "mymoney/mymoneybudget.h"
 #include "mymoney/mymoneyreport.h"
 #include "mymoney/mymoneysplit.h"
 #include "mymoney/mymoneyutils.h"
 #include "mymoney/mymoneystatement.h"
 #include "mymoney/mymoneyforecast.h"
 #include "mymoney/mymoneytransactionfilter.h"
 
 
 #include "converter/mymoneystatementreader.h"
 #include "converter/mymoneytemplate.h"
 
 #include "plugins/interfaces/kmmappinterface.h"
 #include "plugins/interfaces/kmmviewinterface.h"
 #include "plugins/interfaces/kmmstatementinterface.h"
 #include "plugins/interfaces/kmmimportinterface.h"
 #include "plugins/interfaceloader.h"
 #include "plugins/onlinepluginextended.h"
 #include "pluginloader.h"
 
 #include "tasks/credittransfer.h"
 
 #include "icons/icons.h"
 
 #include "misc/webconnect.h"
 
 #include "storage/mymoneystoragemgr.h"
 #include "storage/mymoneystoragexml.h"
 #include "storage/mymoneystoragebin.h"
 #include "storage/mymoneystorageanon.h"
 
 #include <libkgpgfile/kgpgfile.h>
 
 #include "transactioneditor.h"
 #include <QHBoxLayout>
 #include <QFileDialog>
 
 #include "kmymoneyutils.h"
 #include "kcreditswindow.h"
 
 #include "ledgerdelegate.h"
 #include "storageenums.h"
 #include "mymoneyenums.h"
 #include "dialogenums.h"
 #include "viewenums.h"
 #include "menuenums.h"
 
 #include "misc/platformtools.h"
 
 #ifdef KMM_DEBUG
 #include "mymoney/storage/mymoneystoragedump.h"
 #include "mymoneytracer.h"
 #endif
 
 using namespace Icons;
 using namespace eMenu;
 
 static constexpr KCompressionDevice::CompressionType const& COMPRESSION_TYPE = KCompressionDevice::GZip;
 static constexpr char recoveryKeyId[] = "0xD2B08440";
 static constexpr char recoveryKeyId2[] = "59B0F826D2B08440";
 
 // define the default period to warn about an expiring recoverkey to 30 days
 // but allows to override this setting during build time
 #ifndef RECOVER_KEY_EXPIRATION_WARNING
 #define RECOVER_KEY_EXPIRATION_WARNING 30
 #endif
 
 enum backupStateE {
   BACKUP_IDLE = 0,
   BACKUP_MOUNTING,
   BACKUP_COPYING,
   BACKUP_UNMOUNTING
 };
 
 class KMyMoneyApp::Private
 {
 public:
   Private(KMyMoneyApp *app) :
       q(app),
       m_statementXMLindex(0),
       m_balanceWarning(0),
       m_backupState(backupStateE::BACKUP_IDLE),
       m_backupResult(0),
       m_backupMount(0),
       m_ignoreBackupExitCode(false),
       m_fileOpen(false),
       m_fmode(QFileDevice::ReadUser | QFileDevice::WriteUser),
       m_fileType(KMyMoneyApp::KmmXML),
       m_myMoneyView(nullptr),
       m_startDialog(false),
       m_progressBar(nullptr),
       m_statusLabel(nullptr),
       m_autoSaveEnabled(true),
       m_autoSaveTimer(nullptr),
       m_progressTimer(nullptr),
       m_autoSavePeriod(0),
       m_inAutoSaving(false),
       m_saveEncrypted(nullptr),
       m_additionalKeyLabel(nullptr),
       m_additionalKeyButton(nullptr),
       m_recentFiles(nullptr),
 #ifdef KF5Holidays_FOUND
       m_holidayRegion(nullptr),
 #endif
 #ifdef KF5Activities_FOUND
       m_activityResourceInstance(nullptr),
 #endif
       m_applicationIsReady(true),
       m_webConnect(new WebConnect(app)) {
     // since the days of the week are from 1 to 7,
     // and a day of the week is used to index this bit array,
     // resize the array to 8 elements (element 0 is left unused)
     m_processingDays.resize(8);
 
   }
 
   void closeFile();
   void unlinkStatementXML();
   void moveInvestmentTransaction(const QString& fromId,
                                  const QString& toId,
                                  const MyMoneyTransaction& t);
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > automaticReconciliation(const MyMoneyAccount &account,
       const QList<QPair<MyMoneyTransaction, MyMoneySplit> > &transactions,
       const MyMoneyMoney &amount);
 
 
   /**
     * The public interface.
     */
   KMyMoneyApp * const q;
 
   int                           m_statementXMLindex;
   KBalanceWarning*              m_balanceWarning;
 
   /** the configuration object of the application */
   KSharedConfigPtr m_config;
 
   /**
    * @brief Structure of plugins objects by their interfaces
    */
   KMyMoneyPlugin::Container m_plugins;
 
   /**
     * The following variable represents the state while crafting a backup.
     * It can have the following values
     *
     * - IDLE: the default value if not performing a backup
     * - MOUNTING: when a mount command has been issued
     * - COPYING:  when a copy command has been issued
     * - UNMOUNTING: when an unmount command has been issued
     */
   backupStateE   m_backupState;
 
   /**
     * This variable keeps the result of the backup operation.
     */
   int     m_backupResult;
 
   /**
     * This variable is set, when the user selected to mount/unmount
     * the backup volume.
     */
   bool    m_backupMount;
 
   /**
     * Flag for internal run control
     */
   bool    m_ignoreBackupExitCode;
 
   bool m_fileOpen;
   QFileDevice::Permissions m_fmode;
 
   KMyMoneyApp::fileTypeE m_fileType;
 
   KProcess m_proc;
 
   /// A pointer to the view holding the tabs.
   KMyMoneyView *m_myMoneyView;
 
   /// The URL of the file currently being edited when open.
   QUrl  m_fileName;
 
   bool m_startDialog;
   QString m_mountpoint;
 
   QProgressBar* m_progressBar;
   QTime         m_lastUpdate;
   QLabel*       m_statusLabel;
 
   // allows multiple imports to be launched trough web connect and to be executed sequentially
   QQueue<QString> m_importUrlsQueue;
 
   // This is Auto Saving related
   bool                  m_autoSaveEnabled;
   QTimer*               m_autoSaveTimer;
   QTimer*               m_progressTimer;
   int                   m_autoSavePeriod;
   bool                  m_inAutoSaving;
 
   // Pointer to the combo box used for key selection during
   // File/Save as
   KComboBox*            m_saveEncrypted;
 
   // id's that need to be remembered
   QString               m_accountGoto, m_payeeGoto;
 
   QStringList           m_additionalGpgKeys;
   QLabel*               m_additionalKeyLabel;
   QPushButton*          m_additionalKeyButton;
 
   KRecentFilesAction*   m_recentFiles;
 
 #ifdef KF5Holidays_FOUND
   // used by the calendar interface for schedules
   KHolidays::HolidayRegion* m_holidayRegion;
 #endif
 
 #ifdef KF5Activities_FOUND
   KActivities::ResourceInstance * m_activityResourceInstance;
 #endif
 
   QBitArray             m_processingDays;
   QMap<QDate, bool>     m_holidayMap;
   QStringList           m_consistencyCheckResult;
   bool                  m_applicationIsReady;
 
   WebConnect*           m_webConnect;
 
   // methods
   void consistencyCheck(bool alwaysDisplayResults);
   static void setThemedCSS();
   void copyConsistencyCheckResults();
   void saveConsistencyCheckResults();
 
   void checkAccountName(const MyMoneyAccount& _acc, const QString& name) const
   {
     auto file = MyMoneyFile::instance();
     if (_acc.name() != name) {
       MyMoneyAccount acc(_acc);
       acc.setName(name);
       file->modifyAccount(acc);
     }
   }
 
   /**
     * This method updates names of currencies from file to localized names
     */
   void updateCurrencyNames()
   {
     auto file = MyMoneyFile::instance();
     MyMoneyFileTransaction ft;
 
     QList<MyMoneySecurity> storedCurrencies = MyMoneyFile::instance()->currencyList();
     QList<MyMoneySecurity> availableCurrencies = MyMoneyFile::instance()->availableCurrencyList();
     QStringList currencyIDs;
 
     foreach (auto currency, availableCurrencies)
       currencyIDs.append(currency.id());
 
     try {
       foreach (auto currency, storedCurrencies) {
         int i = currencyIDs.indexOf(currency.id());
         if (i != -1 && availableCurrencies.at(i).name() != currency.name()) {
           currency.setName(availableCurrencies.at(i).name());
           file->modifyCurrency(currency);
         }
       }
       ft.commit();
     } catch (const MyMoneyException &e) {
-      qDebug("Error %s updating currency names", qPrintable(e.what()));
+      qDebug("Error %s updating currency names", e.what());
     }
   }
 
   void updateAccountNames()
   {
     // make sure we setup the name of the base accounts in translated form
     try {
       MyMoneyFileTransaction ft;
       const auto file = MyMoneyFile::instance();
       checkAccountName(file->asset(), i18n("Asset"));
       checkAccountName(file->liability(), i18n("Liability"));
       checkAccountName(file->income(), i18n("Income"));
       checkAccountName(file->expense(), i18n("Expense"));
       checkAccountName(file->equity(), i18n("Equity"));
       ft.commit();
     } catch (const MyMoneyException &) {
     }
   }
 
   void ungetString(QIODevice *qfile, char *buf, int len)
   {
     buf = &buf[len-1];
     while (len--) {
       qfile->ungetChar(*buf--);
     }
   }
 
   bool applyFileFixes()
   {
     const auto blocked = MyMoneyFile::instance()->blockSignals(true);
     KSharedConfigPtr config = KSharedConfig::openConfig();
 
     KConfigGroup grp = config->group("General Options");
 
     // For debugging purposes, we can turn off the automatic fix manually
     // by setting the entry in kmymoneyrc to true
     grp = config->group("General Options");
     if (grp.readEntry("SkipFix", false) != true) {
       MyMoneyFileTransaction ft;
       try {
         // Check if we have to modify the file before we allow to work with it
         auto s = MyMoneyFile::instance()->storage();
         while (s->fileFixVersion() < s->currentFixVersion()) {
           qDebug("%s", qPrintable((QString("testing fileFixVersion %1 < %2").arg(s->fileFixVersion()).arg(s->currentFixVersion()))));
           switch (s->fileFixVersion()) {
             case 0:
               fixFile_0();
               s->setFileFixVersion(1);
               break;
 
             case 1:
               fixFile_1();
               s->setFileFixVersion(2);
               break;
 
             case 2:
               fixFile_2();
               s->setFileFixVersion(3);
               break;
 
             case 3:
               fixFile_3();
               s->setFileFixVersion(4);
               break;
 
               // add new levels above. Don't forget to increase currentFixVersion() for all
               // the storage backends this fix applies to
             default:
-              throw MYMONEYEXCEPTION(i18n("Unknown fix level in input file"));
+              throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown fix level in input file"));
           }
         }
         ft.commit();
       } catch (const MyMoneyException &) {
         MyMoneyFile::instance()->blockSignals(blocked);
         return false;
       }
     } else {
       qDebug("Skipping automatic transaction fix!");
     }
     MyMoneyFile::instance()->blockSignals(blocked);
     return true;
   }
 
   void connectStorageToModels()
   {
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectAdded);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectModified);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectRemoved);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->accountsModel(), &AccountsModel::slotBalanceOrValueChanged);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->accountsModel(), &AccountsModel::slotBalanceOrValueChanged);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectAdded);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectModified);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectRemoved);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->institutionsModel(), &AccountsModel::slotBalanceOrValueChanged);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->institutionsModel(), &AccountsModel::slotBalanceOrValueChanged);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectAdded);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectModified);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectRemoved);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->equitiesModel(), &EquitiesModel::slotBalanceOrValueChanged);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->equitiesModel(), &EquitiesModel::slotBalanceOrValueChanged);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectAdded);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectModified);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectRemoved);
   }
 
   void disconnectStorageFromModels()
   {
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectAdded);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectModified);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->accountsModel(), &AccountsModel::slotObjectRemoved);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->accountsModel(), &AccountsModel::slotBalanceOrValueChanged);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->accountsModel(), &AccountsModel::slotBalanceOrValueChanged);
 
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectAdded);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectModified);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->institutionsModel(), &InstitutionsModel::slotObjectRemoved);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->institutionsModel(), &AccountsModel::slotBalanceOrValueChanged);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->institutionsModel(), &AccountsModel::slotBalanceOrValueChanged);
 
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectAdded);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectModified);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->equitiesModel(), &EquitiesModel::slotObjectRemoved);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::balanceChanged,
                Models::instance()->equitiesModel(), &EquitiesModel::slotBalanceOrValueChanged);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::valueChanged,
                Models::instance()->equitiesModel(), &EquitiesModel::slotBalanceOrValueChanged);
 
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectAdded,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectAdded);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectModified,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectModified);
     q->disconnect(MyMoneyFile::instance(), &MyMoneyFile::objectRemoved,
                Models::instance()->securitiesModel(), &SecuritiesModel::slotObjectRemoved);
   }
 
   /**
    * This method is used after a file or database has been
    * read into storage, and performs various initialization tasks
    *
    * @retval true all went okay
    * @retval false an exception occurred during this process
    */
   bool initializeStorage()
   {
     const auto blocked = MyMoneyFile::instance()->blockSignals(true);
 
     updateAccountNames();
     updateCurrencyNames();
     selectBaseCurrency();
 
     // setup the standard precision
     AmountEdit::setStandardPrecision(MyMoneyMoney::denomToPrec(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction()));
     KMyMoneyEdit::setStandardPrecision(MyMoneyMoney::denomToPrec(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction()));
 
     if (!applyFileFixes())
       return false;
 
     MyMoneyFile::instance()->blockSignals(blocked);
 
     emit q->kmmFilePlugin(KMyMoneyApp::postOpen);
 
     Models::instance()->fileOpened();
     connectStorageToModels();
 
     // inform everyone about new data
     MyMoneyFile::instance()->forceDataChanged();
 
     q->slotCheckSchedules();
 
     m_myMoneyView->slotFileOpened();
 
     onlineJobAdministration::instance()->updateActions();
     return true;
   }
 
   /**
     * This method attaches an empty storage object to the MyMoneyFile
     * object. It calls removeStorage() to remove a possibly attached
     * storage object.
     */
   void newStorage()
   {
     removeStorage();
     auto file = MyMoneyFile::instance();
     file->attachStorage(new MyMoneyStorageMgr);
   }
 
   /**
     * This method removes an attached storage from the MyMoneyFile
     * object.
     */
   void removeStorage()
   {
     auto file = MyMoneyFile::instance();
     auto p = file->storage();
     if (p) {
       file->detachStorage(p);
       delete p;
     }
   }
 
   /**
     * if no base currency is defined, start the dialog and force it to be set
     */
   void selectBaseCurrency()
   {
     auto file = MyMoneyFile::instance();
 
     // check if we have a base currency. If not, we need to select one
     QString baseId;
     try {
       baseId = MyMoneyFile::instance()->baseCurrency().id();
     } catch (const MyMoneyException &e) {
-      qDebug("%s", qPrintable(e.what()));
+      qDebug("%s", e.what());
     }
 
     if (baseId.isEmpty()) {
       QPointer<KCurrencyEditDlg> dlg = new KCurrencyEditDlg(q);
   //    connect(dlg, SIGNAL(selectBaseCurrency(MyMoneySecurity)), this, SLOT(slotSetBaseCurrency(MyMoneySecurity)));
       dlg->exec();
       delete dlg;
     }
 
     try {
       baseId = MyMoneyFile::instance()->baseCurrency().id();
     } catch (const MyMoneyException &e) {
-      qDebug("%s", qPrintable(e.what()));
+      qDebug("%s", e.what());
     }
 
     if (!baseId.isEmpty()) {
       // check that all accounts have a currency
       QList<MyMoneyAccount> list;
       file->accountList(list);
       QList<MyMoneyAccount>::Iterator it;
 
       // don't forget those standard accounts
       list << file->asset();
       list << file->liability();
       list << file->income();
       list << file->expense();
       list << file->equity();
 
 
       for (it = list.begin(); it != list.end(); ++it) {
         QString cid;
         try {
           if (!(*it).currencyId().isEmpty() || (*it).currencyId().length() != 0)
             cid = MyMoneyFile::instance()->currency((*it).currencyId()).id();
-        } catch (const MyMoneyException& e) {
+        } catch (const MyMoneyException &e) {
           qDebug() << QLatin1String("Account") << (*it).id() << (*it).name() << e.what();
         }
 
         if (cid.isEmpty()) {
           (*it).setCurrencyId(baseId);
           MyMoneyFileTransaction ft;
           try {
             file->modifyAccount(*it);
             ft.commit();
           } catch (const MyMoneyException &e) {
-            qDebug("Unable to setup base currency in account %s (%s): %s", qPrintable((*it).name()), qPrintable((*it).id()), qPrintable(e.what()));
+            qDebug("Unable to setup base currency in account %s (%s): %s", qPrintable((*it).name()), qPrintable((*it).id()), e.what());
           }
         }
       }
     }
   }
 
   /**
     * Calls MyMoneyFile::readAllData which reads a MyMoneyFile into appropriate
     * data structures in memory.  The return result is examined to make sure no
     * errors occurred whilst parsing.
     *
     * @param url The URL to read from.
     *            If no protocol is specified, file:// is assumed.
     *
     * @return Whether the read was successful.
     */
   bool openNondatabase(const QUrl &url)
   {
     if (!url.isValid())
       throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid URL %1").arg(qPrintable(url.url())));
 
     QString fileName;
     auto downloadedFile = false;
     if (url.isLocalFile()) {
       fileName = url.toLocalFile();
     } else {
       fileName = KMyMoneyUtils::downloadFile(url);
       downloadedFile = true;
     }
 
     if (!KMyMoneyUtils::fileExists(QUrl::fromLocalFile(fileName)))
       throw MYMONEYEXCEPTION(QString::fromLatin1("Error opening the file.\n"
                                                  "Requested file: '%1'.\n"
                                                  "Downloaded file: '%2'").arg(qPrintable(url.url()), fileName));
 
 
     QFile file(fileName);
     if (!file.open(QIODevice::ReadOnly))
       throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot read the file: %1").arg(fileName));
 
     QByteArray qbaFileHeader(2, '\0');
     const auto sFileToShort = QString::fromLatin1("File %1 is too short.").arg(fileName);
     if (file.read(qbaFileHeader.data(), 2) != 2)
       throw MYMONEYEXCEPTION(sFileToShort);
 
     file.close();
 
     // There's a problem with the KFilterDev and KGPGFile classes:
     // One supports the at(n) member but not ungetch() together with
     // read() and the other does not provide an at(n) method but
     // supports read() that considers the ungetch() buffer. QFile
     // supports everything so this is not a problem. We solve the problem
     // for now by keeping track of which method can be used.
     auto haveAt = true;
     auto isEncrypted = false;
 
     emit q->kmmFilePlugin(preOpen);
 
     QIODevice* qfile = nullptr;
     QString sFileHeader(qbaFileHeader);
     if (sFileHeader == QString("\037\213")) {        // gzipped?
       qfile = new KCompressionDevice(fileName, COMPRESSION_TYPE);
     } else if (sFileHeader == QString("--") ||        // PGP ASCII armored?
                sFileHeader == QString("\205\001") ||  // PGP binary?
                sFileHeader == QString("\205\002")) {  // PGP binary?
       if (KGPGFile::GPGAvailable()) {
         qfile = new KGPGFile(fileName);
         haveAt = false;
         isEncrypted = true;
       } else {
-        throw MYMONEYEXCEPTION(QString::fromLatin1("%1").arg(i18n("GPG is not available for decryption of file <b>%1</b>", fileName)));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("GPG is not available for decryption of file <b>%1</b>").arg(fileName));
       }
     } else {
       // we can't use file directly, as we delete qfile later on
       qfile = new QFile(file.fileName());
     }
 
     if (!qfile->open(QIODevice::ReadOnly)) {
       delete qfile;
       throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot read the file: %1").arg(fileName));
     }
 
     qbaFileHeader.resize(8);
     if (qfile->read(qbaFileHeader.data(), 8) != 8)
       throw MYMONEYEXCEPTION(sFileToShort);
 
     if (haveAt)
       qfile->seek(0);
     else
       ungetString(qfile, qbaFileHeader.data(), 8);
 
     // Ok, we got the first block of 8 bytes. Read in the two
     // unsigned long int's by preserving endianess. This is
     // achieved by reading them through a QDataStream object
     qint32 magic0, magic1;
     QDataStream s(&qbaFileHeader, QIODevice::ReadOnly);
     s >> magic0;
     s >> magic1;
 
     // If both magic numbers match (we actually read in the
     // text 'KMyMoney' then we assume a binary file and
     // construct a reader for it. Otherwise, we construct
     // an XML reader object.
     //
     // The expression magic0 < 30 is only used to create
     // a binary reader if we assume an old binary file. This
     // should be removed at some point. An alternative is to
     // check the beginning of the file against an pattern
     // of the XML file (e.g. '?<xml' ).
     if ((magic0 == MAGIC_0_50 && magic1 == MAGIC_0_51) ||
         magic0 < 30) {
       // we do not support this file format anymore
-      throw MYMONEYEXCEPTION(QString::fromLatin1("<qt>%1</qt>").arg(i18n("File <b>%1</b> contains the old binary format used by KMyMoney. Please use an older version of KMyMoney (0.8.x) that still supports this format to convert it to the new XML based format.", fileName)));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("<qt>File <b>%1</b> contains the old binary format used by KMyMoney. Please use an older version of KMyMoney (0.8.x) that still supports this format to convert it to the new XML based format.</qt>").arg(fileName));
     }
 
     // Scan the first 70 bytes to see if we find something
     // we know. For now, we support our own XML format and
     // GNUCash XML format. If the file is smaller, then it
     // contains no valid data and we reject it anyway.
     qbaFileHeader.resize(70);
     if (qfile->read(qbaFileHeader.data(), 70) != 70)
       throw MYMONEYEXCEPTION(sFileToShort);
 
     if (haveAt)
       qfile->seek(0);
     else
       ungetString(qfile, qbaFileHeader.data(), 70);
 
     IMyMoneyOperationsFormat* pReader = nullptr;
     QRegExp kmyexp("<!DOCTYPE KMYMONEY-FILE>");
     QRegExp gncexp("<gnc-v(\\d+)");
     QByteArray txt(qbaFileHeader, 70);
     if (kmyexp.indexIn(txt) != -1) {
       pReader = new MyMoneyStorageXML;
       m_fileType = KMyMoneyApp::KmmXML;
     } else if (gncexp.indexIn(txt) != -1) {
 
       for (const auto& plugin : m_plugins.storage) {
         if (plugin->formatName().compare(QLatin1String("GNC")) == 0) {
           pReader = plugin->reader();
           break;
         }
       }
       if (!pReader) {
         KMessageBox::error(q, i18n("Couldn't find suitable plugin to read your storage."));
         return false;
       }
       m_fileType = KMyMoneyApp::GncXML;
     } else {
       throw MYMONEYEXCEPTION(QString::fromLatin1("<qt>%1</qt>").arg(i18n("File <b>%1</b> contains an unknown file format.", fileName)));
     }
 
     // disconnect the current storga manager from the engine
     MyMoneyFile::instance()->detachStorage();
 
     // create a new empty storage object
     auto storage = new MyMoneyStorageMgr;
 
     // attach the storage before reading the file, since the online
     // onlineJobAdministration object queries the engine during
     // loading.
     MyMoneyFile::instance()->attachStorage(storage);
 
     pReader->setProgressCallback(&KMyMoneyApp::progressCallback);
     pReader->readFile(qfile, storage);
     pReader->setProgressCallback(0);
     delete pReader;
 
     qfile->close();
     delete qfile;
 
     // if a temporary file was downloaded, then it will be removed
     // with the next call. Otherwise, it stays untouched on the local
     // filesystem.
     if (downloadedFile)
       QFile::remove(fileName);
 
     // encapsulate transactions to the engine to be able to commit/rollback
     MyMoneyFileTransaction ft;
     // make sure we setup the encryption key correctly
     if (isEncrypted && MyMoneyFile::instance()->value("kmm-encryption-key").isEmpty())
       MyMoneyFile::instance()->setValue("kmm-encryption-key", KMyMoneySettings::gpgRecipientList().join(","));
     ft.commit();
     return true;
   }
 
   /**
    * This method is called from readFile to open a database file which
    * is to be processed in 'proper' database mode, i.e. in-place updates
    *
    * @param dbaseURL pseudo-QUrl representation of database
    *
    * @retval true Database opened successfully
    * @retval false Could not open or read database
    */
   bool openDatabase(const QUrl &url)
   {
     // open the database
     auto pStorage = MyMoneyFile::instance()->storage();
     if (!pStorage)
       pStorage = new MyMoneyStorageMgr;
 
     auto rc = false;
     auto pluginFound = false;
     for (const auto& plugin : m_plugins.storage) {
       if (plugin->formatName().compare(QLatin1String("SQL")) == 0) {
         rc = plugin->open(pStorage, url);
         pluginFound = true;
         break;
       }
     }
 
     if(!pluginFound)
       KMessageBox::error(q, i18n("Couldn't find suitable plugin to read your storage."));
 
     if(!rc) {
       removeStorage();
       delete pStorage;
       return false;
     }
 
     if (pStorage) {
       MyMoneyFile::instance()->detachStorage();
       MyMoneyFile::instance()->attachStorage(pStorage);
     }
     return true;
   }
 
   /**
     * Close the currently opened file and create an empty new file.
     *
     * @see MyMoneyFile
     */
   void newFile()
   {
     closeFile();
     m_fileType = KMyMoneyApp::KmmXML; // assume native type until saved
     m_fileOpen = true;
   }
 
   /**
     * Saves the data into permanent storage using the XML format.
     *
     * @param url The URL to save into.
     *            If no protocol is specified, file:// is assumed.
     * @param keyList QString containing a comma separated list of keys
     *            to be used for encryption. If @p keyList is empty,
     *            the file will be saved unencrypted (the default)
     *
     * @retval false save operation failed
     * @retval true save operation was successful
     */
   bool saveFile(const QUrl &url, const QString& keyList = QString())
   {
     QString filename = url.path();
 
     if (!m_fileOpen) {
       KMessageBox::error(q, i18n("Tried to access a file when it has not been opened"));
       return false;
     }
 
     emit q->kmmFilePlugin(KMyMoneyApp::preSave);
     std::unique_ptr<IMyMoneyOperationsFormat> storageWriter;
 
     // If this file ends in ".ANON.XML" then this should be written using the
     // anonymous writer.
     bool plaintext = filename.right(4).toLower() == ".xml";
     if (filename.right(9).toLower() == ".anon.xml")
       storageWriter = std::make_unique<MyMoneyStorageANON>();
     else
       storageWriter = std::make_unique<MyMoneyStorageXML>();
 
     // actually, url should be the parameter to this function
     // but for now, this would involve too many changes
     auto rc = true;
     try {
       if (! url.isValid()) {
-        throw MYMONEYEXCEPTION(i18n("Malformed URL '%1'", url.url()));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("Malformed URL '%1'").arg(url.url()));
       }
 
       if (url.scheme() == QLatin1String("sql")) {
           rc = false;
           auto pluginFound = false;
           for (const auto& plugin : m_plugins.storage) {
               if (plugin->formatName().compare(QLatin1String("SQL")) == 0) {
                   rc = plugin->save(url);
                   pluginFound = true;
                   break;
                 }
             }
 
           if(!pluginFound)
-            throw MYMONEYEXCEPTION(i18n("Couldn't find suitable plugin to save your storage."));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Couldn't find suitable plugin to save your storage."));
 
         } else if (url.isLocalFile()) {
           filename = url.toLocalFile();
           try {
             const unsigned int nbak = KMyMoneySettings::autoBackupCopies();
             if (nbak) {
                 KBackup::numberedBackupFile(filename, QString(), QStringLiteral("~"), nbak);
               }
             saveToLocalFile(filename, storageWriter.get(), plaintext, keyList);
           } catch (const MyMoneyException &) {
-            throw MYMONEYEXCEPTION(i18n("Unable to write changes to '%1'", filename));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to write changes to '%1'").arg(filename));
           }
         } else {
 
           QTemporaryFile tmpfile;
           tmpfile.open(); // to obtain the name
           tmpfile.close();
           saveToLocalFile(tmpfile.fileName(), storageWriter.get(), plaintext, keyList);
 
           Q_CONSTEXPR int permission = -1;
           QFile file(tmpfile.fileName());
           file.open(QIODevice::ReadOnly);
           KIO::StoredTransferJob *putjob = KIO::storedPut(file.readAll(), url, permission, KIO::JobFlag::Overwrite);
           if (!putjob->exec()) {
-              throw MYMONEYEXCEPTION(i18n("Unable to upload to '%1'.<br />%2", url.toDisplayString(), putjob->errorString()));
+              throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to upload to '%1'.<br />%2").arg(url.toDisplayString(), putjob->errorString()));
             }
           file.close();
         }
       m_fileType = KMyMoneyApp::KmmXML;
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(q, e.what());
+      KMessageBox::error(q, QString::fromLatin1(e.what()));
       MyMoneyFile::instance()->setDirty();
       rc = false;
     }
     emit q->kmmFilePlugin(postSave);
     return rc;
   }
 
   /**
     * This method is used by saveFile() to store the data
     * either directly in the destination file if it is on
     * the local file system or in a temporary file when
     * the final destination is reached over a network
     * protocol (e.g. FTP)
     *
     * @param localFile the name of the local file
     * @param writer pointer to the formatter
     * @param plaintext whether to override any compression & encryption settings
     * @param keyList QString containing a comma separated list of keys to be used for encryption
     *            If @p keyList is empty, the file will be saved unencrypted
     *
     * @note This method will close the file when it is written.
     */
   void saveToLocalFile(const QString& localFile, IMyMoneyOperationsFormat* pWriter, bool plaintext, const QString& keyList)
   {
     // Check GPG encryption
     bool encryptFile = true;
     bool encryptRecover = false;
     if (!keyList.isEmpty()) {
       if (!KGPGFile::GPGAvailable()) {
         KMessageBox::sorry(q, i18n("GPG does not seem to be installed on your system. Please make sure that GPG can be found using the standard search path. This time, encryption is disabled."), i18n("GPG not found"));
         encryptFile = false;
       } else {
         if (KMyMoneySettings::encryptRecover()) {
           encryptRecover = true;
           if (!KGPGFile::keyAvailable(QString(recoveryKeyId))) {
             KMessageBox::sorry(q, i18n("<p>You have selected to encrypt your data also with the KMyMoney recover key, but the key with id</p><p><center><b>%1</b></center></p><p>has not been found in your keyring at this time. Please make sure to import this key into your keyring. You can find it on the <a href=\"https://kmymoney.org/\">KMyMoney web-site</a>. This time your data will not be encrypted with the KMyMoney recover key.</p>", QString(recoveryKeyId)), i18n("GPG Key not found"));
             encryptRecover = false;
           }
         }
 
         for(const QString& key: keyList.split(',', QString::SkipEmptyParts)) {
           if (!KGPGFile::keyAvailable(key)) {
             KMessageBox::sorry(q, i18n("<p>You have specified to encrypt your data for the user-id</p><p><center><b>%1</b>.</center></p><p>Unfortunately, a valid key for this user-id was not found in your keyring. Please make sure to import a valid key for this user-id. This time, encryption is disabled.</p>", key), i18n("GPG Key not found"));
             encryptFile = false;
             break;
           }
         }
 
         if (encryptFile == true) {
           QString msg = i18n("<p>You have configured to save your data in encrypted form using GPG. Make sure you understand that you might lose all your data if you encrypt it, but cannot decrypt it later on. If unsure, answer <b>No</b>.</p>");
           if (KMessageBox::questionYesNo(q, msg, i18n("Store GPG encrypted"), KStandardGuiItem::yes(), KStandardGuiItem::no(), "StoreEncrypted") == KMessageBox::No) {
             encryptFile = false;
           }
         }
       }
     }
 
 
     // Create a temporary file if needed
     QString writeFile = localFile;
     QTemporaryFile tmpFile;
     if (QFile::exists(localFile)) {
       tmpFile.open();
       writeFile = tmpFile.fileName();
       tmpFile.close();
     }
 
     /**
      * @brief Automatically restore settings when scope is left
      */
     struct restorePreviousSettingsHelper {
       restorePreviousSettingsHelper()
         : m_signalsWereBlocked{MyMoneyFile::instance()->signalsBlocked()}
       {
         MyMoneyFile::instance()->blockSignals(true);
       }
 
       ~restorePreviousSettingsHelper()
       {
         MyMoneyFile::instance()->blockSignals(m_signalsWereBlocked);
       }
       const bool m_signalsWereBlocked;
     } restoreHelper;
 
     MyMoneyFileTransaction ft;
     MyMoneyFile::instance()->deletePair("kmm-encryption-key");
     std::unique_ptr<QIODevice> device;
 
     if (!keyList.isEmpty() && encryptFile && !plaintext) {
       std::unique_ptr<KGPGFile> kgpg = std::unique_ptr<KGPGFile>(new KGPGFile{writeFile});
       if (kgpg) {
         for(const QString& key: keyList.split(',', QString::SkipEmptyParts)) {
           kgpg->addRecipient(key.toLatin1());
         }
 
         if (encryptRecover) {
           kgpg->addRecipient(recoveryKeyId);
         }
         MyMoneyFile::instance()->setValue("kmm-encryption-key", keyList);
         device = std::unique_ptr<decltype(device)::element_type>(kgpg.release());
       }
     } else {
       QFile *file = new QFile(writeFile);
       // The second parameter of KCompressionDevice means that KCompressionDevice will delete the QFile object
       device = std::unique_ptr<decltype(device)::element_type>(new KCompressionDevice{file, true, (plaintext) ? KCompressionDevice::None : COMPRESSION_TYPE});
     }
 
     ft.commit();
 
     if (!device || !device->open(QIODevice::WriteOnly)) {
-      throw MYMONEYEXCEPTION(i18n("Unable to open file '%1' for writing.", localFile));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Unable to open file '%1' for writing.").arg(localFile));
     }
 
     pWriter->setProgressCallback(&KMyMoneyApp::progressCallback);
     pWriter->writeFile(device.get(), MyMoneyFile::instance()->storage());
     device->close();
 
     // Check for errors if possible, only possible for KGPGFile
     QFileDevice *fileDevice = qobject_cast<QFileDevice*>(device.get());
     if (fileDevice && fileDevice->error() != QFileDevice::NoError) {
-      throw MYMONEYEXCEPTION(i18n("Failure while writing to '%1'", localFile));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Failure while writing to '%1'").arg(localFile));
     }
 
     if (writeFile != localFile) {
       // This simple comparison is possible because the strings are equal if no temporary file was created.
       // If a temporary file was created, it is made in a way that the name is definitely different. So no
       // symlinks etc. have to be evaluated.
       if (!QFile::remove(localFile) || !QFile::rename(writeFile, localFile))
-        throw MYMONEYEXCEPTION(i18n("Failure while writing to '%1'", localFile));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("Failure while writing to '%1'").arg(localFile));
     }
     QFile::setPermissions(localFile, m_fmode);
     pWriter->setProgressCallback(0);
   }
 
   /**
     * Call this to see if the MyMoneyFile contains any unsaved data.
     *
     * @retval true if any data has been modified but not saved
     * @retval false otherwise
     */
   bool dirty()
   {
     if (!m_fileOpen)
       return false;
 
     return MyMoneyFile::instance()->dirty();
   }
 
 
   /* DO NOT ADD code to this function or any of it's called ones.
      Instead, create a new function, fixFile_n, and modify the initializeStorage()
      logic above to call it */
 
   void fixFile_3()
   {
     // make sure each storage object contains a (unique) id
     MyMoneyFile::instance()->storageId();
   }
 
   void fixFile_2()
   {
     auto file = MyMoneyFile::instance();
     MyMoneyTransactionFilter filter;
     filter.setReportAllSplits(false);
     QList<MyMoneyTransaction> transactionList;
     file->transactionList(transactionList, filter);
 
     // scan the transactions and modify transactions with two splits
     // which reference an account and a category to have the memo text
     // of the account.
     auto count = 0;
     foreach (const auto transaction, transactionList) {
       if (transaction.splitCount() == 2) {
         QString accountId;
         QString categoryId;
         QString accountMemo;
         QString categoryMemo;
         foreach (const auto split, transaction.splits()) {
           auto acc = file->account(split.accountId());
           if (acc.isIncomeExpense()) {
             categoryId = split.id();
             categoryMemo = split.memo();
           } else {
             accountId = split.id();
             accountMemo = split.memo();
           }
         }
 
         if (!accountId.isEmpty() && !categoryId.isEmpty()
             && accountMemo != categoryMemo) {
           MyMoneyTransaction t(transaction);
           MyMoneySplit s(t.splitById(categoryId));
           s.setMemo(accountMemo);
           t.modifySplit(s);
           file->modifyTransaction(t);
           ++count;
         }
       }
     }
     qDebug("%d transactions fixed in fixFile_2", count);
   }
 
   void fixFile_1()
   {
     // we need to fix reports. If the account filter list contains
     // investment accounts, we need to add the stock accounts to the list
     // as well if we don't have the expert mode enabled
     if (!KMyMoneySettings::expertMode()) {
       try {
         QList<MyMoneyReport> reports = MyMoneyFile::instance()->reportList();
         QList<MyMoneyReport>::iterator it_r;
         for (it_r = reports.begin(); it_r != reports.end(); ++it_r) {
           QStringList list;
           (*it_r).accounts(list);
           QStringList missing;
           QStringList::const_iterator it_a, it_b;
           for (it_a = list.constBegin(); it_a != list.constEnd(); ++it_a) {
             auto acc = MyMoneyFile::instance()->account(*it_a);
             if (acc.accountType() == eMyMoney::Account::Type::Investment) {
               foreach (const auto accountID, acc.accountList()) {
                 if (!list.contains(accountID)) {
                   missing.append(accountID);
                 }
               }
             }
           }
           if (!missing.isEmpty()) {
             (*it_r).addAccount(missing);
             MyMoneyFile::instance()->modifyReport(*it_r);
           }
         }
       } catch (const MyMoneyException &) {
       }
     }
   }
 
   #if 0
   if (!m_accountsView->allItemsSelected())
   {
     // retrieve a list of selected accounts
     QStringList list;
     m_accountsView->selectedItems(list);
 
     // if we're not in expert mode, we need to make sure
     // that all stock accounts for the selected investment
     // account are also selected
     if (!KMyMoneySettings::expertMode()) {
       QStringList missing;
       QStringList::const_iterator it_a, it_b;
       for (it_a = list.begin(); it_a != list.end(); ++it_a) {
         auto acc = MyMoneyFile::instance()->account(*it_a);
         if (acc.accountType() == Account::Type::Investment) {
           foreach (const auto accountID, acc.accountList()) {
             if (!list.contains(accountID)) {
               missing.append(accountID);
             }
           }
         }
       }
       list += missing;
     }
 
     m_filter.addAccount(list);
   }
 
   #endif
 
 
 
 
 
   void fixFile_0()
   {
     /* (Ace) I am on a crusade against file fixups.  Whenever we have to fix the
      * file, it is really a warning.  So I'm going to print a debug warning, and
      * then go track them down when I see them to figure out how they got saved
      * out needing fixing anyway.
      */
 
     auto file = MyMoneyFile::instance();
     QList<MyMoneyAccount> accountList;
     file->accountList(accountList);
     QList<MyMoneyAccount>::Iterator it_a;
     QList<MyMoneySchedule> scheduleList = file->scheduleList();
     QList<MyMoneySchedule>::Iterator it_s;
 
     MyMoneyAccount equity = file->equity();
     MyMoneyAccount asset = file->asset();
     bool equityListEmpty = equity.accountList().count() == 0;
 
     for (it_a = accountList.begin(); it_a != accountList.end(); ++it_a) {
       if ((*it_a).accountType() == eMyMoney::Account::Type::Loan
           || (*it_a).accountType() == eMyMoney::Account::Type::AssetLoan) {
         fixLoanAccount_0(*it_a);
       }
       // until early before 0.8 release, the equity account was not saved to
       // the file. If we have an equity account with no sub-accounts but
       // find and equity account that has equity() as it's parent, we reparent
       // this account. Need to move it to asset() first, because otherwise
       // MyMoneyFile::reparent would act as NOP.
       if (equityListEmpty && (*it_a).accountType() == eMyMoney::Account::Type::Equity) {
         if ((*it_a).parentAccountId() == equity.id()) {
           auto acc = *it_a;
           // tricky, force parent account to be empty so that we really
           // can re-parent it
           acc.setParentAccountId(QString());
           file->reparentAccount(acc, equity);
           qDebug() << Q_FUNC_INFO << " fixed account " << acc.id() << " reparented to " << equity.id();
         }
       }
     }
 
     for (it_s = scheduleList.begin(); it_s != scheduleList.end(); ++it_s) {
       fixSchedule_0(*it_s);
     }
 
     fixTransactions_0();
   }
 
   void fixSchedule_0(MyMoneySchedule sched)
   {
     MyMoneyTransaction t = sched.transaction();
     QList<MyMoneySplit> splitList = t.splits();
     QList<MyMoneySplit>::ConstIterator it_s;
     bool updated = false;
 
     try {
       // Check if the splits contain valid data and set it to
       // be valid.
       for (it_s = splitList.constBegin(); it_s != splitList.constEnd(); ++it_s) {
         // the first split is always the account on which this transaction operates
         // and if the transaction commodity is not set, we take this
         if (it_s == splitList.constBegin() && t.commodity().isEmpty()) {
           qDebug() << Q_FUNC_INFO << " " << t.id() << " has no commodity";
           try {
             auto acc = MyMoneyFile::instance()->account((*it_s).accountId());
             t.setCommodity(acc.currencyId());
             updated = true;
           } catch (const MyMoneyException &) {
           }
         }
         // make sure the account exists. If not, remove the split
         try {
           MyMoneyFile::instance()->account((*it_s).accountId());
         } catch (const MyMoneyException &) {
           qDebug() << Q_FUNC_INFO << " " << sched.id() << " " << (*it_s).id() << " removed, because account '" << (*it_s).accountId() << "' does not exist.";
           t.removeSplit(*it_s);
           updated = true;
         }
         if ((*it_s).reconcileFlag() != eMyMoney::Split::State::NotReconciled) {
           qDebug() << Q_FUNC_INFO << " " << sched.id() << " " << (*it_s).id() << " should be 'not reconciled'";
           MyMoneySplit split = *it_s;
           split.setReconcileDate(QDate());
           split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
           t.modifySplit(split);
           updated = true;
         }
         // the schedule logic used to operate only on the value field.
         // This is now obsolete.
         if ((*it_s).shares().isZero() && !(*it_s).value().isZero()) {
           MyMoneySplit split = *it_s;
           split.setShares(split.value());
           t.modifySplit(split);
           updated = true;
         }
       }
 
       // If there have been changes, update the schedule and
       // the engine data.
       if (updated) {
         sched.setTransaction(t);
         MyMoneyFile::instance()->modifySchedule(sched);
       }
     } catch (const MyMoneyException &e) {
-      qWarning("Unable to update broken schedule: %s", qPrintable(e.what()));
+      qWarning("Unable to update broken schedule: %s", e.what());
     }
   }
 
   void fixLoanAccount_0(MyMoneyAccount acc)
   {
     if (acc.value("final-payment").isEmpty()
         || acc.value("term").isEmpty()
         || acc.value("periodic-payment").isEmpty()
         || acc.value("loan-amount").isEmpty()
         || acc.value("interest-calculation").isEmpty()
         || acc.value("schedule").isEmpty()
         || acc.value("fixed-interest").isEmpty()) {
       KMessageBox::information(q,
                                i18n("<p>The account \"%1\" was previously created as loan account but some information is missing.</p><p>The new loan wizard will be started to collect all relevant information.</p><p>Please use KMyMoney version 0.8.7 or later and earlier than version 0.9 to correct the problem.</p>"
                                     , acc.name()),
                                i18n("Account problem"));
 
-      throw MYMONEYEXCEPTION("Fix LoanAccount0 not supported anymore");
+      throw MYMONEYEXCEPTION_CSTRING("Fix LoanAccount0 not supported anymore");
     }
   }
 
   void fixTransactions_0()
   {
     auto file = MyMoneyFile::instance();
 
     QList<MyMoneySchedule> scheduleList = file->scheduleList();
     MyMoneyTransactionFilter filter;
     filter.setReportAllSplits(false);
     QList<MyMoneyTransaction> transactionList;
     file->transactionList(transactionList, filter);
 
     QList<MyMoneySchedule>::Iterator it_x;
     QStringList interestAccounts;
 
     KMSTATUS(i18n("Fix transactions"));
     q->slotStatusProgressBar(0, scheduleList.count() + transactionList.count());
 
     int cnt = 0;
     // scan the schedules to find interest accounts
     for (it_x = scheduleList.begin(); it_x != scheduleList.end(); ++it_x) {
       MyMoneyTransaction t = (*it_x).transaction();
       QList<MyMoneySplit>::ConstIterator it_s;
       QStringList accounts;
       bool hasDuplicateAccounts = false;
 
       foreach (const auto split, t.splits()) {
         if (accounts.contains(split.accountId())) {
           hasDuplicateAccounts = true;
           qDebug() << Q_FUNC_INFO << " " << t.id() << " has multiple splits with account " << split.accountId();
         } else {
           accounts << split.accountId();
         }
 
         if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
           if (interestAccounts.contains(split.accountId()) == 0) {
             interestAccounts << split.accountId();
           }
         }
       }
       if (hasDuplicateAccounts) {
         fixDuplicateAccounts_0(t);
       }
       ++cnt;
       if (!(cnt % 10))
         q->slotStatusProgressBar(cnt);
     }
 
     // scan the transactions and modify loan transactions
     for (auto& transaction : transactionList) {
       QString defaultAction;
       QList<MyMoneySplit> splits = transaction.splits();
       QStringList accounts;
 
       // check if base commodity is set. if not, set baseCurrency
       if (transaction.commodity().isEmpty()) {
         qDebug() << Q_FUNC_INFO << " " << transaction.id() << " has no base currency";
         transaction.setCommodity(file->baseCurrency().id());
         file->modifyTransaction(transaction);
       }
 
       bool isLoan = false;
       // Determine default action
       if (transaction.splitCount() == 2) {
         // check for transfer
         int accountCount = 0;
         MyMoneyMoney val;
         foreach (const auto split, splits) {
           auto acc = file->account(split.accountId());
           if (acc.accountGroup() == eMyMoney::Account::Type::Asset
               || acc.accountGroup() == eMyMoney::Account::Type::Liability) {
             val = split.value();
             accountCount++;
             if (acc.accountType() == eMyMoney::Account::Type::Loan
                 || acc.accountType() == eMyMoney::Account::Type::AssetLoan)
               isLoan = true;
           } else
             break;
         }
         if (accountCount == 2) {
           if (isLoan)
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization);
           else
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer);
         } else {
           if (val.isNegative())
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal);
           else
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit);
         }
       }
 
       isLoan = false;
       foreach (const auto split, splits) {
         auto acc = file->account(split.accountId());
         MyMoneyMoney val = split.value();
         if (acc.accountGroup() == eMyMoney::Account::Type::Asset
             || acc.accountGroup() == eMyMoney::Account::Type::Liability) {
           if (!val.isPositive()) {
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal);
             break;
           } else {
             defaultAction = MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit);
             break;
           }
         }
       }
 
   #if 0
       // Check for correct actions in transactions referencing credit cards
       bool needModify = false;
       // The action fields are actually not used anymore in the ledger view logic
       // so we might as well skip this whole thing here!
       for (it_s = splits.begin(); needModify == false && it_s != splits.end(); ++it_s) {
         auto acc = file->account((*it_s).accountId());
         MyMoneyMoney val = (*it_s).value();
         if (acc.accountType() == Account::Type::CreditCard) {
           if (val < 0 && (*it_s).action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal) && (*it_s).action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer))
             needModify = true;
           if (val >= 0 && (*it_s).action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit) && (*it_s).action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer))
             needModify = true;
         }
       }
 
       // (Ace) Extended the #endif down to cover this conditional, because as-written
       // it will ALWAYS be skipped.
 
       if (needModify == true) {
         for (it_s = splits.begin(); it_s != splits.end(); ++it_s) {
           (*it_s).setAction(defaultAction);
           transaction.modifySplit(*it_s);
           file->modifyTransaction(transaction);
         }
         splits = transaction.splits();    // update local copy
         qDebug("Fixed credit card assignment in %s", transaction.id().data());
       }
   #endif
 
       // Check for correct assignment of ActionInterest in all splits
       // and check if there are any duplicates in this transactions
       for (auto& split : splits) {
         MyMoneyAccount splitAccount = file->account(split.accountId());
         if (!accounts.contains(split.accountId())) {
           accounts << split.accountId();
         }
         // if this split references an interest account, the action
         // must be of type ActionInterest
         if (interestAccounts.contains(split.accountId())) {
           if (split.action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
             qDebug() << Q_FUNC_INFO << " " << transaction.id() << " contains an interest account (" << split.accountId() << ") but does not have ActionInterest";
             split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Interest));
             transaction.modifySplit(split);
             file->modifyTransaction(transaction);
             qDebug("Fixed interest action in %s", qPrintable(transaction.id()));
           }
           // if it does not reference an interest account, it must not be
           // of type ActionInterest
         } else {
           if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
             qDebug() << Q_FUNC_INFO << " " << transaction.id() << " does not contain an interest account so it should not have ActionInterest";
             split.setAction(defaultAction);
             transaction.modifySplit(split);
             file->modifyTransaction(transaction);
             qDebug("Fixed interest action in %s", qPrintable(transaction.id()));
           }
         }
 
         // check that for splits referencing an account that has
         // the same currency as the transactions commodity the value
         // and shares field are the same.
         if (transaction.commodity() == splitAccount.currencyId()
             && split.value() != split.shares()) {
           qDebug() << Q_FUNC_INFO << " " << transaction.id() << " " << split.id() << " uses the transaction currency, but shares != value";
           split.setShares(split.value());
           transaction.modifySplit(split);
           file->modifyTransaction(transaction);
         }
 
         // fix the shares and values to have the correct fraction
         if (!splitAccount.isInvest()) {
           try {
             int fract = splitAccount.fraction();
             if (split.shares() != split.shares().convert(fract)) {
               qDebug("adjusting fraction in %s,%s", qPrintable(transaction.id()), qPrintable(split.id()));
               split.setShares(split.shares().convert(fract));
               split.setValue(split.value().convert(fract));
               transaction.modifySplit(split);
               file->modifyTransaction(transaction);
             }
           } catch (const MyMoneyException &) {
             qDebug("Missing security '%s', split not altered", qPrintable(splitAccount.currencyId()));
           }
         }
       }
 
       ++cnt;
       if (!(cnt % 10))
         q->slotStatusProgressBar(cnt);
     }
 
     q->slotStatusProgressBar(-1, -1);
   }
 
   void fixDuplicateAccounts_0(MyMoneyTransaction& t)
   {
     qDebug("Duplicate account in transaction %s", qPrintable(t.id()));
   }
 
 
 
 };
 
 KMyMoneyApp::KMyMoneyApp(QWidget* parent) :
     KXmlGuiWindow(parent),
     d(new Private(this))
 {
 #ifdef KMM_DBUS
   new KmymoneyAdaptor(this);
   QDBusConnection::sessionBus().registerObject("/KMymoney", this);
   QDBusConnection::sessionBus().interface()->registerService(
     "org.kde.kmymoney-" + QString::number(platformTools::processId()), QDBusConnectionInterface::DontQueueService);
 #endif
   // Register the main engine types used as meta-objects
   qRegisterMetaType<MyMoneyMoney>("MyMoneyMoney");
   qRegisterMetaType<MyMoneySecurity>("MyMoneySecurity");
 
   // preset the pointer because we need it during the course of this constructor
   kmymoney = this;
   d->m_config = KSharedConfig::openConfig();
 
   d->setThemedCSS();
 
   MyMoneyTransactionFilter::setFiscalYearStart(KMyMoneySettings::firstFiscalMonth(), KMyMoneySettings::firstFiscalDay());
 
   updateCaption(true);
 
   QFrame* frame = new QFrame;
   frame->setFrameStyle(QFrame::NoFrame);
   // values for margin (11) and spacing(6) taken from KDialog implementation
   QBoxLayout* layout = new QBoxLayout(QBoxLayout::TopToBottom, frame);
   layout->setContentsMargins(2, 2, 2, 2);
   layout->setSpacing(6);
 
   {
     #if defined(Q_OS_WIN) || defined(Q_OS_MACOS)
     QString themeName = QLatin1Literal("system");                       // using QIcon::setThemeName on Craft build system causes icons to disappear
     #else
     QString themeName = KMyMoneySettings::iconsTheme();                 // get theme user wants
     #endif
     if (!themeName.isEmpty() && themeName != QLatin1Literal("system"))  // if it isn't default theme then set it
       QIcon::setThemeName(themeName);
     Icons::setIconThemeNames(QIcon::themeName());                       // get whatever theme user ends up with and hope our icon names will fit that theme
   }
 
   initStatusBar();
   pActions = initActions();
   pMenus = initMenus();
 
   d->newStorage();
   d->m_myMoneyView = new KMyMoneyView;
   layout->addWidget(d->m_myMoneyView, 10);
   connect(d->m_myMoneyView, &KMyMoneyView::aboutToChangeView, this, &KMyMoneyApp::slotResetSelections);
   connect(d->m_myMoneyView, SIGNAL(currentPageChanged(KPageWidgetItem*,KPageWidgetItem*)),
           this, SLOT(slotUpdateActions()));
 
   connect(d->m_myMoneyView, &KMyMoneyView::statusMsg, this, &KMyMoneyApp::slotStatusMsg);
   connect(d->m_myMoneyView, &KMyMoneyView::statusProgress, this, &KMyMoneyApp::slotStatusProgressBar);
 
   connect(this, &KMyMoneyApp::fileLoaded, d->m_myMoneyView, &KMyMoneyView::slotRefreshViews);
 
   // Initialize kactivities resource instance
 #ifdef KF5Activities_FOUND
   d->m_activityResourceInstance = new KActivities::ResourceInstance(window()->winId(), this);
   connect(this, &KMyMoneyApp::fileLoaded, d->m_activityResourceInstance, &KActivities::ResourceInstance::setUri);
 #endif
 
   const auto viewActions = d->m_myMoneyView->actionsToBeConnected();
   actionCollection()->addActions(viewActions.values());
   for (auto it = viewActions.cbegin(); it != viewActions.cend(); ++it)
     pActions.insert(it.key(), it.value());
 
   ///////////////////////////////////////////////////////////////////
   // call inits to invoke all other construction parts
   readOptions();
 
   // now initialize the plugin structure
   createInterfaces();
   KMyMoneyPlugin::pluginHandling(KMyMoneyPlugin::Action::Load, d->m_plugins, this, guiFactory());
   onlineJobAdministration::instance()->setOnlinePlugins(d->m_plugins.extended);
   d->m_myMoneyView->setOnlinePlugins(d->m_plugins.online);
   d->m_myMoneyView->setStoragePlugins(d->m_plugins.storage);
 
   setCentralWidget(frame);
 
   connect(&d->m_proc, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotBackupHandleEvents()));
 
   // force to show the home page if the file is closed
   connect(pActions[Action::ViewTransactionDetail], &QAction::toggled, d->m_myMoneyView, &KMyMoneyView::slotShowTransactionDetail);
 
   d->m_backupState = BACKUP_IDLE;
 
   QLocale locale;
   for (auto const& weekDay: locale.weekdays())
   {
     d->m_processingDays.setBit(static_cast<int>(weekDay));
   }
   d->m_autoSaveTimer = new QTimer(this);
   d->m_progressTimer = new QTimer(this);
 
   connect(d->m_autoSaveTimer, SIGNAL(timeout()), this, SLOT(slotAutoSave()));
   connect(d->m_progressTimer, SIGNAL(timeout()), this, SLOT(slotStatusProgressDone()));
 
   // make sure, we get a note when the engine changes state
   connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotDataChanged()));
 
   // connect the WebConnect server
   connect(d->m_webConnect, SIGNAL(gotUrl(QUrl)), this, SLOT(webConnect(QUrl)));
   // make sure we have a balance warning object
   d->m_balanceWarning = new KBalanceWarning(this);
 
   // setup the initial configuration
   slotUpdateConfiguration(QString());
 
   // kickstart date change timer
   slotDateChanged();
 
   connect(this, SIGNAL(fileLoaded(QUrl)), onlineJobAdministration::instance(), SLOT(updateOnlineTaskProperties()));
 
 }
 
 KMyMoneyApp::~KMyMoneyApp()
 {
   // delete cached objects since they are in the way
   // when unloading the plugins
   onlineJobAdministration::instance()->clearCaches();
 
   // we need to unload all plugins before we destroy anything else
   KMyMoneyPlugin::pluginHandling(KMyMoneyPlugin::Action::Unload, d->m_plugins, this, guiFactory());
   d->removeStorage();
 
 #ifdef KF5Holidays_FOUND
   delete d->m_holidayRegion;
 #endif
 
 #ifdef KF5Activities_FOUND
   delete d->m_activityResourceInstance;
 #endif
 
   delete d;
 }
 
 QUrl KMyMoneyApp::lastOpenedURL()
 {
   QUrl url = d->m_startDialog ? QUrl() : d->m_fileName;
 
   if (!url.isValid()) {
     url = QUrl::fromUserInput(readLastUsedFile());
   }
 
   ready();
 
   return url;
 }
 
 void KMyMoneyApp::slotInstallConsistencyCheckContextMenu()
 {
   // this code relies on the implementation of KMessageBox::informationList to add a context menu to that list,
   // please adjust it if it's necessary or rewrite the way the consistency check results are displayed
   if (QWidget* dialog = QApplication::activeModalWidget()) {
     if (QListWidget* widget = dialog->findChild<QListWidget *>()) {
       // give the user a hint that the data can be saved
       widget->setToolTip(i18n("This is the consistency check log, use the context menu to copy or save it."));
       widget->setWhatsThis(widget->toolTip());
       widget->setContextMenuPolicy(Qt::CustomContextMenu);
       connect(widget, SIGNAL(customContextMenuRequested(QPoint)), SLOT(slotShowContextMenuForConsistencyCheck(QPoint)));
     }
   }
 }
 
 void KMyMoneyApp::slotShowContextMenuForConsistencyCheck(const QPoint &pos)
 {
   // allow the user to save the consistency check results
   if (QWidget* widget = qobject_cast< QWidget* >(sender())) {
     QMenu contextMenu(widget);
     QAction* copy = new QAction(i18n("Copy to clipboard"), widget);
     QAction* save = new QAction(i18n("Save to file"), widget);
     contextMenu.addAction(copy);
     contextMenu.addAction(save);
     QAction *result = contextMenu.exec(widget->mapToGlobal(pos));
     if (result == copy) {
       // copy the consistency check results to the clipboard
       d->copyConsistencyCheckResults();
     } else if (result == save) {
       // save the consistency check results to a file
       d->saveConsistencyCheckResults();
     }
   }
 }
 
 QHash<eMenu::Menu, QMenu *> KMyMoneyApp::initMenus()
 {
   QHash<Menu, QMenu *> lutMenus;
   const QHash<Menu, QString> menuNames {
     {Menu::Institution,             QStringLiteral("institution_context_menu")},
     {Menu::Account,                 QStringLiteral("account_context_menu")},
     {Menu::Schedule,                QStringLiteral("schedule_context_menu")},
     {Menu::Category,                QStringLiteral("category_context_menu")},
     {Menu::Tag,                     QStringLiteral("tag_context_menu")},
     {Menu::Payee,                   QStringLiteral("payee_context_menu")},
     {Menu::Investment,              QStringLiteral("investment_context_menu")},
     {Menu::Transaction,             QStringLiteral("transaction_context_menu")},
     {Menu::MoveTransaction,         QStringLiteral("transaction_move_menu")},
     {Menu::MarkTransaction,         QStringLiteral("transaction_mark_menu")},
     {Menu::MarkTransactionContext,  QStringLiteral("transaction_context_mark_menu")},
     {Menu::OnlineJob,               QStringLiteral("onlinejob_context_menu")}
   };
 
   for (auto it = menuNames.cbegin(); it != menuNames.cend(); ++it)
     lutMenus.insert(it.key(), qobject_cast<QMenu*>(factory()->container(it.value(), this)));
   return lutMenus;
 }
 
 QHash<Action, QAction *> KMyMoneyApp::initActions()
 {
   auto aC = actionCollection();
 
   /* Look-up table for all custom and standard actions.
   It's required for:
   1) building QList with QActions to be added to ActionCollection
   2) adding custom features to QActions like e.g. keyboard shortcut
   */
   QHash<Action, QAction *> lutActions;
 
   // *************
   // Adding standard actions
   // *************
   KStandardAction::openNew(this, &KMyMoneyApp::slotFileNew, aC);
   KStandardAction::open(this, &KMyMoneyApp::slotFileOpen, aC);
   d->m_recentFiles = KStandardAction::openRecent(this, &KMyMoneyApp::slotFileOpenRecent, aC);
   KStandardAction::save(this, &KMyMoneyApp::slotFileSave, aC);
   KStandardAction::saveAs(this, &KMyMoneyApp::slotFileSaveAs, aC);
   KStandardAction::close(this, &KMyMoneyApp::slotFileClose, aC);
   KStandardAction::quit(this, &KMyMoneyApp::slotFileQuit, aC);
   lutActions.insert(Action::Print, KStandardAction::print(this, &KMyMoneyApp::slotPrintView, aC));
   KStandardAction::preferences(this, &KMyMoneyApp::slotSettings, aC);
 
   // *************
   // Adding all actions
   // *************
   {
     // struct for creating useless (unconnected) QAction
     struct actionInfo {
       Action  action;
       QString name;
       QString text;
       Icon    icon;
     };
 
     const QVector<actionInfo> actionInfos {
       // *************
       // The File menu
       // *************
       {Action::FileBackup,                    QStringLiteral("file_backup"),                    i18n("Backup..."),                                  Icon::Empty},
       {Action::FileImportStatement,           QStringLiteral("file_import_statement"),          i18n("Statement file..."),                          Icon::Empty},
       {Action::FileImportTemplate,            QStringLiteral("file_import_template"),           i18n("Account Template..."),                        Icon::Empty},
       {Action::FileExportTemplate,            QStringLiteral("file_export_template"),           i18n("Account Template..."),                        Icon::Empty},
       {Action::FilePersonalData,              QStringLiteral("view_personal_data"),             i18n("Personal Data..."),                           Icon::UserProperties},
 #ifdef KMM_DEBUG
       {Action::FileDump,                      QStringLiteral("file_dump"),                      i18n("Dump Memory"),                                Icon::Empty},
 #endif
       {Action::FileInformation,               QStringLiteral("view_file_info"),                 i18n("File-Information..."),                        Icon::DocumentProperties},
       // *************
       // The Edit menu
       // *************
       {Action::EditFindTransaction,           QStringLiteral("edit_find_transaction"),          i18n("Find transaction..."),                        Icon::EditFindTransaction},
       // *************
       // The View menu
       // *************
       {Action::ViewTransactionDetail,         QStringLiteral("view_show_transaction_detail"),   i18n("Show Transaction Detail"),                    Icon::ViewTransactionDetail},
       {Action::ViewHideReconciled,            QStringLiteral("view_hide_reconciled_transactions"), i18n("Hide reconciled transactions"),            Icon::HideReconciled},
       {Action::ViewHideCategories,            QStringLiteral("view_hide_unused_categories"),    i18n("Hide unused categories"),                     Icon::HideCategories},
       {Action::ViewShowAll,                   QStringLiteral("view_show_all_accounts"),         i18n("Show all accounts"),                          Icon::Empty},
       // *********************
       // The institutions menu
       // *********************
       {Action::NewInstitution,                QStringLiteral("institution_new"),                i18n("New institution..."),                         Icon::InstitutionNew},
       {Action::EditInstitution,               QStringLiteral("institution_edit"),               i18n("Edit institution..."),                        Icon::InstitutionEdit},
       {Action::DeleteInstitution,             QStringLiteral("institution_delete"),             i18n("Delete institution..."),                      Icon::InstitutionDelete},
       // *****************
       // The accounts menu
       // *****************
       {Action::NewAccount,                    QStringLiteral("account_new"),                    i18n("New account..."),                             Icon::AccountNew},
       {Action::OpenAccount,                   QStringLiteral("account_open"),                   i18n("Open ledger"),                                Icon::ViewFinancialList},
       {Action::StartReconciliation,           QStringLiteral("account_reconcile"),              i18n("Reconcile..."),                               Icon::Reconcile},
       {Action::FinishReconciliation,          QStringLiteral("account_reconcile_finish"),       i18nc("Finish reconciliation", "Finish"),           Icon::AccountFinishReconciliation},
       {Action::PostponeReconciliation,        QStringLiteral("account_reconcile_postpone"),     i18n("Postpone reconciliation"),                    Icon::MediaPlaybackPause},
       {Action::EditAccount,                   QStringLiteral("account_edit"),                   i18n("Edit account..."),                            Icon::AccountEdit},
       {Action::DeleteAccount,                 QStringLiteral("account_delete"),                 i18n("Delete account..."),                          Icon::AccountDelete},
       {Action::CloseAccount,                  QStringLiteral("account_close"),                  i18n("Close account"),                              Icon::AccountClose},
       {Action::ReopenAccount,                 QStringLiteral("account_reopen"),                 i18n("Reopen account"),                             Icon::AccountReopen},
       {Action::ReportAccountTransactions,     QStringLiteral("account_transaction_report"),     i18n("Transaction report"),                         Icon::ViewFinancialList},
       {Action::ChartAccountBalance,           QStringLiteral("account_chart"),                  i18n("Show balance chart..."),                      Icon::OfficeChartLine},
       {Action::MapOnlineAccount,              QStringLiteral("account_online_map"),             i18n("Map account..."),                             Icon::NewsSubscribe},
       {Action::UnmapOnlineAccount,            QStringLiteral("account_online_unmap"),           i18n("Unmap account..."),                           Icon::NewsUnsubscribe},
       {Action::UpdateAccount,                 QStringLiteral("account_online_update"),          i18n("Update account..."),                          Icon::AccountUpdate},
       {Action::UpdateAllAccounts,             QStringLiteral("account_online_update_all"),      i18n("Update all accounts..."),                     Icon::AccountUpdateAll},
       {Action::AccountCreditTransfer,         QStringLiteral("account_online_new_credit_transfer"), i18n("New credit transfer"),                        Icon::AccountCreditTransfer},
       // *******************
       // The categories menu
       // *******************
       {Action::NewCategory,                   QStringLiteral("category_new"),                   i18n("New category..."),                            Icon::CategoryNew},
       {Action::EditCategory,                  QStringLiteral("category_edit"),                  i18n("Edit category..."),                           Icon::CategoryEdit},
       {Action::DeleteCategory,                QStringLiteral("category_delete"),                i18n("Delete category..."),                         Icon::CategoryDelete},
       // **************
       // The tools menu
       // **************
       {Action::ToolCurrencies,                QStringLiteral("tools_currency_editor"),          i18n("Currencies..."),                              Icon::ViewCurrencyList},
       {Action::ToolPrices,                    QStringLiteral("tools_price_editor"),             i18n("Prices..."),                                  Icon::Empty},
       {Action::ToolUpdatePrices,              QStringLiteral("tools_update_prices"),            i18n("Update Stock and Currency Prices..."),        Icon::ToolUpdatePrices},
       {Action::ToolConsistency,               QStringLiteral("tools_consistency_check"),        i18n("Consistency Check"),                          Icon::Empty},
       {Action::ToolPerformance,               QStringLiteral("tools_performancetest"),          i18n("Performance-Test"),                           Icon::Fork},
       {Action::ToolCalculator,                QStringLiteral("tools_kcalc"),                    i18n("Calculator..."),                              Icon::AccessoriesCalculator},
       // *****************
       // The settings menu
       // *****************
       {Action::SettingsAllMessages,           QStringLiteral("settings_enable_messages"),       i18n("Enable all messages"),                        Icon::Empty},
       // *************
       // The help menu
       // *************
       {Action::HelpShow,                      QStringLiteral("help_show_tip"),                  i18n("&Show tip of the day"),                       Icon::Tip},
       // ***************************
       // Actions w/o main menu entry
       // ***************************
       {Action::NewTransaction,                QStringLiteral("transaction_new"),                i18nc("New transaction button", "New"),             Icon::TransactionNew},
       {Action::EditTransaction,               QStringLiteral("transaction_edit"),               i18nc("Edit transaction button", "Edit"),           Icon::TransactionEdit},
       {Action::EnterTransaction,              QStringLiteral("transaction_enter"),              i18nc("Enter transaction", "Enter"),                Icon::DialogOK},
       {Action::EditSplits,                    QStringLiteral("transaction_editsplits"),         i18nc("Edit split button", "Edit splits"),          Icon::Split},
       {Action::CancelTransaction,             QStringLiteral("transaction_cancel"),             i18nc("Cancel transaction edit", "Cancel"),         Icon::DialogCancel},
       {Action::DeleteTransaction,             QStringLiteral("transaction_delete"),             i18nc("Delete transaction", "Delete"),              Icon::EditDelete},
       {Action::DuplicateTransaction,          QStringLiteral("transaction_duplicate"),          i18nc("Duplicate transaction", "Duplicate"),        Icon::EditCopy},
       {Action::MatchTransaction,              QStringLiteral("transaction_match"),              i18nc("Button text for match transaction", "Match"),Icon::TransactionMatch},
       {Action::AcceptTransaction,             QStringLiteral("transaction_accept"),             i18nc("Accept 'imported' and 'matched' transaction", "Accept"), Icon::TransactionAccept},
       {Action::ToggleReconciliationFlag,      QStringLiteral("transaction_mark_toggle"),        i18nc("Toggle reconciliation flag", "Toggle"),     Icon::Empty},
       {Action::MarkCleared,                   QStringLiteral("transaction_mark_cleared"),       i18nc("Mark transaction cleared", "Cleared"),       Icon::Empty},
       {Action::MarkReconciled,                QStringLiteral("transaction_mark_reconciled"),    i18nc("Mark transaction reconciled", "Reconciled"), Icon::Empty},
       {Action::MarkNotReconciled,             QStringLiteral("transaction_mark_notreconciled"), i18nc("Mark transaction not reconciled", "Not reconciled"),     Icon::Empty},
       {Action::SelectAllTransactions,         QStringLiteral("transaction_select_all"),         i18nc("Select all transactions", "Select all"),     Icon::Empty},
       {Action::GoToAccount,                   QStringLiteral("transaction_goto_account"),       i18n("Go to account"),                              Icon::GoJump},
       {Action::GoToPayee,                     QStringLiteral("transaction_goto_payee"),         i18n("Go to payee"),                                Icon::GoJump},
       {Action::NewScheduledTransaction,       QStringLiteral("transaction_create_schedule"),    i18n("Create scheduled transaction..."),            Icon::AppointmentNew},
       {Action::AssignTransactionsNumber,      QStringLiteral("transaction_assign_number"),      i18n("Assign next number"),                         Icon::Empty},
       {Action::CombineTransactions,           QStringLiteral("transaction_combine"),            i18nc("Combine transactions", "Combine"),           Icon::Empty},
       {Action::CopySplits,                    QStringLiteral("transaction_copy_splits"),        i18n("Copy splits"),                                Icon::Empty},
       //Investment
       {Action::NewInvestment,                 QStringLiteral("investment_new"),                 i18n("New investment..."),                          Icon::InvestmentNew},
       {Action::EditInvestment,                QStringLiteral("investment_edit"),                i18n("Edit investment..."),                         Icon::InvestmentEdit},
       {Action::DeleteInvestment,              QStringLiteral("investment_delete"),              i18n("Delete investment..."),                       Icon::InvestmentDelete},
       {Action::UpdatePriceOnline,             QStringLiteral("investment_online_price_update"), i18n("Online price update..."),                     Icon::InvestmentOnlinePrice},
       {Action::UpdatePriceManually,           QStringLiteral("investment_manual_price_update"), i18n("Manual price update..."),                     Icon::Empty},
       //Schedule
       {Action::NewSchedule,                   QStringLiteral("schedule_new"),                   i18n("New scheduled transaction"),                  Icon::AppointmentNew},
       {Action::EditSchedule,                  QStringLiteral("schedule_edit"),                  i18n("Edit scheduled transaction"),                 Icon::DocumentEdit},
       {Action::DeleteSchedule,                QStringLiteral("schedule_delete"),                i18n("Delete scheduled transaction"),               Icon::EditDelete},
       {Action::DuplicateSchedule,             QStringLiteral("schedule_duplicate"),             i18n("Duplicate scheduled transaction"),            Icon::EditCopy},
       {Action::EnterSchedule,                 QStringLiteral("schedule_enter"),                 i18n("Enter next transaction..."),                  Icon::KeyEnter},
       {Action::SkipSchedule,                  QStringLiteral("schedule_skip"),                  i18n("Skip next transaction..."),                   Icon::MediaSeekForward},
       //Payees
       {Action::NewPayee,                      QStringLiteral("payee_new"),                      i18n("New payee"),                                  Icon::ListAddUser},
       {Action::RenamePayee,                   QStringLiteral("payee_rename"),                   i18n("Rename payee"),                               Icon::PayeeRename},
       {Action::DeletePayee,                   QStringLiteral("payee_delete"),                   i18n("Delete payee"),                               Icon::ListRemoveUser},
       {Action::MergePayee,                    QStringLiteral("payee_merge"),                    i18n("Merge payees"),                               Icon::PayeeMerge},
       //Tags
       {Action::NewTag,                        QStringLiteral("tag_new"),                        i18n("New tag"),                                    Icon::ListAddTag},
       {Action::RenameTag,                     QStringLiteral("tag_rename"),                     i18n("Rename tag"),                                 Icon::TagRename},
       {Action::DeleteTag,                     QStringLiteral("tag_delete"),                     i18n("Delete tag"),                                 Icon::ListRemoveTag},
       //debug actions
 #ifdef KMM_DEBUG
       {Action::WizardNewUser,                 QStringLiteral("new_user_wizard"),                i18n("Test new feature"),                           Icon::Empty},
       {Action::DebugTraces,                   QStringLiteral("debug_traces"),                   i18n("Debug Traces"),                               Icon::Empty},
 #endif
       {Action::DebugTimers,                   QStringLiteral("debug_timers"),                   i18n("Debug Timers"),                               Icon::Empty},
       // onlineJob actions
       {Action::DeleteOnlineJob,               QStringLiteral("onlinejob_delete"),               i18n("Remove credit transfer"),                     Icon::EditDelete},
       {Action::EditOnlineJob,                 QStringLiteral("onlinejob_edit"),                 i18n("Edit credit transfer"),                       Icon::DocumentEdit},
       {Action::LogOnlineJob,                  QStringLiteral("onlinejob_log"),                  i18n("Show log"),                                   Icon::Empty},
     };
 
     for (const auto& info : actionInfos) {
       auto a = new QAction(this);
       // KActionCollection::addAction by name sets object name anyways,
       // so, as better alternative, set it here right from the start
       a->setObjectName(info.name);
       a->setText(info.text);
       if (info.icon != Icon::Empty) // no need to set empty icon
         a->setIcon(Icons::get(info.icon));
       a->setEnabled(false);
       lutActions.insert(info.action, a);  // store QAction's pointer for later processing
     }
   }
 
   {
     // List with slots that get connected here. Other slots get connected in e.g. appropriate views
     typedef void(KMyMoneyApp::*KMyMoneyAppFunc)();
     const QHash<eMenu::Action, KMyMoneyAppFunc> actionConnections {
       // *************
       // The File menu
       // *************
 //      {Action::FileOpenDatabase,              &KMyMoneyApp::slotOpenDatabase},
 //      {Action::FileSaveAsDatabase,            &KMyMoneyApp::slotSaveAsDatabase},
       {Action::FileBackup,                    &KMyMoneyApp::slotBackupFile},
       {Action::FileImportTemplate,            &KMyMoneyApp::slotLoadAccountTemplates},
       {Action::FileExportTemplate,            &KMyMoneyApp::slotSaveAccountTemplates},
       {Action::FilePersonalData,              &KMyMoneyApp::slotFileViewPersonal},
 #ifdef KMM_DEBUG
       {Action::FileDump,                      &KMyMoneyApp::slotFileFileInfo},
 #endif
       {Action::FileInformation,               &KMyMoneyApp::slotFileInfoDialog},
       // *************
       // The View menu
       // *************
       {Action::ViewTransactionDetail,         &KMyMoneyApp::slotShowTransactionDetail},
       {Action::ViewHideReconciled,            &KMyMoneyApp::slotHideReconciledTransactions},
       {Action::ViewHideCategories,            &KMyMoneyApp::slotHideUnusedCategories},
       {Action::ViewShowAll,                   &KMyMoneyApp::slotShowAllAccounts},
       // **************
       // The tools menu
       // **************
       {Action::ToolCurrencies,                &KMyMoneyApp::slotCurrencyDialog},
       {Action::ToolPrices,                    &KMyMoneyApp::slotPriceDialog},
       {Action::ToolUpdatePrices,              &KMyMoneyApp::slotEquityPriceUpdate},
       {Action::ToolConsistency,               &KMyMoneyApp::slotFileConsistencyCheck},
       {Action::ToolPerformance,               &KMyMoneyApp::slotPerformanceTest},
 //      {Action::ToolSQL,                       &KMyMoneyApp::slotGenerateSql},
       {Action::ToolCalculator,                &KMyMoneyApp::slotToolsStartKCalc},
       // *****************
       // The settings menu
       // *****************
       {Action::SettingsAllMessages,           &KMyMoneyApp::slotEnableMessages},
       // *************
       // The help menu
       // *************
       {Action::HelpShow,                      &KMyMoneyApp::slotShowTipOfTheDay},
       // ***************************
       // Actions w/o main menu entry
       // ***************************
       //debug actions
 #ifdef KMM_DEBUG
       {Action::WizardNewUser,                 &KMyMoneyApp::slotNewFeature},
       {Action::DebugTraces,                   &KMyMoneyApp::slotToggleTraces},
 #endif
       {Action::DebugTimers,                   &KMyMoneyApp::slotToggleTimers},
     };
 
     for (auto connection = actionConnections.cbegin(); connection != actionConnections.cend(); ++connection)
       connect(lutActions[connection.key()], &QAction::triggered, this, connection.value());
   }
 
   // *************
   // Setting some of added actions checkable
   // *************
   {
     // Some actions are checkable,
     // so set them here
     const QVector<Action> checkableActions {
       Action::ViewTransactionDetail, Action::ViewHideReconciled, Action::ViewHideCategories,
     #ifdef KMM_DEBUG
           Action::DebugTraces,
           Action::DebugTimers,
     #endif
           Action::ViewShowAll
     };
 
     for (const auto& it : checkableActions) {
       lutActions[it]->setCheckable(true);
       lutActions[it]->setEnabled(true);
     }
   }
 
   // *************
   // Setting actions that are always enabled
   // *************
   {
     const QVector<eMenu::Action> alwaysEnabled {
       Action::HelpShow,
       Action::SettingsAllMessages,
       Action::ToolPerformance,
       Action::ToolCalculator
     };
     for (const auto& action : alwaysEnabled) {
       lutActions[action]->setEnabled(true);
     }
   }
 
   // *************
   // Setting keyboard shortcuts for some of added actions
   // *************
   {
     const QVector<QPair<Action, QKeySequence>> actionShortcuts {
       {qMakePair(Action::EditFindTransaction,         Qt::CTRL + Qt::Key_F)},
       {qMakePair(Action::ViewTransactionDetail,       Qt::CTRL + Qt::Key_T)},
       {qMakePair(Action::ViewHideReconciled,          Qt::CTRL + Qt::Key_R)},
       {qMakePair(Action::ViewHideCategories,          Qt::CTRL + Qt::Key_U)},
       {qMakePair(Action::ViewShowAll,                 Qt::CTRL + Qt::SHIFT + Qt::Key_A)},
       {qMakePair(Action::StartReconciliation,         Qt::CTRL + Qt::SHIFT + Qt::Key_R)},
       {qMakePair(Action::NewTransaction,              Qt::CTRL + Qt::Key_Insert)},
       {qMakePair(Action::ToggleReconciliationFlag,    Qt::CTRL + Qt::Key_Space)},
       {qMakePair(Action::MarkCleared,                 Qt::CTRL + Qt::ALT+ Qt::Key_Space)},
       {qMakePair(Action::MarkReconciled,              Qt::CTRL + Qt::SHIFT + Qt::Key_Space)},
       {qMakePair(Action::SelectAllTransactions,       Qt::CTRL + Qt::Key_A)},
 #ifdef KMM_DEBUG
       {qMakePair(Action::WizardNewUser,               Qt::CTRL + Qt::Key_G)},
 #endif
       {qMakePair(Action::AssignTransactionsNumber,    Qt::CTRL + Qt::SHIFT + Qt::Key_N)}
     };
 
     for(const auto& it : actionShortcuts)
       aC->setDefaultShortcut(lutActions[it.first], it.second);
   }
 
   // *************
   // Misc settings
   // *************
   connect(onlineJobAdministration::instance(), &onlineJobAdministration::canSendCreditTransferChanged,  lutActions.value(Action::AccountCreditTransfer), &QAction::setEnabled);
 
   // Setup transaction detail switch
   lutActions[Action::ViewTransactionDetail]->setChecked(KMyMoneySettings::showRegisterDetailed());
   lutActions[Action::ViewHideReconciled]->setChecked(KMyMoneySettings::hideReconciledTransactions());
   lutActions[Action::ViewHideCategories]->setChecked(KMyMoneySettings::hideUnusedCategory());
   lutActions[Action::ViewShowAll]->setChecked(false);
 
   // *************
   // Adding actions to ActionCollection
   // *************
   actionCollection()->addActions(lutActions.values());
 
   // ************************
   // Currently unused actions
   // ************************
 #if 0
   new KToolBarPopupAction(i18n("View back"), "go-previous", 0, this, SLOT(slotShowPreviousView()), actionCollection(), "go_back");
   new KToolBarPopupAction(i18n("View forward"), "go-next", 0, this, SLOT(slotShowNextView()), actionCollection(), "go_forward");
 
   action("go_back")->setEnabled(false);
   action("go_forward")->setEnabled(false);
 #endif
 
   // use the absolute path to your kmymoneyui.rc file for testing purpose in createGUI();
   setupGUI();
 
   // reconnect about app entry to dialog with full credits information
   auto aboutApp = aC->action(QString::fromLatin1(KStandardAction::name(KStandardAction::AboutApp)));
   aboutApp->disconnect();
   connect(aboutApp, &QAction::triggered, this, &KMyMoneyApp::slotShowCredits);
 
   QMenu *menuContainer;
   menuContainer = static_cast<QMenu*>(factory()->container(QStringLiteral("import"), this));
   menuContainer->setIcon(Icons::get(Icon::DocumentImport));
 
   menuContainer = static_cast<QMenu*>(factory()->container(QStringLiteral("export"), this));
   menuContainer->setIcon(Icons::get(Icon::DocumentExport));
   return lutActions;
 }
 
 #ifdef KMM_DEBUG
 void KMyMoneyApp::dumpActions() const
 {
   const QList<QAction*> list = actionCollection()->actions();
   foreach (const auto it, list)
     std::cout << qPrintable(it->objectName()) << ": " << qPrintable(it->text()) << std::endl;
 }
 #endif
 
 bool KMyMoneyApp::isActionToggled(const Action _a)
 {
   return pActions[_a]->isChecked();
 }
 
 void KMyMoneyApp::initStatusBar()
 {
   ///////////////////////////////////////////////////////////////////
   // STATUSBAR
 
   d->m_statusLabel = new QLabel;
   statusBar()->addWidget(d->m_statusLabel);
   ready();
 
   // Initialization of progress bar taken from KDevelop ;-)
   d->m_progressBar = new QProgressBar;
   statusBar()->addWidget(d->m_progressBar);
   d->m_progressBar->setFixedHeight(d->m_progressBar->sizeHint().height() - 8);
 
   // hide the progress bar for now
   slotStatusProgressBar(-1, -1);
 }
 
 void KMyMoneyApp::saveOptions()
 {
   KConfigGroup grp = d->m_config->group("General Options");
   grp.writeEntry("Geometry", size());
 
   grp.writeEntry("Show Statusbar", actionCollection()->action(KStandardAction::name(KStandardAction::ShowStatusbar))->isChecked());
 
   KConfigGroup toolbarGrp = d->m_config->group("mainToolBar");
   toolBar("mainToolBar")->saveSettings(toolbarGrp);
 
   d->m_recentFiles->saveEntries(d->m_config->group("Recent Files"));
 
 }
 
 
 void KMyMoneyApp::readOptions()
 {
   KConfigGroup grp = d->m_config->group("General Options");
 
 
   pActions[Action::ViewHideReconciled]->setChecked(KMyMoneySettings::hideReconciledTransactions());
   pActions[Action::ViewHideCategories]->setChecked(KMyMoneySettings::hideUnusedCategory());
 
   d->m_recentFiles->loadEntries(d->m_config->group("Recent Files"));
 
   // Startdialog is written in the settings dialog
   d->m_startDialog = grp.readEntry("StartDialog", true);
 }
 
 void KMyMoneyApp::resizeEvent(QResizeEvent* ev)
 {
   KMainWindow::resizeEvent(ev);
   updateCaption(true);
 }
 
 int KMyMoneyApp::askSaveOnClose()
 {
   int ans;
   if (KMyMoneySettings::autoSaveOnClose()) {
     ans = KMessageBox::Yes;
   } else {
     ans = KMessageBox::warningYesNoCancel(this, i18n("The file has been changed, save it?"));
   }
   return ans;
 }
 
 bool KMyMoneyApp::queryClose()
 {
   if (!isReady())
     return false;
 
   if (d->dirty()) {
     int ans = askSaveOnClose();
 
     if (ans == KMessageBox::Cancel)
       return false;
     else if (ans == KMessageBox::Yes) {
       bool saved = slotFileSave();
       saveOptions();
       return saved;
     }
   }
 //  if (d->m_myMoneyView->isDatabase())
 //    slotFileClose(); // close off the database
   saveOptions();
   return true;
 }
 
 /////////////////////////////////////////////////////////////////////
 // SLOT IMPLEMENTATION
 /////////////////////////////////////////////////////////////////////
 void KMyMoneyApp::slotFileInfoDialog()
 {
   QPointer<KMyMoneyFileInfoDlg> dlg = new KMyMoneyFileInfoDlg(0);
   dlg->exec();
   delete dlg;
 }
 
 void KMyMoneyApp::slotPerformanceTest()
 {
   // dump performance report to stderr
 
   int measurement[2];
   QTime timer;
   MyMoneyAccount acc;
 
   qDebug("--- Starting performance tests ---");
 
   // AccountList
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   timer.start();
   for (int i = 0; i < 1000; ++i) {
     QList<MyMoneyAccount> list;
 
     MyMoneyFile::instance()->accountList(list);
     measurement[i != 0] = timer.elapsed();
   }
   std::cerr << "accountList()" << std::endl;
   std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
   std::cerr << "Total time: " << (measurement[0] + measurement[1]) << " msec" << std::endl;
   std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 1000 << " msec" << std::endl;
 
   // Balance of asset account(s)
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   acc = MyMoneyFile::instance()->asset();
   for (int i = 0; i < 1000; ++i) {
     timer.start();
     MyMoneyMoney result = MyMoneyFile::instance()->balance(acc.id());
     measurement[i != 0] += timer.elapsed();
   }
   std::cerr << "balance(Asset)" << std::endl;
   std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
   std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 1000 << " msec" << std::endl;
 
   // total balance of asset account
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   acc = MyMoneyFile::instance()->asset();
   for (int i = 0; i < 1000; ++i) {
     timer.start();
     MyMoneyMoney result = MyMoneyFile::instance()->totalBalance(acc.id());
     measurement[i != 0] += timer.elapsed();
   }
   std::cerr << "totalBalance(Asset)" << std::endl;
   std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
   std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 1000 << " msec" << std::endl;
 
   // Balance of expense account(s)
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   acc = MyMoneyFile::instance()->expense();
   for (int i = 0; i < 1000; ++i) {
     timer.start();
     MyMoneyMoney result = MyMoneyFile::instance()->balance(acc.id());
     measurement[i != 0] += timer.elapsed();
   }
   std::cerr << "balance(Expense)" << std::endl;
   std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
   std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 1000 << " msec" << std::endl;
 
   // total balance of expense account
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   acc = MyMoneyFile::instance()->expense();
   timer.start();
   for (int i = 0; i < 1000; ++i) {
     MyMoneyMoney result = MyMoneyFile::instance()->totalBalance(acc.id());
     measurement[i != 0] = timer.elapsed();
   }
   std::cerr << "totalBalance(Expense)" << std::endl;
   std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
   std::cerr << "Total time: " << (measurement[0] + measurement[1]) << " msec" << std::endl;
   std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 1000 << " msec" << std::endl;
 
   // transaction list
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   if (MyMoneyFile::instance()->asset().accountCount()) {
     MyMoneyTransactionFilter filter(MyMoneyFile::instance()->asset().accountList()[0]);
     filter.setDateFilter(QDate(), QDate::currentDate());
     QList<MyMoneyTransaction> list;
 
     timer.start();
     for (int i = 0; i < 100; ++i) {
       list = MyMoneyFile::instance()->transactionList(filter);
       measurement[i != 0] = timer.elapsed();
     }
     std::cerr << "transactionList()" << std::endl;
     std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
     std::cerr << "Total time: " << (measurement[0] + measurement[1]) << " msec" << std::endl;
     std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 100 << " msec" << std::endl;
   }
 
   // transaction list
 //  MyMoneyFile::instance()->preloadCache();
   measurement[0] = measurement[1] = 0;
   if (MyMoneyFile::instance()->asset().accountCount()) {
     MyMoneyTransactionFilter filter(MyMoneyFile::instance()->asset().accountList()[0]);
     filter.setDateFilter(QDate(), QDate::currentDate());
     QList<MyMoneyTransaction> list;
 
     timer.start();
     for (int i = 0; i < 100; ++i) {
       MyMoneyFile::instance()->transactionList(list, filter);
       measurement[i != 0] = timer.elapsed();
     }
     std::cerr << "transactionList(list)" << std::endl;
     std::cerr << "First time: " << measurement[0] << " msec" << std::endl;
     std::cerr << "Total time: " << (measurement[0] + measurement[1]) << " msec" << std::endl;
     std::cerr << "Average   : " << (measurement[0] + measurement[1]) / 100 << " msec" << std::endl;
   }
 //  MyMoneyFile::instance()->preloadCache();
 }
 
 void KMyMoneyApp::slotFileNew()
 {
   KMSTATUS(i18n("Creating new document..."));
 
   slotFileClose();
 
   if (!d->m_fileOpen) {
     // next line required until we move all file handling out of KMyMoneyView
     d->newFile();
 
     d->m_fileName = QUrl();
     updateCaption();
 
     NewUserWizard::Wizard *wizard = new NewUserWizard::Wizard();
 
     if (wizard->exec() == QDialog::Accepted) {
       MyMoneyFileTransaction ft;
       MyMoneyFile* file = MyMoneyFile::instance();
       try {
         // store the user info
         file->setUser(wizard->user());
 
         // create and setup base currency
         file->addCurrency(wizard->baseCurrency());
         file->setBaseCurrency(wizard->baseCurrency());
 
         // create a possible institution
         MyMoneyInstitution inst = wizard->institution();
         if (inst.name().length()) {
           file->addInstitution(inst);
         }
 
         // create a possible checking account
         auto acc = wizard->account();
         if (acc.name().length()) {
           acc.setInstitutionId(inst.id());
           MyMoneyAccount asset = file->asset();
           file->addAccount(acc, asset);
 
           // create possible opening balance transaction
           if (!wizard->openingBalance().isZero()) {
             file->createOpeningBalanceTransaction(acc, wizard->openingBalance());
           }
         }
 
         // import the account templates
         QList<MyMoneyTemplate> templates = wizard->templates();
         QList<MyMoneyTemplate>::iterator it_t;
         for (it_t = templates.begin(); it_t != templates.end(); ++it_t) {
           (*it_t).importTemplate(&progressCallback);
         }
 
         d->m_fileName = wizard->url();
         ft.commit();
         KMyMoneySettings::setFirstTimeRun(false);
 
         // FIXME This is a bit clumsy. We re-read the freshly
         // created file to be able to run through all the
         // fixup logic and then save it to keep the modified
         // flag off.
         slotFileSave();
         if (d->openNondatabase(d->m_fileName)) {
           d->m_fileOpen = true;
           d->initializeStorage();
         }
         slotFileSave();
 
         // now keep the filename in the recent files used list
         //KRecentFilesAction *p = dynamic_cast<KRecentFilesAction*>(action(KStandardAction::name(KStandardAction::OpenRecent)));
         //if(p)
         d->m_recentFiles->addUrl(d->m_fileName);
         writeLastUsedFile(d->m_fileName.url());
 
       } catch (const MyMoneyException &) {
         // next line required until we move all file handling out of KMyMoneyView
         d->closeFile();
       }
       if (wizard->startSettingsAfterFinished())
         slotSettings();
     } else {
       // next line required until we move all file handling out of KMyMoneyView
       d->closeFile();
     }
     delete wizard;
     updateCaption();
 
     emit fileLoaded(d->m_fileName);
   }
 }
 
 bool KMyMoneyApp::isDatabase()
 {
   return (d->m_fileOpen && ((d->m_fileType == KmmDb)));
 }
 
 bool KMyMoneyApp::isNativeFile()
 {
   return (d->m_fileOpen && (d->m_fileType < MaxNativeFileType));
 }
 
 bool KMyMoneyApp::fileOpen() const
 {
   return d->m_fileOpen;
 }
 
 // General open
 void KMyMoneyApp::slotFileOpen()
 {
   KMSTATUS(i18n("Open a file."));
 
   QString prevDir = readLastUsedDir();
   QString fileExtensions;
   fileExtensions.append(i18n("KMyMoney files (*.kmy *.xml)"));
   fileExtensions.append(QLatin1String(";;"));
 
   for (const auto& plugin : d->m_plugins.storage) {
     const auto fileExtension = plugin->fileExtension();
     if (!fileExtension.isEmpty()) {
       fileExtensions.append(fileExtension);
       fileExtensions.append(QLatin1String(";;"));
     }
   }
   fileExtensions.append(i18n("All files (*)"));
 
   QPointer<QFileDialog> dialog = new QFileDialog(this, QString(), prevDir, fileExtensions);
   dialog->setFileMode(QFileDialog::ExistingFile);
   dialog->setAcceptMode(QFileDialog::AcceptOpen);
 
   if (dialog->exec() == QDialog::Accepted && dialog != nullptr) {
     slotFileOpenRecent(dialog->selectedUrls().first());
   }
   delete dialog;
 }
 
 bool KMyMoneyApp::isImportableFile(const QUrl &url)
 {
   bool result = false;
 
   // Iterate through the plugins and see if there's a loaded plugin who can handle it
   QMap<QString, KMyMoneyPlugin::ImporterPlugin*>::const_iterator it_plugin = d->m_plugins.importer.constBegin();
   while (it_plugin != d->m_plugins.importer.constEnd()) {
     if ((*it_plugin)->isMyFormat(url.path())) {
       result = true;
       break;
     }
     ++it_plugin;
   }
 
   // If we did not find a match, try importing it as a KMM statement file,
   // which is really just for testing.  the statement file is not exposed
   // to users.
   if (it_plugin == d->m_plugins.importer.constEnd())
     if (MyMoneyStatement::isStatementFile(url.path()))
       result = true;
 
   // Place code here to test for QIF and other locally-supported formats
   // (i.e. not a plugin). If you add them here, be sure to add it to
   // the webConnect function.
 
   return result;
 }
 
 bool KMyMoneyApp::isFileOpenedInAnotherInstance(const QUrl &url)
 {
   const auto instances = instanceList();
 #ifdef KMM_DBUS
   // check if there are other instances which might have this file open
   for (const auto& instance : instances) {
     QDBusInterface remoteApp(instance, "/KMymoney", "org.kde.kmymoney");
     QDBusReply<QString> reply = remoteApp.call("filename");
     if (!reply.isValid())
       qDebug("D-Bus error while calling app->filename()");
     else if (reply.value() == url.url())
       return true;
   }
 #else
   Q_UNUSED(url)
 #endif
   return false;
 }
 
 void KMyMoneyApp::slotFileOpenRecent(const QUrl &url)
 {
   KMSTATUS(i18n("Loading file..."));
   if (isFileOpenedInAnotherInstance(url)) {
     KMessageBox::sorry(this, i18n("<p>File <b>%1</b> is already opened in another instance of KMyMoney</p>", url.toDisplayString(QUrl::PreferLocalFile)), i18n("Duplicate open"));
     return;
   }
 
   if (url.scheme() != QLatin1String("sql") && !KMyMoneyUtils::fileExists(url)) {
     KMessageBox::sorry(this, i18n("<p><b>%1</b> is either an invalid filename or the file does not exist. You can open another file or create a new one.</p>", url.toDisplayString(QUrl::PreferLocalFile)), i18n("File not found"));
     return;
   }
 
   if (d->m_fileOpen)
     slotFileClose();
 
   if (d->m_fileOpen)
     return;
 
   try {
     auto isOpened = false;
     if (url.scheme() == QLatin1String("sql"))
       isOpened = d->openDatabase(url);
     else
       isOpened = d->openNondatabase(url);
 
     if (!isOpened)
       return;
 
     d->m_fileOpen = true;
     if (!d->initializeStorage()) {
       d->m_fileOpen = false;
       return;
     }
 
     if (isNativeFile()) {
       d->m_fileName = url;
       updateCaption();
       writeLastUsedFile(url.toDisplayString(QUrl::PreferLocalFile));
       /* Don't use url variable after KRecentFilesAction::addUrl
        * as it might delete it.
        * More in API reference to this method
        */
       d->m_recentFiles->addUrl(url);
     } else {
       d->m_fileName = QUrl(); // imported files have no filename
     }
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::sorry(this, i18n("Cannot open file as requested. Error was: %1", e.what()));
+    KMessageBox::sorry(this, i18n("Cannot open file as requested. Error was: %1", QString::fromLatin1(e.what())));
   }
   updateCaption();
   emit fileLoaded(d->m_fileName);
 }
 
 bool KMyMoneyApp::slotFileSave()
 {
   // if there's nothing changed, there's no need to save anything
   if (!d->dirty())
     return true;
 
   bool rc = false;
 
   KMSTATUS(i18n("Saving file..."));
 
   if (d->m_fileName.isEmpty())
     return slotFileSaveAs();
 
   d->consistencyCheck(false);
 
   setEnabled(false);
   if (isDatabase()) {
     auto pluginFound = false;
     for (const auto& plugin : d->m_plugins.storage) {
       if (plugin->formatName().compare(QLatin1String("SQL")) == 0) {
         rc = plugin->save(d->m_fileName);
         pluginFound = true;
         break;
       }
     }
     if(!pluginFound)
       KMessageBox::error(this, i18n("Couldn't find suitable plugin to save your storage."));
   } else {
     rc = d->saveFile(d->m_fileName, MyMoneyFile::instance()->value("kmm-encryption-key"));
   }
   setEnabled(true);
 
   d->m_autoSaveTimer->stop();
 
   updateCaption();
   return rc;
 }
 
 bool KMyMoneyApp::slotFileSaveAs()
 {
   bool rc = false;
   KMSTATUS(i18n("Saving file with a new filename..."));
 
   QString selectedKeyName;
   if (KGPGFile::GPGAvailable() && KMyMoneySettings::writeDataEncrypted()) {
     // fill the secret key list and combo box
     QStringList keyList;
     KGPGFile::secretKeyList(keyList);
 
     QPointer<KGpgKeySelectionDlg> dlg = new KGpgKeySelectionDlg(this);
     dlg->setSecretKeys(keyList, KMyMoneySettings::gpgRecipient());
     dlg->setAdditionalKeys(KMyMoneySettings::gpgRecipientList());
     rc = dlg->exec();
     if ((rc == QDialog::Accepted) && (dlg != 0)) {
       d->m_additionalGpgKeys = dlg->additionalKeys();
       selectedKeyName = dlg->secretKey();
     }
     delete dlg;
     if (rc != QDialog::Accepted) {
       return false;
     }
   }
 
   QString prevDir; // don't prompt file name if not a native file
   if (isNativeFile())
     prevDir = readLastUsedDir();
 
   QPointer<QFileDialog> dlg =
     new QFileDialog(this, i18n("Save As"), prevDir,
                     QString(QLatin1String("%2 (%1);;")).arg(QStringLiteral("*.kmy")).arg(i18nc("KMyMoney (Filefilter)", "KMyMoney files")) +
                     QString(QLatin1String("%2 (%1);;")).arg(QStringLiteral("*.xml")).arg(i18nc("XML (Filefilter)", "XML files")) +
                     QString(QLatin1String("%2 (%1);;")).arg(QStringLiteral("*.anon.xml")).arg(i18nc("Anonymous (Filefilter)", "Anonymous files")) +
                     QString(QLatin1String("%2 (%1);;")).arg(QStringLiteral("*")).arg(i18nc("All files (Filefilter)", "All files")));
   dlg->setAcceptMode(QFileDialog::AcceptSave);
 
   if (dlg->exec() == QDialog::Accepted && dlg != 0) {
     QUrl newURL = dlg->selectedUrls().first();
     if (!newURL.fileName().isEmpty()) {
       d->consistencyCheck(false);
       QString newName = newURL.toDisplayString(QUrl::PreferLocalFile);
 
       // append extension if not present
       if (!newName.endsWith(QLatin1String(".kmy"), Qt::CaseInsensitive) &&
           !newName.endsWith(QLatin1String(".xml"), Qt::CaseInsensitive))
         newName.append(QLatin1String(".kmy"));
       newURL = QUrl::fromUserInput(newName);
       d->m_recentFiles->addUrl(newURL);
 
       setEnabled(false);
       // If this is the anonymous file export, just save it, don't actually take the
       // name, or remember it! Don't even try to encrypt it
       if (newName.endsWith(QLatin1String(".anon.xml"), Qt::CaseInsensitive))
         rc = d->saveFile(newURL);
       else {
         d->m_fileName = newURL;
         QString encryptionKeys;
         QRegExp keyExp(".* \\((.*)\\)");
         if (keyExp.indexIn(selectedKeyName) != -1) {
           encryptionKeys = keyExp.cap(1);
           if (!d->m_additionalGpgKeys.isEmpty()) {
             if (!encryptionKeys.isEmpty())
               encryptionKeys.append(QLatin1Char(','));
             encryptionKeys.append(d->m_additionalGpgKeys.join(QLatin1Char(',')));
           }
         }
         rc = d->saveFile(d->m_fileName, encryptionKeys);
         //write the directory used for this file as the default one for next time.
         writeLastUsedDir(newURL.toDisplayString(QUrl::RemoveFilename | QUrl::PreferLocalFile | QUrl::StripTrailingSlash));
         writeLastUsedFile(newName);
       }
       d->m_autoSaveTimer->stop();
       setEnabled(true);
     }
   }
 
   delete dlg;
   updateCaption();
   return rc;
 }
 
 void KMyMoneyApp::slotFileCloseWindow()
 {
   KMSTATUS(i18n("Closing window..."));
 
   if (d->dirty()) {
     int answer = askSaveOnClose();
     if (answer == KMessageBox::Cancel)
       return;
     else if (answer == KMessageBox::Yes)
       slotFileSave();
   }
   close();
 }
 
 void KMyMoneyApp::slotFileClose()
 {
 //  bool okToSelect = true;
 
   // check if transaction editor is open and ask user what he wants to do
 //  slotTransactionsCancelOrEnter(okToSelect);
 
 //  if (!okToSelect)
 //    return;
 
   // no update status here, as we might delete the status too early.
   if (d->dirty()) {
     int answer = askSaveOnClose();
     if (answer == KMessageBox::Cancel)
       return;
     else if (answer == KMessageBox::Yes)
       slotFileSave();
   }
 
   d->closeFile();
 }
 
 void KMyMoneyApp::slotFileQuit()
 {
   // don't modify the status message here as this will prevent quit from working!!
   // See the beginning of queryClose() and isReady() why. Thomas Baumgart 2005-10-17
 
   bool quitApplication = true;
 
   QList<KMainWindow*> memberList = KMainWindow::memberList();
   if (!memberList.isEmpty()) {
 
     QList<KMainWindow*>::const_iterator w_it = memberList.constBegin();
     for (; w_it != memberList.constEnd(); ++w_it) {
       // only close the window if the closeEvent is accepted. If the user presses Cancel on the saveModified() dialog,
       // the window and the application stay open.
       if (!(*w_it)->close()) {
         quitApplication = false;
         break;
       }
     }
   }
 
   // We will only quit if all windows were processed and not cancelled
   if (quitApplication) {
     QCoreApplication::quit();
   }
 }
 
 void KMyMoneyApp::slotShowTransactionDetail()
 {
 
 }
 
 void KMyMoneyApp::slotHideReconciledTransactions()
 {
   KMyMoneySettings::setHideReconciledTransactions(pActions[Action::ViewHideReconciled]->isChecked());
   d->m_myMoneyView->slotRefreshViews();
 }
 
 void KMyMoneyApp::slotHideUnusedCategories()
 {
   KMyMoneySettings::setHideUnusedCategory(pActions[Action::ViewHideCategories]->isChecked());
   d->m_myMoneyView->slotRefreshViews();
 }
 
 void KMyMoneyApp::slotShowAllAccounts()
 {
   KMyMoneySettings::setShowAllAccounts(pActions[Action::ViewShowAll]->isChecked());
   d->m_myMoneyView->slotRefreshViews();
 }
 
 #ifdef KMM_DEBUG
 void KMyMoneyApp::slotFileFileInfo()
 {
   if (!d->m_fileOpen) {
     KMessageBox::information(this, i18n("No KMyMoneyFile open"));
     return;
   }
 
   QFile g("kmymoney.dump");
   g.open(QIODevice::WriteOnly);
   QDataStream st(&g);
   MyMoneyStorageDump dumper;
   dumper.writeStream(st, MyMoneyFile::instance()->storage());
   g.close();
 }
 
 void KMyMoneyApp::slotToggleTraces()
 {
   MyMoneyTracer::onOff(pActions[Action::DebugTraces]->isChecked() ? 1 : 0);
 }
 #endif
 
 void KMyMoneyApp::slotToggleTimers()
 {
   extern bool timersOn; // main.cpp
 
   timersOn = pActions[Action::DebugTimers]->isChecked();
 }
 
 QString KMyMoneyApp::slotStatusMsg(const QString &text)
 {
   ///////////////////////////////////////////////////////////////////
   // change status message permanently
   QString previousMessage = d->m_statusLabel->text();
   d->m_applicationIsReady = false;
 
   QString currentMessage = text;
   if (currentMessage.isEmpty() || currentMessage == i18nc("Application is ready to use", "Ready.")) {
     d->m_applicationIsReady = true;
     currentMessage = i18nc("Application is ready to use", "Ready.");
   }
   statusBar()->clearMessage();
   d->m_statusLabel->setText(currentMessage);
   return previousMessage;
 }
 
 void KMyMoneyApp::ready()
 {
   slotStatusMsg(QString());
 }
 
 bool KMyMoneyApp::isReady()
 {
   return d->m_applicationIsReady;
 }
 
 void KMyMoneyApp::slotStatusProgressBar(int current, int total)
 {
   if (total == -1 && current == -1) {     // reset
     if (d->m_progressTimer) {
       d->m_progressTimer->start(500);     // remove from screen in 500 msec
       d->m_progressBar->setValue(d->m_progressBar->maximum());
     }
 
   } else if (total != 0) {                // init
     d->m_progressTimer->stop();
     d->m_progressBar->setMaximum(total);
     d->m_progressBar->setValue(0);
     d->m_progressBar->show();
 
   } else {                                // update
     QTime currentTime = QTime::currentTime();
     // only process painting if last update is at least 250 ms ago
     if (abs(d->m_lastUpdate.msecsTo(currentTime)) > 250) {
       d->m_progressBar->setValue(current);
       d->m_lastUpdate = currentTime;
     }
   }
 }
 
 void KMyMoneyApp::slotStatusProgressDone()
 {
   d->m_progressTimer->stop();
   d->m_progressBar->reset();
   d->m_progressBar->hide();
   d->m_progressBar->setValue(0);
 }
 
 void KMyMoneyApp::progressCallback(int current, int total, const QString& msg)
 {
   if (!msg.isEmpty())
     kmymoney->slotStatusMsg(msg);
 
   kmymoney->slotStatusProgressBar(current, total);
 }
 
 void KMyMoneyApp::slotFileViewPersonal()
 {
   if (!d->m_fileOpen) {
     KMessageBox::information(this, i18n("No KMyMoneyFile open"));
     return;
   }
 
   KMSTATUS(i18n("Viewing personal data..."));
 
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyPayee user = file->user();
 
   QPointer<EditPersonalDataDlg> editPersonalDataDlg = new EditPersonalDataDlg(user.name(), user.address(),
       user.city(), user.state(), user.postcode(), user.telephone(),
       user.email(), this, i18n("Edit Personal Data"));
 
   if (editPersonalDataDlg->exec() == QDialog::Accepted && editPersonalDataDlg != 0) {
     user.setName(editPersonalDataDlg->userName());
     user.setAddress(editPersonalDataDlg->userStreet());
     user.setCity(editPersonalDataDlg->userTown());
     user.setState(editPersonalDataDlg->userCountry());
     user.setPostcode(editPersonalDataDlg->userPostcode());
     user.setTelephone(editPersonalDataDlg->userTelephone());
     user.setEmail(editPersonalDataDlg->userEmail());
     MyMoneyFileTransaction ft;
     try {
       file->setUser(user);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to store user information: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to store user information: %1", QString::fromLatin1(e.what())));
     }
   }
   delete editPersonalDataDlg;
 }
 
 void KMyMoneyApp::slotLoadAccountTemplates()
 {
   KMSTATUS(i18n("Importing account templates."));
 
   int rc;
   QPointer<KLoadTemplateDlg> dlg = new KLoadTemplateDlg();
   if ((rc = dlg->exec()) == QDialog::Accepted && dlg != 0) {
     MyMoneyFileTransaction ft;
     try {
       // import the account templates
       QList<MyMoneyTemplate> templates = dlg->templates();
       QList<MyMoneyTemplate>::iterator it_t;
       for (it_t = templates.begin(); it_t != templates.end(); ++it_t) {
         (*it_t).importTemplate(&progressCallback);
       }
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(0, i18n("Error"), i18n("Unable to import template(s): %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to import template(s)"), QString::fromLatin1(e.what()));
     }
   }
   delete dlg;
 }
 
 void KMyMoneyApp::slotSaveAccountTemplates()
 {
   KMSTATUS(i18n("Exporting account templates."));
 
   QString savePath = QStandardPaths::writableLocation(QStandardPaths::DataLocation) + "/templates/" + QLocale().name();
   QDir templatesDir(savePath);
   if (!templatesDir.exists())
       templatesDir.mkpath(savePath);
   QString newName = QFileDialog::getSaveFileName(this, i18n("Save as..."), savePath,
                     i18n("KMyMoney template files (*.kmt);;All files (*)"));
 
   //
   // If there is no file extension, then append a .kmt at the end of the file name.
   // If there is a file extension, make sure it is .kmt, delete any others.
   //
   if (!newName.isEmpty()) {
     // find last . delimiter
     int nLoc = newName.lastIndexOf('.');
     if (nLoc != -1) {
       QString strExt, strTemp;
       strTemp = newName.left(nLoc + 1);
       strExt = newName.right(newName.length() - (nLoc + 1));
       if ((strExt.indexOf("kmt", 0, Qt::CaseInsensitive) == -1)) {
         strTemp.append("kmt");
         //append to make complete file name
         newName = strTemp;
       }
     } else {
       newName.append(".kmt");
     }
 
     if (okToWriteFile(QUrl::fromLocalFile(newName))) {
       QPointer <KTemplateExportDlg> dlg = new KTemplateExportDlg(this);
       if (dlg->exec() == QDialog::Accepted && dlg) {
           MyMoneyTemplate templ;
           templ.setTitle(dlg->title());
           templ.setShortDescription(dlg->shortDescription());
           templ.setLongDescription(dlg->longDescription());
           templ.exportTemplate(&progressCallback);
           templ.saveTemplate(QUrl::fromLocalFile(newName));
       }
       delete dlg;
     }
   }
 }
 
 bool KMyMoneyApp::okToWriteFile(const QUrl &url)
 {
   Q_UNUSED(url)
 
   // check if the file exists and warn the user
   bool reallySaveFile = true;
 
   if (KMyMoneyUtils::fileExists(url)) {
     if (KMessageBox::warningYesNo(this, QLatin1String("<qt>") + i18n("The file <b>%1</b> already exists. Do you really want to overwrite it?", url.toDisplayString(QUrl::PreferLocalFile)) + QLatin1String("</qt>"), i18n("File already exists")) != KMessageBox::Yes)
     reallySaveFile = false;
   }
   return reallySaveFile;
 }
 
 void KMyMoneyApp::slotSettings()
 {
   // if we already have an instance of the settings dialog, then use it
   if (KConfigDialog::showDialog("KMyMoney-Settings"))
     return;
 
   // otherwise, we have to create it
   auto dlg = new KSettingsKMyMoney(this, "KMyMoney-Settings", KMyMoneySettings::self());
   connect(dlg, &KSettingsKMyMoney::settingsChanged, this, &KMyMoneyApp::slotUpdateConfiguration);
   dlg->show();
 }
 
 void KMyMoneyApp::slotShowCredits()
 {
   KAboutData aboutData = initializeCreditsData();
   KAboutApplicationDialog dlg(aboutData, this);
   dlg.exec();
 }
 
 void KMyMoneyApp::slotUpdateConfiguration(const QString &dialogName)
 {
   if(dialogName.compare(QLatin1String("Plugins")) == 0) {
     KMyMoneyPlugin::pluginHandling(KMyMoneyPlugin::Action::Reorganize, d->m_plugins, this, guiFactory());
     onlineJobAdministration::instance()->updateActions();
     onlineJobAdministration::instance()->setOnlinePlugins(d->m_plugins.extended);
     d->m_myMoneyView->setOnlinePlugins(d->m_plugins.online);
     d->m_myMoneyView->setStoragePlugins(d->m_plugins.storage);
     return;
   }
   MyMoneyTransactionFilter::setFiscalYearStart(KMyMoneySettings::firstFiscalMonth(), KMyMoneySettings::firstFiscalDay());
 
 #ifdef ENABLE_UNFINISHEDFEATURES
   LedgerSeparator::setFirstFiscalDate(KMyMoneySettings::firstFiscalMonth(), KMyMoneySettings::firstFiscalDay());
 #endif
 
   d->m_myMoneyView->updateViewType();
 
   // update the sql storage module settings
 //  MyMoneyStorageSql::setStartDate(KMyMoneySettings::startDate().date());
 
   // update the report module settings
   MyMoneyReport::setLineWidth(KMyMoneySettings::lineWidth());
 
   // update the holiday region configuration
   setHolidayRegion(KMyMoneySettings::holidayRegion());
 
   d->m_myMoneyView->slotRefreshViews();
 
   // re-read autosave configuration
   d->m_autoSaveEnabled = KMyMoneySettings::autoSaveFile();
   d->m_autoSavePeriod = KMyMoneySettings::autoSavePeriod();
 
   // stop timer if turned off but running
   if (d->m_autoSaveTimer->isActive() && !d->m_autoSaveEnabled) {
     d->m_autoSaveTimer->stop();
   }
   // start timer if turned on and needed but not running
   if (!d->m_autoSaveTimer->isActive() && d->m_autoSaveEnabled && d->dirty()) {
     d->m_autoSaveTimer->setSingleShot(true);
     d->m_autoSaveTimer->start(d->m_autoSavePeriod * 60 * 1000);
   }
 
   d->setThemedCSS();
 
   // check if the recovery key is still valid or expires soon
 
   if (KMyMoneySettings::writeDataEncrypted() && KMyMoneySettings::encryptRecover()) {
     if (KGPGFile::GPGAvailable()) {
       KGPGFile file;
       QDateTime expirationDate = file.keyExpires(QLatin1String(recoveryKeyId2));
       if (expirationDate.isValid() && QDateTime::currentDateTime().daysTo(expirationDate) <= RECOVER_KEY_EXPIRATION_WARNING) {
         bool skipMessage = false;
 
         //get global config object for our app.
         KSharedConfigPtr kconfig = KSharedConfig::openConfig();
         KConfigGroup grp;
         QDate lastWarned;
         if (kconfig) {
           grp = d->m_config->group("General Options");
           lastWarned = grp.readEntry("LastRecoverKeyExpirationWarning", QDate());
           if (QDate::currentDate() == lastWarned) {
             skipMessage = true;
           }
         }
         if (!skipMessage) {
           if (kconfig) {
             grp.writeEntry("LastRecoverKeyExpirationWarning", QDate::currentDate());
           }
           KMessageBox::information(this, i18np("You have configured KMyMoney to use GPG to protect your data and to encrypt your data also with the KMyMoney recover key. This key is about to expire in %1 day. Please update the key from a keyserver using your GPG frontend (e.g. KGPG).", "You have configured KMyMoney to use GPG to protect your data and to encrypt your data also with the KMyMoney recover key. This key is about to expire in %1 days. Please update the key from a keyserver using your GPG frontend (e.g. KGPG).", QDateTime::currentDateTime().daysTo(expirationDate)), i18n("Recover key expires soon"));
         }
       }
     }
   }
 }
 
 void KMyMoneyApp::slotBackupFile()
 {
   // Save the file first so isLocalFile() works
   if (d->m_myMoneyView && d->dirty())
 
   {
     if (KMessageBox::questionYesNo(this, i18n("The file must be saved first "
                                    "before it can be backed up.  Do you want to continue?")) == KMessageBox::No) {
       return;
 
     }
 
     slotFileSave();
   }
 
 
 
   if (d->m_fileName.isEmpty())
     return;
 
   if (!d->m_fileName.isLocalFile()) {
     KMessageBox::sorry(this,
                        i18n("The current implementation of the backup functionality only supports local files as source files. Your current source file is '%1'.", d->m_fileName.url()),
 
                        i18n("Local files only"));
     return;
   }
 
   QPointer<KBackupDlg> backupDlg = new KBackupDlg(this);
   int returncode = backupDlg->exec();
   if (returncode == QDialog::Accepted && backupDlg != 0) {
 
 
     d->m_backupMount = backupDlg->mountCheckBoxChecked();
     d->m_proc.clearProgram();
     d->m_backupState = BACKUP_MOUNTING;
     d->m_mountpoint = backupDlg->mountPoint();
 
     if (d->m_backupMount) {
       slotBackupMount();
     } else {
       progressCallback(0, 300, "");
 #ifdef Q_OS_WIN
       d->m_ignoreBackupExitCode = true;
       QTimer::singleShot(0, this, SLOT(slotBackupHandleEvents()));
 #else
       // If we don't have to mount a device, we just issue
       // a dummy command to start the copy operation
       d->m_proc.setProgram("true");
       d->m_proc.start();
 #endif
     }
 
   }
 
   delete backupDlg;
 }
 
 void KMyMoneyApp::slotBackupMount()
 {
   progressCallback(0, 300, i18n("Mounting %1", d->m_mountpoint));
   d->m_proc.setProgram("mount");
   d->m_proc << d->m_mountpoint;
   d->m_proc.start();
 }
 
 bool KMyMoneyApp::slotBackupWriteFile()
 {
   QFileInfo fi(d->m_fileName.fileName());
   QString today = QDate::currentDate().toString("-yyyy-MM-dd.") + fi.suffix();
   QString backupfile = d->m_mountpoint + '/' + d->m_fileName.fileName();
   KMyMoneyUtils::appendCorrectFileExt(backupfile, today);
 
   // check if file already exists and ask what to do
   QFile f(backupfile);
   if (f.exists()) {
     int answer = KMessageBox::warningContinueCancel(this, i18n("Backup file for today exists on that device. Replace?"), i18n("Backup"), KGuiItem(i18n("&Replace")));
     if (answer == KMessageBox::Cancel) {
       return false;
     }
   }
 
   progressCallback(50, 0, i18n("Writing %1", backupfile));
   d->m_proc.clearProgram();
 #ifdef Q_OS_WIN
   d->m_proc << "cmd.exe" << "/c" << "copy" << "/b" << "/y";
   d->m_proc << (QDir::toNativeSeparators(d->m_fileName.toLocalFile()) + "+ nul") << QDir::toNativeSeparators(backupfile);
 #else
   d->m_proc << "cp" << "-f";
   d->m_proc << d->m_fileName.toLocalFile() << backupfile;
 #endif
   d->m_backupState = BACKUP_COPYING;
   d->m_proc.start();
   return true;
 }
 
 void KMyMoneyApp::slotBackupUnmount()
 {
   progressCallback(250, 0, i18n("Unmounting %1", d->m_mountpoint));
   d->m_proc.clearProgram();
   d->m_proc.setProgram("umount");
   d->m_proc << d->m_mountpoint;
   d->m_backupState = BACKUP_UNMOUNTING;
   d->m_proc.start();
 }
 
 void KMyMoneyApp::slotBackupFinish()
 {
   d->m_backupState = BACKUP_IDLE;
   progressCallback(-1, -1, QString());
   ready();
 }
 
 void KMyMoneyApp::slotBackupHandleEvents()
 {
   switch (d->m_backupState) {
     case BACKUP_MOUNTING:
 
       if (d->m_ignoreBackupExitCode ||
          (d->m_proc.exitStatus() == QProcess::NormalExit && d->m_proc.exitCode() == 0)) {
         d->m_ignoreBackupExitCode = false;
         d->m_backupResult = 0;
         if (!slotBackupWriteFile()) {
           d->m_backupResult = 1;
           if (d->m_backupMount)
             slotBackupUnmount();
           else
             slotBackupFinish();
         }
       } else {
         KMessageBox::information(this, i18n("Error mounting device"), i18n("Backup"));
         d->m_backupResult = 1;
         if (d->m_backupMount)
           slotBackupUnmount();
         else
           slotBackupFinish();
       }
       break;
 
     case BACKUP_COPYING:
       if (d->m_proc.exitStatus() == QProcess::NormalExit && d->m_proc.exitCode() == 0) {
 
         if (d->m_backupMount) {
           slotBackupUnmount();
         } else {
           progressCallback(300, 0, i18nc("Backup done", "Done"));
           KMessageBox::information(this, i18n("File successfully backed up"), i18n("Backup"));
           slotBackupFinish();
         }
       } else {
         qDebug("copy exit code is %d", d->m_proc.exitCode());
         d->m_backupResult = 1;
         KMessageBox::information(this, i18n("Error copying file to device"), i18n("Backup"));
         if (d->m_backupMount)
           slotBackupUnmount();
         else
           slotBackupFinish();
       }
       break;
 
 
     case BACKUP_UNMOUNTING:
       if (d->m_proc.exitStatus() == QProcess::NormalExit && d->m_proc.exitCode() == 0) {
 
         progressCallback(300, 0, i18nc("Backup done", "Done"));
         if (d->m_backupResult == 0)
           KMessageBox::information(this, i18n("File successfully backed up"), i18n("Backup"));
       } else {
         KMessageBox::information(this, i18n("Error unmounting device"), i18n("Backup"));
       }
       slotBackupFinish();
       break;
 
     default:
       qWarning("Unknown state for backup operation!");
       progressCallback(-1, -1, QString());
       ready();
       break;
   }
 }
 
 void KMyMoneyApp::slotShowTipOfTheDay()
 {
   KTipDialog::showTip(d->m_myMoneyView, "", true);
 }
 
 void KMyMoneyApp::slotShowPreviousView()
 {
 
 }
 
 void KMyMoneyApp::slotShowNextView()
 {
 
 }
 
 void KMyMoneyApp::slotGenerateSql()
 {
 //  QPointer<KGenerateSqlDlg> editor = new KGenerateSqlDlg(this);
 //  editor->setObjectName("Generate Database SQL");
 //  editor->exec();
 //  delete editor;
 }
 
 void KMyMoneyApp::slotToolsStartKCalc()
 {
   QString cmd = KMyMoneySettings::externalCalculator();
   // if none is present, we fall back to the default
   if (cmd.isEmpty()) {
 #if defined(Q_OS_WIN32)
     cmd = QLatin1String("calc");
 #elif defined(Q_OS_MAC)
     cmd = QLatin1String("open -a Calculator");
 #else
     cmd = QLatin1String("kcalc");
 #endif
   }
   KRun::runCommand(cmd, this);
 }
 
 void KMyMoneyApp::createAccount(MyMoneyAccount& newAccount, MyMoneyAccount& parentAccount, MyMoneyAccount& brokerageAccount, MyMoneyMoney openingBal)
 {
   MyMoneyFile *file = MyMoneyFile::instance();
   try {
     const MyMoneySecurity& sec = file->security(newAccount.currencyId());
     // Check the opening balance
     if (openingBal.isPositive() && newAccount.accountGroup() == eMyMoney::Account::Type::Liability) {
       QString message = i18n("This account is a liability and if the "
                              "opening balance represents money owed, then it should be negative.  "
                              "Negate the amount?\n\n"
                              "Please click Yes to change the opening balance to %1,\n"
                              "Please click No to leave the amount as %2,\n"
                              "Please click Cancel to abort the account creation."
                              , MyMoneyUtils::formatMoney(-openingBal, newAccount, sec)
                              , MyMoneyUtils::formatMoney(openingBal, newAccount, sec));
 
       int ans = KMessageBox::questionYesNoCancel(this, message);
       if (ans == KMessageBox::Yes) {
         openingBal = -openingBal;
 
       } else if (ans == KMessageBox::Cancel)
         return;
     }
 
     file->createAccount(newAccount, parentAccount, brokerageAccount, openingBal);
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::information(this, i18n("Unable to add account: %1", e.what()));
+    KMessageBox::information(this, i18n("Unable to add account: %1", QString::fromLatin1(e.what())));
   }
 }
 
 void KMyMoneyApp::slotInvestmentNew(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   KNewInvestmentWizard::newInvestment(account, parent);
 }
 
 void KMyMoneyApp::slotCategoryNew(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   KNewAccountDlg::newCategory(account, parent);
 }
 
 void KMyMoneyApp::slotCategoryNew(MyMoneyAccount& account)
 {
   KNewAccountDlg::newCategory(account, MyMoneyAccount());
 }
 
 void KMyMoneyApp::slotAccountNew(MyMoneyAccount& account)
 {
   NewAccountWizard::Wizard::newAccount(account);
 }
 
 void KMyMoneyApp::createSchedule(MyMoneySchedule newSchedule, MyMoneyAccount& newAccount)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   // Add the schedule only if one exists
   //
   // Remember to modify the first split to reference the newly created account
   if (!newSchedule.name().isEmpty()) {
     try {
       // We assume at least 2 splits in the transaction
       MyMoneyTransaction t = newSchedule.transaction();
       if (t.splitCount() < 2) {
-        throw MYMONEYEXCEPTION("Transaction for schedule has less than 2 splits!");
+        throw MYMONEYEXCEPTION_CSTRING("Transaction for schedule has less than 2 splits!");
       }
 
       MyMoneyFileTransaction ft;
       try {
         file->addSchedule(newSchedule);
 
         // in case of a loan account, we keep a reference to this
         // schedule in the account
         if (newAccount.accountType() == eMyMoney::Account::Type::Loan
             || newAccount.accountType() == eMyMoney::Account::Type::AssetLoan) {
           newAccount.setValue("schedule", newSchedule.id());
           file->modifyAccount(newAccount);
         }
         ft.commit();
       } catch (const MyMoneyException &e) {
-        KMessageBox::information(this, i18n("Unable to add scheduled transaction: %1", e.what()));
+        KMessageBox::information(this, i18n("Unable to add scheduled transaction: %1", QString::fromLatin1(e.what())));
       }
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to add scheduled transaction: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to add scheduled transaction: %1", QString::fromLatin1(e.what())));
     }
   }
 }
 
 QList<QPair<MyMoneyTransaction, MyMoneySplit> > KMyMoneyApp::Private::automaticReconciliation(const MyMoneyAccount &account,
     const QList<QPair<MyMoneyTransaction, MyMoneySplit> > &transactions,
     const MyMoneyMoney &amount)
 {
   static const int NR_OF_STEPS_LIMIT = 300000;
   static const int PROGRESSBAR_STEPS = 1000;
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > result = transactions;
 
   KMSTATUS(i18n("Running automatic reconciliation"));
   int progressBarIndex = 0;
   q->slotStatusProgressBar(progressBarIndex, NR_OF_STEPS_LIMIT / PROGRESSBAR_STEPS);
 
   // optimize the most common case - all transactions should be cleared
   QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplitResult(result);
   MyMoneyMoney transactionsBalance;
   while (itTransactionSplitResult.hasNext()) {
     const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplitResult.next();
     transactionsBalance += transactionSplit.second.shares();
   }
   if (amount == transactionsBalance) {
     result = transactions;
     return result;
   }
   q->slotStatusProgressBar(progressBarIndex++, 0);
   // only one transaction is uncleared
   itTransactionSplitResult.toFront();
   int index = 0;
   while (itTransactionSplitResult.hasNext()) {
     const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplitResult.next();
     if (transactionsBalance - transactionSplit.second.shares() == amount) {
       result.removeAt(index);
       return result;
     }
     index++;
   }
   q->slotStatusProgressBar(progressBarIndex++, 0);
 
   // more than one transaction is uncleared - apply the algorithm
   result.clear();
 
   const MyMoneySecurity &security = MyMoneyFile::instance()->security(account.currencyId());
   double precision = 0.1 / account.fraction(security);
 
   QList<MyMoneyMoney> sumList;
   sumList << MyMoneyMoney();
 
   QMap<MyMoneyMoney, QList<QPair<QString, QString> > > sumToComponentsMap;
 
   // compute the possible matches
   QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplit(transactions);
   while (itTransactionSplit.hasNext()) {
     const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplit.next();
     QListIterator<MyMoneyMoney> itSum(sumList);
     QList<MyMoneyMoney> tempList;
     while (itSum.hasNext()) {
       const MyMoneyMoney &sum = itSum.next();
       QList<QPair<QString, QString> > splitIds;
       splitIds << qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id());
       if (sumToComponentsMap.contains(sum)) {
         if (sumToComponentsMap.value(sum).contains(qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id()))) {
           continue;
         }
         splitIds.append(sumToComponentsMap.value(sum));
       }
       tempList << transactionSplit.second.shares() + sum;
       sumToComponentsMap[transactionSplit.second.shares() + sum] = splitIds;
       int size = sumToComponentsMap.size();
       if (size % PROGRESSBAR_STEPS == 0) {
         q->slotStatusProgressBar(progressBarIndex++, 0);
       }
       if (size > NR_OF_STEPS_LIMIT) {
         return result; // it's taking too much resources abort the algorithm
       }
     }
     QList<MyMoneyMoney> unionList;
     unionList.append(tempList);
     unionList.append(sumList);
     qSort(unionList);
     sumList.clear();
     MyMoneyMoney smallestSumFromUnion = unionList.first();
     sumList.append(smallestSumFromUnion);
     QListIterator<MyMoneyMoney> itUnion(unionList);
     while (itUnion.hasNext()) {
       MyMoneyMoney sumFromUnion = itUnion.next();
       if (smallestSumFromUnion < MyMoneyMoney(1 - precision / transactions.size())*sumFromUnion) {
         smallestSumFromUnion = sumFromUnion;
         sumList.append(sumFromUnion);
       }
     }
   }
 
   q->slotStatusProgressBar(NR_OF_STEPS_LIMIT / PROGRESSBAR_STEPS, 0);
   if (sumToComponentsMap.contains(amount)) {
     QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplit2(transactions);
     while (itTransactionSplit2.hasNext()) {
       const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplit2.next();
       const QList<QPair<QString, QString> > &splitIds = sumToComponentsMap.value(amount);
       if (splitIds.contains(qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id()))) {
         result.append(transactionSplit);
       }
     }
   }
 
 #ifdef KMM_DEBUG
   qDebug("For the amount %s a number of %d possible sums where computed from the set of %d transactions: ",
          qPrintable(MyMoneyUtils::formatMoney(amount, security)), sumToComponentsMap.size(), transactions.size());
 #endif
 
   q->slotStatusProgressBar(-1, -1);
   return result;
 }
 
 void KMyMoneyApp::slotReparentAccount(const MyMoneyAccount& _src, const MyMoneyInstitution& _dst)
 {
   MyMoneyAccount src(_src);
   src.setInstitutionId(_dst.id());
   MyMoneyFileTransaction ft;
   try {
     MyMoneyFile::instance()->modifyAccount(src);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::sorry(this, i18n("<p><b>%1</b> cannot be moved to institution <b>%2</b>. Reason: %3</p>", src.name(), _dst.name(), e.what()));
+    KMessageBox::sorry(this, i18n("<p><b>%1</b> cannot be moved to institution <b>%2</b>. Reason: %3</p>", src.name(), _dst.name(), QString::fromLatin1(e.what())));
   }
 }
 
 void KMyMoneyApp::slotReparentAccount(const MyMoneyAccount& _src, const MyMoneyAccount& _dst)
 {
   MyMoneyAccount src(_src);
   MyMoneyAccount dst(_dst);
   MyMoneyFileTransaction ft;
   try {
     MyMoneyFile::instance()->reparentAccount(src, dst);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::sorry(this, i18n("<p><b>%1</b> cannot be moved to <b>%2</b>. Reason: %3</p>", src.name(), dst.name(), e.what()));
+    KMessageBox::sorry(this, i18n("<p><b>%1</b> cannot be moved to <b>%2</b>. Reason: %3</p>", src.name(), dst.name(), QString::fromLatin1(e.what())));
   }
 }
 
 void KMyMoneyApp::slotScheduleNew(const MyMoneyTransaction& _t, eMyMoney::Schedule::Occurrence occurrence)
 {
   KEditScheduleDlg::newSchedule(_t, occurrence);
 }
 
 void KMyMoneyApp::slotPayeeNew(const QString& newnameBase, QString& id)
 {
   KMyMoneyUtils::newPayee(newnameBase, id);
 }
 
 void KMyMoneyApp::slotNewFeature()
 {
 }
 
 // move a stock transaction from one investment account to another
 void KMyMoneyApp::Private::moveInvestmentTransaction(const QString& /*fromId*/,
     const QString& toId,
     const MyMoneyTransaction& tx)
 {
   MyMoneyAccount toInvAcc = MyMoneyFile::instance()->account(toId);
   MyMoneyTransaction t(tx);
   // first determine which stock we are dealing with.
   // fortunately, investment transactions have only one stock involved
   QString stockAccountId;
   QString stockSecurityId;
   MyMoneySplit s;
   foreach (const auto split, t.splits()) {
     stockAccountId = split.accountId();
     stockSecurityId =
       MyMoneyFile::instance()->account(stockAccountId).currencyId();
     if (!MyMoneyFile::instance()->security(stockSecurityId).isCurrency()) {
       s = split;
       break;
     }
   }
   // Now check the target investment account to see if it
   // contains a stock with this id
   QString newStockAccountId;
   foreach (const auto sAccount, toInvAcc.accountList()) {
     if (MyMoneyFile::instance()->account(sAccount).currencyId() ==
         stockSecurityId) {
       newStockAccountId = sAccount;
       break;
     }
   }
   // if it doesn't exist, we need to add it as a copy of the old one
   // no 'copyAccount()' function??
   if (newStockAccountId.isEmpty()) {
     MyMoneyAccount stockAccount =
       MyMoneyFile::instance()->account(stockAccountId);
     MyMoneyAccount newStock;
     newStock.setName(stockAccount.name());
     newStock.setNumber(stockAccount.number());
     newStock.setDescription(stockAccount.description());
     newStock.setInstitutionId(stockAccount.institutionId());
     newStock.setOpeningDate(stockAccount.openingDate());
     newStock.setAccountType(stockAccount.accountType());
     newStock.setCurrencyId(stockAccount.currencyId());
     newStock.setClosed(stockAccount.isClosed());
     MyMoneyFile::instance()->addAccount(newStock, toInvAcc);
     newStockAccountId = newStock.id();
   }
   // now update the split and the transaction
   s.setAccountId(newStockAccountId);
   t.modifySplit(s);
   MyMoneyFile::instance()->modifyTransaction(t);
 }
 
 void KMyMoneyApp::showContextMenu(const QString& containerName)
 {
   QWidget* w = factory()->container(containerName, this);
   if (auto menu = dynamic_cast<QMenu*>(w))
     menu->exec(QCursor::pos());
   else
     qDebug("menu '%s' not found: w = %p, menu = %p", qPrintable(containerName), w, menu);
 }
 
 void KMyMoneyApp::slotPrintView()
 {
   d->m_myMoneyView->slotPrintView();
 }
 
 void KMyMoneyApp::updateCaption(bool skipActions)
 {
   QString caption;
 
   caption = d->m_fileName.fileName();
 
   if (caption.isEmpty() && d->m_myMoneyView && d->m_fileOpen)
     caption = i18n("Untitled");
 
   // MyMoneyFile::instance()->dirty() throws an exception, if
   // there's no storage object available. In this case, we
   // assume that the storage object is not changed. Actually,
   // this can only happen if we are newly created early on.
   bool modified;
   try {
     modified = MyMoneyFile::instance()->dirty();
   } catch (const MyMoneyException &) {
     modified = false;
     skipActions = true;
   }
 
 #ifdef KMM_DEBUG
   caption += QString(" (%1 x %2)").arg(width()).arg(height());
 #endif
 
   setCaption(caption, modified);
 
   if (!skipActions) {
     d->m_myMoneyView->enableViewsIfFileOpen(d->m_fileOpen);
     slotUpdateActions();
   }
 }
 
 void KMyMoneyApp::slotUpdateActions()
 {
   const auto file = MyMoneyFile::instance();
   const bool fileOpen = d->m_fileOpen;
   const bool modified = file->dirty();
 //  const bool importRunning = (d->m_smtReader != 0);
   auto aC = actionCollection();
 
   // *************
   // Disabling actions based on conditions
   // *************
   {
     QString tooltip = i18n("Create a new transaction");
     const QVector<QPair<Action, bool>> actionStates {
 //      {qMakePair(Action::FileOpenDatabase, true)},
 //      {qMakePair(Action::FileSaveAsDatabase, fileOpen)},
       {qMakePair(Action::FilePersonalData, fileOpen)},
       {qMakePair(Action::FileBackup, (fileOpen && !isDatabase()))},
       {qMakePair(Action::FileInformation, fileOpen)},
       {qMakePair(Action::FileImportTemplate, fileOpen/* && !importRunning*/)},
       {qMakePair(Action::FileExportTemplate, fileOpen/* && !importRunning*/)},
 #ifdef KMM_DEBUG
       {qMakePair(Action::FileDump, fileOpen)},
 #endif
       {qMakePair(Action::EditFindTransaction, fileOpen)},
       {qMakePair(Action::ToolCurrencies, fileOpen)},
       {qMakePair(Action::ToolPrices, fileOpen)},
       {qMakePair(Action::ToolUpdatePrices, fileOpen)},
       {qMakePair(Action::ToolConsistency, fileOpen)},
       {qMakePair(Action::NewAccount, fileOpen)},
       {qMakePair(Action::AccountCreditTransfer, onlineJobAdministration::instance()->canSendCreditTransfer())},
       {qMakePair(Action::NewInstitution, fileOpen)},
 //      {qMakePair(Action::TransactionNew, (fileOpen && d->m_myMoneyView->canCreateTransactions(KMyMoneyRegister::SelectedTransactions(), tooltip)))},
       {qMakePair(Action::NewSchedule, fileOpen)},
 //      {qMakePair(Action::CurrencyNew, fileOpen)},
 //      {qMakePair(Action::PriceNew, fileOpen)},
     };
 
     for (const auto& a : actionStates)
       pActions[a.first]->setEnabled(a.second);
   }
 
   // *************
   // Disabling standard actions based on conditions
   // *************
   aC->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Save)))->setEnabled(modified /*&& !d->m_myMoneyView->isDatabase()*/);
   aC->action(QString::fromLatin1(KStandardAction::name(KStandardAction::SaveAs)))->setEnabled(fileOpen);
   aC->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Close)))->setEnabled(fileOpen);
   aC->action(QString::fromLatin1(KStandardAction::name(KStandardAction::Print)))->setEnabled(fileOpen && d->m_myMoneyView->canPrint());
 }
 
 void KMyMoneyApp::slotResetSelections()
 {
   d->m_myMoneyView->slotObjectSelected(MyMoneyAccount());
   d->m_myMoneyView->slotObjectSelected(MyMoneyInstitution());
   d->m_myMoneyView->slotObjectSelected(MyMoneySchedule());
   d->m_myMoneyView->slotObjectSelected(MyMoneyTag());
   d->m_myMoneyView->slotSelectByVariant(QVariantList {QVariant::fromValue(KMyMoneyRegister::SelectedTransactions())}, eView::Intent::SelectRegisterTransactions);
   slotUpdateActions();
 }
 
 void KMyMoneyApp::slotDataChanged()
 {
   // As this method is called every time the MyMoneyFile instance
   // notifies a modification, it's the perfect place to start the timer if needed
   if (d->m_autoSaveEnabled && !d->m_autoSaveTimer->isActive()) {
     d->m_autoSaveTimer->setSingleShot(true);
     d->m_autoSaveTimer->start(d->m_autoSavePeriod * 60 * 1000);  //miliseconds
   }
   updateCaption();
 }
 
 void KMyMoneyApp::slotCurrencyDialog()
 {
   QPointer<KCurrencyEditDlg> dlg = new KCurrencyEditDlg(this);
   dlg->exec();
   delete dlg;
 }
 
 void KMyMoneyApp::slotPriceDialog()
 {
   QPointer<KMyMoneyPriceDlg> dlg = new KMyMoneyPriceDlg(this);
   dlg->exec();
   delete dlg;
 }
 
 void KMyMoneyApp::slotFileConsistencyCheck()
 {
   d->consistencyCheck(true);
   updateCaption();
 }
 
 void KMyMoneyApp::Private::consistencyCheck(bool alwaysDisplayResult)
 {
   KMSTATUS(i18n("Running consistency check..."));
 
   MyMoneyFileTransaction ft;
   try {
     m_consistencyCheckResult = MyMoneyFile::instance()->consistencyCheck();
     ft.commit();
   } catch (const MyMoneyException &e) {
     m_consistencyCheckResult.append(i18n("Consistency check failed: %1", e.what()));
     // always display the result if the check failed
     alwaysDisplayResult = true;
   }
 
   // in case the consistency check was OK, we get a single line as result
   // in all errneous cases, we get more than one line and force the
   // display of them.
 
   if (alwaysDisplayResult || m_consistencyCheckResult.size() > 1) {
     QString msg = i18n("The consistency check has found no issues in your data. Details are presented below.");
     if (m_consistencyCheckResult.size() > 1)
       msg = i18n("The consistency check has found some issues in your data. Details are presented below. Those issues that could not be corrected automatically need to be solved by the user.");
     // install a context menu for the list after the dialog is displayed
     QTimer::singleShot(500, q, SLOT(slotInstallConsistencyCheckContextMenu()));
     KMessageBox::informationList(0, msg, m_consistencyCheckResult, i18n("Consistency check result"));
   }
   // this data is no longer needed
   m_consistencyCheckResult.clear();
 }
 
 void KMyMoneyApp::Private::copyConsistencyCheckResults()
 {
   QClipboard *clipboard = QApplication::clipboard();
   clipboard->setText(m_consistencyCheckResult.join(QLatin1String("\n")));
 }
 
 void KMyMoneyApp::Private::saveConsistencyCheckResults()
 {
   QUrl fileUrl = QFileDialog::getSaveFileUrl(q);
 
   if (!fileUrl.isEmpty()) {
     QFile file(fileUrl.toLocalFile());
     if (file.open(QFile::WriteOnly | QFile::Append | QFile::Text)) {
       QTextStream out(&file);
       out << m_consistencyCheckResult.join(QLatin1String("\n"));
       file.close();
     }
   }
 }
 
 void KMyMoneyApp::Private::setThemedCSS()
 {
   const QStringList CSSnames {QStringLiteral("kmymoney.css"), QStringLiteral("welcome.css")};
 
   const QString rcDir("/html/");
   const QStringList defaultCSSDirs = QStandardPaths::locateAll(QStandardPaths::AppDataLocation, rcDir, QStandardPaths::LocateDirectory);
 
   // scan the list of directories to find the ones that really
   // contains all files we look for
   QString defaultCSSDir;
   foreach (const auto dir, defaultCSSDirs) {
     defaultCSSDir = dir;
     foreach (const auto CSSname, CSSnames) {
       QFileInfo fileInfo(defaultCSSDir + CSSname);
       if (!fileInfo.exists()) {
         defaultCSSDir.clear();
         break;
       }
     }
     if (!defaultCSSDir.isEmpty()) {
       break;
     }
   }
 
   // make sure we have the local directory where the themed version is stored
   const QString themedCSSDir  = QStandardPaths::standardLocations(QStandardPaths::AppConfigLocation).first() + rcDir;
   QDir().mkpath(themedCSSDir);
 
   foreach (const auto CSSname, CSSnames) {
     const QString defaultCSSFilename = defaultCSSDir + CSSname;
     QFileInfo fileInfo(defaultCSSFilename);
     if (fileInfo.exists()) {
       const QString themedCSSFilename = themedCSSDir + CSSname;
       QFile::remove(themedCSSFilename);
       if (QFile::copy(defaultCSSFilename, themedCSSFilename)) {
         QFile cssFile (themedCSSFilename);
         if (cssFile.open(QIODevice::ReadWrite)) {
           QTextStream cssStream(&cssFile);
           auto cssText = cssStream.readAll();
           cssText.replace(QLatin1String("./"), defaultCSSDir, Qt::CaseSensitive);
           cssText.replace(QLatin1String("WindowText"),    KMyMoneySettings::schemeColor(SchemeColor::WindowText).name(),        Qt::CaseSensitive);
           cssText.replace(QLatin1String("Window"),        KMyMoneySettings::schemeColor(SchemeColor::WindowBackground).name(),  Qt::CaseSensitive);
           cssText.replace(QLatin1String("HighlightText"), KMyMoneySettings::schemeColor(SchemeColor::ListHighlightText).name(), Qt::CaseSensitive);
           cssText.replace(QLatin1String("Highlight"),     KMyMoneySettings::schemeColor(SchemeColor::ListHighlight).name(),     Qt::CaseSensitive);
           cssText.replace(QLatin1String("black"),         KMyMoneySettings::schemeColor(SchemeColor::ListGrid).name(),          Qt::CaseSensitive);
           cssStream.seek(0);
           cssStream << cssText;
           cssFile.close();
         }
       }
     }
   }
 }
 
 void KMyMoneyApp::slotCheckSchedules()
 {
   if (KMyMoneySettings::checkSchedule() == true) {
 
     KMSTATUS(i18n("Checking for overdue scheduled transactions..."));
     MyMoneyFile *file = MyMoneyFile::instance();
     QDate checkDate = QDate::currentDate().addDays(KMyMoneySettings::checkSchedulePreview());
 
     QList<MyMoneySchedule> scheduleList =  file->scheduleList();
     QList<MyMoneySchedule>::Iterator it;
 
     eDialogs::ScheduleResultCode rc = eDialogs::ScheduleResultCode::Enter;
     for (it = scheduleList.begin(); (it != scheduleList.end()) && (rc != eDialogs::ScheduleResultCode::Cancel); ++it) {
       // Get the copy in the file because it might be modified by commitTransaction
       MyMoneySchedule schedule = file->schedule((*it).id());
 
       if (schedule.autoEnter()) {
         try {
           while (!schedule.isFinished() && (schedule.adjustedNextDueDate() <= checkDate)
                  && rc != eDialogs::ScheduleResultCode::Ignore
                  && rc != eDialogs::ScheduleResultCode::Cancel) {
             rc = d->m_myMoneyView->enterSchedule(schedule, true, true);
             schedule = file->schedule((*it).id()); // get a copy of the modified schedule
           }
         } catch (const MyMoneyException &) {
         }
       }
       if (rc == eDialogs::ScheduleResultCode::Ignore) {
         // if the current schedule was ignored then we must make sure that the user can still enter the next scheduled transaction
         rc = eDialogs::ScheduleResultCode::Enter;
       }
     }
     updateCaption();
   }
 }
 
 void KMyMoneyApp::writeLastUsedDir(const QString& directory)
 {
   //get global config object for our app.
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   if (kconfig) {
     KConfigGroup grp = kconfig->group("General Options");
 
     //write path entry, no error handling since its void.
     grp.writeEntry("LastUsedDirectory", directory);
   }
 }
 
 void KMyMoneyApp::writeLastUsedFile(const QString& fileName)
 {
   //get global config object for our app.
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   if (kconfig) {
     KConfigGroup grp = d->m_config->group("General Options");
 
     // write path entry, no error handling since its void.
     // use a standard string, as fileName could contain a protocol
     // e.g. file:/home/thb/....
     grp.writeEntry("LastUsedFile", fileName);
   }
 }
 
 QString KMyMoneyApp::readLastUsedDir() const
 {
   QString str;
 
   //get global config object for our app.
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   if (kconfig) {
     KConfigGroup grp = d->m_config->group("General Options");
 
     //read path entry.  Second parameter is the default if the setting is not found, which will be the default document path.
     str = grp.readEntry("LastUsedDirectory", QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation));
     // if the path stored is empty, we use the default nevertheless
     if (str.isEmpty())
       str = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
   }
 
   return str;
 }
 
 QString KMyMoneyApp::readLastUsedFile() const
 {
   QString str;
 
   // get global config object for our app.
   KSharedConfigPtr kconfig = KSharedConfig::openConfig();
   if (kconfig) {
     KConfigGroup grp = d->m_config->group("General Options");
 
     // read filename entry.
     str = grp.readEntry("LastUsedFile", "");
   }
 
   return str;
 }
 
 QString KMyMoneyApp::filename() const
 {
   return d->m_fileName.url();
 }
 
 QUrl KMyMoneyApp::filenameURL() const
 {
   return d->m_fileName;
 }
 
 void KMyMoneyApp::addToRecentFiles(const QUrl& url)
 {
   d->m_recentFiles->addUrl(url);
 }
 
 QTimer* KMyMoneyApp::autosaveTimer()
 {
   return d->m_autoSaveTimer;
 }
 
 WebConnect* KMyMoneyApp::webConnect() const
 {
   return d->m_webConnect;
 }
 
 QList<QString> KMyMoneyApp::instanceList() const
 {
   QList<QString> list;
 #ifdef KMM_DBUS
   QDBusReply<QStringList> reply = QDBusConnection::sessionBus().interface()->registeredServiceNames();
 
   if (reply.isValid()) {
     QStringList apps = reply.value();
     QStringList::ConstIterator it;
 
     // build a list of service names of all running kmymoney applications without this one
     for (it = apps.constBegin(); it != apps.constEnd(); ++it) {
       // please change this method of creating a list of 'all the other kmymoney instances that are running on the system'
       // since assuming that D-Bus creates service names with org.kde.kmymoney-PID is an observation I don't think that it's documented somwhere
       if ((*it).indexOf("org.kde.kmymoney-") == 0) {
         uint thisProcPid = platformTools::processId();
         if ((*it).indexOf(QString("org.kde.kmymoney-%1").arg(thisProcPid)) != 0)
           list += (*it);
       }
     }
   } else {
     qDebug("D-Bus returned the following error while obtaining instances: %s", qPrintable(reply.error().message()));
   }
 #endif
   return list;
 }
 
 void KMyMoneyApp::slotEquityPriceUpdate()
 {
   QPointer<KEquityPriceUpdateDlg> dlg = new KEquityPriceUpdateDlg(this);
   if (dlg->exec() == QDialog::Accepted && dlg != 0)
     dlg->storePrices();
   delete dlg;
 }
 
 void KMyMoneyApp::webConnect(const QString& sourceUrl, const QByteArray& asn_id)
 {
   //
   // Web connect attempts to go through the known importers and see if the file
   // can be importing using that method.  If so, it will import it using that
   // plugin
   //
 
   Q_UNUSED(asn_id)
 
   d->m_importUrlsQueue.enqueue(sourceUrl);
 
   // only start processing if this is the only import so far
   if (d->m_importUrlsQueue.count() == 1) {
     while (!d->m_importUrlsQueue.isEmpty()) {
       // get the value of the next item from the queue
       // but leave it on the queue for now
       QString url = d->m_importUrlsQueue.head();
 
       // Bring this window to the forefront.  This method was suggested by
       // Lubos Lunak <l.lunak@suse.cz> of the KDE core development team.
       // TODO: port KF5 (WebConnect)
       //KStartupInfo::setNewStartupId(this, asn_id);
 
       // Make sure we have an open file
       if (! d->m_fileOpen &&
           KMessageBox::warningContinueCancel(this, i18n("You must first select a KMyMoney file before you can import a statement.")) == KMessageBox::Continue)
         slotFileOpen();
 
       // only continue if the user really did open a file.
       if (d->m_fileOpen) {
         KMSTATUS(i18n("Importing a statement via Web Connect"));
 
         // remove the statement files
         d->unlinkStatementXML();
 
         QMap<QString, KMyMoneyPlugin::ImporterPlugin*>::const_iterator it_plugin = d->m_plugins.importer.constBegin();
         while (it_plugin != d->m_plugins.importer.constEnd()) {
           if ((*it_plugin)->isMyFormat(url)) {
             QList<MyMoneyStatement> statements;
             if (!(*it_plugin)->import(url)) {
               KMessageBox::error(this, i18n("Unable to import %1 using %2 plugin.  The plugin returned the following error: %3", url, (*it_plugin)->formatName(), (*it_plugin)->lastError()), i18n("Importing error"));
             }
 
             break;
           }
           ++it_plugin;
         }
 
         // If we did not find a match, try importing it as a KMM statement file,
         // which is really just for testing.  the statement file is not exposed
         // to users.
         if (it_plugin == d->m_plugins.importer.constEnd())
           if (MyMoneyStatement::isStatementFile(url))
             MyMoneyStatementReader::importStatement(url, false, &progressCallback);
 
       }
       // remove the current processed item from the queue
       d->m_importUrlsQueue.dequeue();
     }
   }
 }
 
 void KMyMoneyApp::slotEnableMessages()
 {
   KMessageBox::enableAllMessages();
   KMessageBox::information(this, i18n("All messages have been enabled."), i18n("All messages"));
 }
 
 void KMyMoneyApp::createInterfaces()
 {
   // Sets up the plugin interface
   KMyMoneyPlugin::pluginInterfaces().appInterface = new KMyMoneyPlugin::KMMAppInterface(this, this);
   KMyMoneyPlugin::pluginInterfaces().importInterface = new KMyMoneyPlugin::KMMImportInterface(this);
   KMyMoneyPlugin::pluginInterfaces().statementInterface = new KMyMoneyPlugin::KMMStatementInterface(this);
   KMyMoneyPlugin::pluginInterfaces().viewInterface = new KMyMoneyPlugin::KMMViewInterface(d->m_myMoneyView, this);
 
   // setup the calendar interface for schedules
   MyMoneySchedule::setProcessingCalendar(this);
 }
 
 void KMyMoneyApp::slotAutoSave()
 {
   if (!d->m_inAutoSaving) {
     // store the focus widget so we can restore it after save
     QPointer<QWidget> focusWidget = qApp->focusWidget();
     d->m_inAutoSaving = true;
     KMSTATUS(i18n("Auto saving..."));
 
     //calls slotFileSave if needed, and restart the timer
     //it the file is not saved, reinitializes the countdown.
     if (d->dirty() && d->m_autoSaveEnabled) {
       if (!slotFileSave() && d->m_autoSavePeriod > 0) {
         d->m_autoSaveTimer->setSingleShot(true);
         d->m_autoSaveTimer->start(d->m_autoSavePeriod * 60 * 1000);
       }
     }
 
     d->m_inAutoSaving = false;
     if (focusWidget && focusWidget != qApp->focusWidget()) {
       // we have a valid focus widget so restore it
       focusWidget->setFocus();
     }
   }
 }
 
 void KMyMoneyApp::slotDateChanged()
 {
   QDateTime dt = QDateTime::currentDateTime();
   QDateTime nextDay(QDate(dt.date().addDays(1)), QTime(0, 0, 0));
 
   // +1 is to make sure that we're already in the next day when the
   // signal is sent (this way we also avoid setting the timer to 0)
   QTimer::singleShot((dt.secsTo(nextDay) + 1)*1000, this, SLOT(slotDateChanged()));
   d->m_myMoneyView->slotRefreshViews();
 }
 
 void KMyMoneyApp::setHolidayRegion(const QString& holidayRegion)
 {
 #ifdef KF5Holidays_FOUND
   //since the cost of updating the cache is now not negligible
   //check whether the region has been modified
   if (!d->m_holidayRegion || d->m_holidayRegion->regionCode() != holidayRegion) {
     // Delete the previous holidayRegion before creating a new one.
     delete d->m_holidayRegion;
     // Create a new holidayRegion.
     d->m_holidayRegion = new KHolidays::HolidayRegion(holidayRegion);
 
     //clear and update the holiday cache
     preloadHolidays();
   }
 #else
   Q_UNUSED(holidayRegion);
 #endif
 }
 
 bool KMyMoneyApp::isProcessingDate(const QDate& date) const
 {
   if (!d->m_processingDays.testBit(date.dayOfWeek()))
     return false;
 #ifdef KF5Holidays_FOUND
   if (!d->m_holidayRegion || !d->m_holidayRegion->isValid())
     return true;
 
   //check first whether it's already in cache
   if (d->m_holidayMap.contains(date)) {
     return d->m_holidayMap.value(date, true);
   } else {
     bool processingDay = !d->m_holidayRegion->isHoliday(date);
     d->m_holidayMap.insert(date, processingDay);
     return processingDay;
   }
 #else
   return true;
 #endif
 }
 
 void KMyMoneyApp::preloadHolidays()
 {
 #ifdef KF5Holidays_FOUND
   //clear the cache before loading
   d->m_holidayMap.clear();
   //only do this if it is a valid region
   if (d->m_holidayRegion && d->m_holidayRegion->isValid()) {
     //load holidays for the forecast days plus 1 cycle, to be on the safe side
     int forecastDays = KMyMoneySettings::forecastDays() + KMyMoneySettings::forecastAccountCycle();
     QDate endDate = QDate::currentDate().addDays(forecastDays);
 
     //look for holidays for the next 2 years as a minimum. That should give a good margin for the cache
     if (endDate < QDate::currentDate().addYears(2))
       endDate = QDate::currentDate().addYears(2);
 
     KHolidays::Holiday::List holidayList = d->m_holidayRegion->holidays(QDate::currentDate(), endDate);
     KHolidays::Holiday::List::const_iterator holiday_it;
     for (holiday_it = holidayList.constBegin(); holiday_it != holidayList.constEnd(); ++holiday_it) {
       for (QDate holidayDate = (*holiday_it).observedStartDate(); holidayDate <= (*holiday_it).observedEndDate(); holidayDate = holidayDate.addDays(1))
         d->m_holidayMap.insert(holidayDate, false);
     }
 
     for (QDate date = QDate::currentDate(); date <= endDate; date = date.addDays(1)) {
       //if it is not a processing day, set it to false
       if (!d->m_processingDays.testBit(date.dayOfWeek())) {
         d->m_holidayMap.insert(date, false);
       } else if (!d->m_holidayMap.contains(date)) {
         //if it is not a holiday nor a weekend, it is a processing day
         d->m_holidayMap.insert(date, true);
       }
     }
   }
 #endif
 }
 
 KMStatus::KMStatus(const QString &text)
 {
   m_prevText = kmymoney->slotStatusMsg(text);
 }
 
 KMStatus::~KMStatus()
 {
   kmymoney->slotStatusMsg(m_prevText);
 }
 
 void KMyMoneyApp::Private::unlinkStatementXML()
 {
   QDir d(KMyMoneySettings::logPath(), "kmm-statement*");
   for (uint i = 0; i < d.count(); ++i) {
     qDebug("Remove %s", qPrintable(d[i]));
     d.remove(KMyMoneySettings::logPath() + QString("/%1").arg(d[i]));
   }
   m_statementXMLindex = 0;
 }
 
 void KMyMoneyApp::Private::closeFile()
 {
   m_myMoneyView->slotObjectSelected(MyMoneyAccount());
   m_myMoneyView->slotObjectSelected(MyMoneyInstitution());
   m_myMoneyView->slotObjectSelected(MyMoneySchedule());
   m_myMoneyView->slotObjectSelected(MyMoneyTag());
   m_myMoneyView->slotSelectByVariant(QVariantList {QVariant::fromValue(KMyMoneyRegister::SelectedTransactions())}, eView::Intent::SelectRegisterTransactions);
 
   m_myMoneyView->finishReconciliation(MyMoneyAccount());
 
   m_myMoneyView->slotFileClosed();
 
   disconnectStorageFromModels();
 
   // notify the models that the file is going to be closed (we should have something like dataChanged that reaches the models first)
   Models::instance()->fileClosed();
 
   emit q->kmmFilePlugin(KMyMoneyApp::preClose);
   if (q->isDatabase())
     MyMoneyFile::instance()->storage()->close(); // to log off a database user
   newStorage();
 
   emit q->kmmFilePlugin(postClose);
   m_fileOpen = false;
 
   m_fileName = QUrl();
   q->updateCaption();
 
   // just create a new balance warning object
   delete m_balanceWarning;
   m_balanceWarning = new KBalanceWarning(q);
 
   emit q->fileLoaded(m_fileName);
 }
diff --git a/kmymoney/kmymoneyutils.cpp b/kmymoney/kmymoneyutils.cpp
index 82a7107af..0662559b7 100644
--- a/kmymoney/kmymoneyutils.cpp
+++ b/kmymoney/kmymoneyutils.cpp
@@ -1,812 +1,810 @@
 /***************************************************************************
                           kmymoneyutils.cpp  -  description
                              -------------------
     begin                : Wed Feb 5 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kmymoneyutils.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QWidget>
 #include <QApplication>
 #include <QList>
 #include <QPixmap>
 #include <QWizard>
 #include <QAbstractButton>
 #include <QPixmapCache>
 #include <QIcon>
 #include <QPainter>
 #include <QBitArray>
 #include <QRegularExpression>
 #include <QRegularExpressionMatch>
 #include <QTemporaryFile>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <KColorScheme>
 #include <KLocalizedString>
 #include <KGuiItem>
 #include <KXmlGuiWindow>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KIO/StatJob>
 #include <KIO/StoredTransferJob>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyschedule.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneyprice.h"
 #include "mymoneystatement.h"
 #include "mymoneyforecast.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "kmymoneysettings.h"
 #include "icons.h"
 #include "storageenums.h"
 #include "mymoneyenums.h"
 
 using namespace Icons;
 
 KMyMoneyUtils::KMyMoneyUtils()
 {
 }
 
 KMyMoneyUtils::~KMyMoneyUtils()
 {
 }
 
 const QString KMyMoneyUtils::occurrenceToString(const eMyMoney::Schedule::Occurrence occurrence)
 {
   return i18nc("Frequency of schedule", MyMoneySchedule::occurrenceToString(occurrence).toLatin1());
 }
 
 const QString KMyMoneyUtils::paymentMethodToString(eMyMoney::Schedule::PaymentType paymentType)
 {
   return i18nc("Scheduled Transaction payment type", MyMoneySchedule::paymentMethodToString(paymentType).toLatin1());
 }
 
 const QString KMyMoneyUtils::weekendOptionToString(eMyMoney::Schedule::WeekendOption weekendOption)
 {
   return i18n(MyMoneySchedule::weekendOptionToString(weekendOption).toLatin1());
 }
 
 const QString KMyMoneyUtils::scheduleTypeToString(eMyMoney::Schedule::Type type)
 {
   return i18nc("Scheduled transaction type", MyMoneySchedule::scheduleTypeToString(type).toLatin1());
 }
 
 KGuiItem KMyMoneyUtils::scheduleNewGuiItem()
 {
   KGuiItem splitGuiItem(i18n("&New Schedule..."),
                         Icons::get(Icon::DocumentNew),
                         i18n("Create a new schedule."),
                         i18n("Use this to create a new schedule."));
 
   return splitGuiItem;
 }
 
 KGuiItem KMyMoneyUtils::accountsFilterGuiItem()
 {
   KGuiItem splitGuiItem(i18n("&Filter"),
                         Icons::get(Icon::ViewFilter),
                         i18n("Filter out accounts"),
                         i18n("Use this to filter out accounts"));
 
   return splitGuiItem;
 }
 
 const char* homePageItems[] = {
   I18N_NOOP("Payments"),
   I18N_NOOP("Preferred accounts"),
   I18N_NOOP("Payment accounts"),
   I18N_NOOP("Favorite reports"),
   I18N_NOOP("Forecast (schedule)"),
   I18N_NOOP("Net worth forecast"),
   I18N_NOOP("Forecast (history)"),
   I18N_NOOP("Assets and Liabilities"),
   I18N_NOOP("Budget"),
   I18N_NOOP("CashFlow"),
   // insert new items above this comment
   0
 };
 
 const QString KMyMoneyUtils::homePageItemToString(const int idx)
 {
   QString rc;
   if (abs(idx) > 0 && abs(idx) < static_cast<int>(sizeof(homePageItems) / sizeof(homePageItems[0]))) {
     rc = i18n(homePageItems[abs(idx-1)]);
   }
   return rc;
 }
 
 int KMyMoneyUtils::stringToHomePageItem(const QString& txt)
 {
   int idx = 0;
   for (idx = 0; homePageItems[idx] != 0; ++idx) {
     if (txt == i18n(homePageItems[idx]))
       return idx + 1;
   }
   return 0;
 }
 
 bool KMyMoneyUtils::appendCorrectFileExt(QString& str, const QString& strExtToUse)
 {
   bool rc = false;
 
   if (!str.isEmpty()) {
     //find last . delminator
     int nLoc = str.lastIndexOf('.');
     if (nLoc != -1) {
       QString strExt, strTemp;
       strTemp = str.left(nLoc + 1);
       strExt = str.right(str.length() - (nLoc + 1));
       if (strExt.indexOf(strExtToUse, 0, Qt::CaseInsensitive) == -1) {
         // if the extension given contains a period, we remove our's
         if (strExtToUse.indexOf('.') != -1)
           strTemp = strTemp.left(strTemp.length() - 1);
         //append extension to make complete file name
         strTemp.append(strExtToUse);
         str = strTemp;
         rc = true;
       }
     } else {
       str.append(QLatin1Char('.'));
       str.append(strExtToUse);
       rc = true;
     }
   }
   return rc;
 }
 
 void KMyMoneyUtils::checkConstants()
 {
   // TODO: port to kf5
 #if 0
   Q_ASSERT(static_cast<int>(KLocale::ParensAround) == static_cast<int>(MyMoneyMoney::ParensAround));
   Q_ASSERT(static_cast<int>(KLocale::BeforeQuantityMoney) == static_cast<int>(MyMoneyMoney::BeforeQuantityMoney));
   Q_ASSERT(static_cast<int>(KLocale::AfterQuantityMoney) == static_cast<int>(MyMoneyMoney::AfterQuantityMoney));
   Q_ASSERT(static_cast<int>(KLocale::BeforeMoney) == static_cast<int>(MyMoneyMoney::BeforeMoney));
   Q_ASSERT(static_cast<int>(KLocale::AfterMoney) == static_cast<int>(MyMoneyMoney::AfterMoney));
 #endif
 }
 
 QString KMyMoneyUtils::variableCSS()
 {
   QColor tcolor = KColorScheme(QPalette::Active).foreground(KColorScheme::NormalText).color();
   QColor link = KColorScheme(QPalette::Active).foreground(KColorScheme::LinkText).color();
 
   QString css;
   css += "<style type=\"text/css\">\n<!--\n";
   css += QString(".row-even, .item0 { background-color: %1; color: %2 }\n")
          .arg(KMyMoneySettings::schemeColor(SchemeColor::ListBackground1).name()).arg(tcolor.name());
   css += QString(".row-odd, .item1  { background-color: %1; color: %2 }\n")
          .arg(KMyMoneySettings::schemeColor(SchemeColor::ListBackground2).name()).arg(tcolor.name());
   css += QString("a { color: %1 }\n").arg(link.name());
   css += "-->\n</style>\n";
   return css;
 }
 
 QString KMyMoneyUtils::findResource(QStandardPaths::StandardLocation type, const QString& filename)
 {
   QLocale locale;
   QString country;
   QString localeName = locale.bcp47Name();
   QString language = localeName;
 
   // extract language and country from the bcp47name
   QRegularExpression regExp(QLatin1String("(\\w+)_(\\w+)"));
   QRegularExpressionMatch match = regExp.match(localeName);
   if (match.hasMatch()) {
     language = match.captured(1);
     country = match.captured(2);
   }
 
   QString rc;
 
   // check that the placeholder is present and set things up
   if (filename.indexOf("%1") != -1) {
     /// @fixme somehow I have the impression, that language and country
     ///    mappings to the filename are not correct. This certainly must
     ///    be overhauled at some point in time (ipwizard, 2017-10-22)
     QString mask = filename.arg("_%1.%2");
     rc = QStandardPaths::locate(type, mask.arg(country).arg(language));
 
     // search the given resource
     if (rc.isEmpty()) {
         mask = filename.arg("_%1");
         rc = QStandardPaths::locate(type, mask.arg(language));
     }
     if (rc.isEmpty()) {
         // qDebug(QString("html/home_%1.html not found").arg(country).toLatin1());
         rc = QStandardPaths::locate(type, mask.arg(country));
     }
     if (rc.isEmpty()) {
         rc = QStandardPaths::locate(type, filename.arg(""));
     }
   } else {
     rc = QStandardPaths::locate(type, filename);
   }
 
   if (rc.isEmpty()) {
     qWarning("No resource found for (%s,%s)", qPrintable(QStandardPaths::displayName(type)), qPrintable(filename));
   }
   return rc;
 }
 
 const MyMoneySplit KMyMoneyUtils::stockSplit(const MyMoneyTransaction& t)
 {
   MyMoneySplit investmentAccountSplit;
   foreach (const auto split, t.splits()) {
     if (!split.accountId().isEmpty()) {
       auto acc = MyMoneyFile::instance()->account(split.accountId());
       if (acc.isInvest()) {
         return split;
       }
       // if we have a reference to an investment account, we remember it here
       if (acc.accountType() == eMyMoney::Account::Type::Investment)
         investmentAccountSplit = split;
     }
   }
   // if we haven't found a stock split, we see if we've seen
   // an investment account on the way. If so, we return it.
   if (!investmentAccountSplit.id().isEmpty())
     return investmentAccountSplit;
 
   // if none was found, we return an empty split.
   return MyMoneySplit();
 }
 
 KMyMoneyUtils::transactionTypeE KMyMoneyUtils::transactionType(const MyMoneyTransaction& t)
 {
   if (!stockSplit(t).id().isEmpty())
     return InvestmentTransaction;
 
   if (t.splitCount() < 2) {
     return Unknown;
   } else if (t.splitCount() > 2) {
     // FIXME check for loan transaction here
     return SplitTransaction;
   }
   QString ida, idb;
   if (t.splits().size() > 0)
     ida = t.splits()[0].accountId();
   if (t.splits().size() > 1)
     idb = t.splits()[1].accountId();
   if (ida.isEmpty() || idb.isEmpty())
     return Unknown;
 
   MyMoneyAccount a, b;
   a = MyMoneyFile::instance()->account(ida);
   b = MyMoneyFile::instance()->account(idb);
   if ((a.accountGroup() == eMyMoney::Account::Type::Asset
        || a.accountGroup() == eMyMoney::Account::Type::Liability)
       && (b.accountGroup() == eMyMoney::Account::Type::Asset
           || b.accountGroup() == eMyMoney::Account::Type::Liability))
     return Transfer;
   return Normal;
 }
 
 void KMyMoneyUtils::calculateAutoLoan(const MyMoneySchedule& schedule, MyMoneyTransaction& transaction, const QMap<QString, MyMoneyMoney>& balances)
 {
   try {
     MyMoneyForecast::calculateAutoLoan(schedule, transaction, balances);
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedError(0, i18n("Unable to load schedule details"), e.what());
+    KMessageBox::detailedError(0, i18n("Unable to load schedule details"), QString::fromLatin1(e.what()));
   }
 }
 
 QString KMyMoneyUtils::nextCheckNumber(const MyMoneyAccount& acc)
 {
   QString number;
   //                   +-#1--+ +#2++-#3-++-#4--+
   QRegExp exp(QString("(.*\\D)?(0*)(\\d+)(\\D.*)?"));
   if (exp.indexIn(acc.value("lastNumberUsed")) != -1) {
     setLastNumberUsed(acc.value("lastNumberUsed"));
     QString arg1 = exp.cap(1);
     QString arg2 = exp.cap(2);
     QString arg3 = QString::number(exp.cap(3).toULong() + 1);
     QString arg4 = exp.cap(4);
     number = QString("%1%2%3%4").arg(arg1).arg(arg2).arg(arg3).arg(arg4);
 
     // if new number is longer than previous one and we identified
     // preceding 0s, then remove one of the preceding zeros
     if (arg2.length() > 0 && (number.length() != acc.value("lastNumberUsed").length())) {
       arg2 = arg2.mid(1);
       number = QString("%1%2%3%4").arg(arg1).arg(arg2).arg(arg3).arg(arg4);
     }
   } else {
     number = '1';
   }
   return number;
 }
 
 void KMyMoneyUtils::updateLastNumberUsed(const MyMoneyAccount& acc, const QString& number)
 {
   MyMoneyAccount accnt = acc;
   QString num = number;
   // now check if this number has been used already
   auto file = MyMoneyFile::instance();
   if (file->checkNoUsed(accnt.id(), num)) {
     // if a number has been entered which is immediately prior to
     // an existing number, the next new number produced would clash
     // so need to look ahead for free next number
     bool free = false;
     for (int i = 0; i < 10; i++) {
       // find next unused number - 10 tries (arbitrary)
       if (file->checkNoUsed(accnt.id(), num)) {
         //  increment and try again
         num = getAdjacentNumber(num);
       } else {
         //  found a free number
         free = true;
         break;
       }
     }
     if (!free) {
       qDebug() << "No free number found - set to '1'";
       num = '1';
     }
     setLastNumberUsed(getAdjacentNumber(num, - 1));
   }
 }
 
 void KMyMoneyUtils::setLastNumberUsed(const QString& num)
 {
   m_lastNumberUsed = num;
 }
 
 QString KMyMoneyUtils::lastNumberUsed()
 {
   return m_lastNumberUsed;
 }
 
 QString KMyMoneyUtils::getAdjacentNumber(const QString& number, int offset)
 {
   QString num = number;
   //                   +-#1--+ +#2++-#3-++-#4--+
   QRegExp exp(QString("(.*\\D)?(0*)(\\d+)(\\D.*)?"));
   if (exp.indexIn(num) != -1) {
     QString arg1 = exp.cap(1);
     QString arg2 = exp.cap(2);
     QString arg3 = QString::number(exp.cap(3).toULong() + offset);
     QString arg4 = exp.cap(4);
     num = QString("%1%2%3%4").arg(arg1).arg(arg2).arg(arg3).arg(arg4);
   } else {
     num = '1';
   }  //  next free number
   return num;
 }
 
 quint64 KMyMoneyUtils::numericPart(const QString & num)
 {
   quint64 num64 = 0;
   QRegExp exp(QString("(.*\\D)?(0*)(\\d+)(\\D.*)?"));
   if (exp.indexIn(num) != -1) {
     QString arg1 = exp.cap(1);
     QString arg2 = exp.cap(2);
     QString arg3 = QString::number(exp.cap(3).toULongLong());
     QString arg4 = exp.cap(4);
     num64 = QString("%2%3").arg(arg2).arg(arg3).toULongLong();
   }
   return num64;
 }
 
 QString KMyMoneyUtils::reconcileStateToString(eMyMoney::Split::State flag, bool text)
 {
   QString txt;
   if (text) {
     switch (flag) {
       case eMyMoney::Split::State::NotReconciled:
         txt = i18nc("Reconciliation state 'Not reconciled'", "Not reconciled");
         break;
       case eMyMoney::Split::State::Cleared:
         txt = i18nc("Reconciliation state 'Cleared'", "Cleared");
         break;
       case eMyMoney::Split::State::Reconciled:
         txt = i18nc("Reconciliation state 'Reconciled'", "Reconciled");
         break;
       case eMyMoney::Split::State::Frozen:
         txt = i18nc("Reconciliation state 'Frozen'", "Frozen");
         break;
       default:
         txt = i18nc("Unknown reconciliation state", "Unknown");
         break;
     }
   } else {
     switch (flag) {
       case eMyMoney::Split::State::NotReconciled:
         break;
       case eMyMoney::Split::State::Cleared:
         txt = i18nc("Reconciliation flag C", "C");
         break;
       case eMyMoney::Split::State::Reconciled:
         txt = i18nc("Reconciliation flag R", "R");
         break;
       case eMyMoney::Split::State::Frozen:
         txt = i18nc("Reconciliation flag F", "F");
         break;
       default:
         txt = i18nc("Flag for unknown reconciliation state", "?");
         break;
     }
   }
   return txt;
 }
 
 MyMoneyTransaction KMyMoneyUtils::scheduledTransaction(const MyMoneySchedule& schedule)
 {
   MyMoneyTransaction t = schedule.transaction();
 
   try {
     if (schedule.type() == eMyMoney::Schedule::Type::LoanPayment) {
       calculateAutoLoan(schedule, t, QMap<QString, MyMoneyMoney>());
     }
   } catch (const MyMoneyException &e) {
-    qDebug("Unable to load schedule details for '%s' during transaction match: %s", qPrintable(schedule.name()), qPrintable(e.what()));
+    qDebug("Unable to load schedule details for '%s' during transaction match: %s", qPrintable(schedule.name()), e.what());
   }
 
   t.clearId();
   t.setEntryDate(QDate());
   return t;
 }
 
 KXmlGuiWindow* KMyMoneyUtils::mainWindow()
 {
   foreach (QWidget *widget, QApplication::topLevelWidgets()) {
     KXmlGuiWindow* result = dynamic_cast<KXmlGuiWindow*>(widget);
     if (result)
       return result;
   }
   return 0;
 }
 
 void KMyMoneyUtils::updateWizardButtons(QWizard* wizard)
 {
   // setup text on buttons
   wizard->setButtonText(QWizard::NextButton, i18nc("Go to next page of the wizard", "&Next"));
   wizard->setButtonText(QWizard::BackButton, KStandardGuiItem::back().text());
 
   // setup icons
   wizard->button(QWizard::FinishButton)->setIcon(KStandardGuiItem::ok().icon());
   wizard->button(QWizard::CancelButton)->setIcon(KStandardGuiItem::cancel().icon());
   wizard->button(QWizard::NextButton)->setIcon(KStandardGuiItem::forward(KStandardGuiItem::UseRTL).icon());
   wizard->button(QWizard::BackButton)->setIcon(KStandardGuiItem::back(KStandardGuiItem::UseRTL).icon());
 }
 
 void KMyMoneyUtils::dissectTransaction(const MyMoneyTransaction& transaction, const MyMoneySplit& split, MyMoneySplit& assetAccountSplit, QList<MyMoneySplit>& feeSplits, QList<MyMoneySplit>& interestSplits, MyMoneySecurity& security, MyMoneySecurity& currency, eMyMoney::Split::InvestmentTransactionType& 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
   assetAccountSplit = MyMoneySplit(); // set to none to check later if it was assigned
   auto file = MyMoneyFile::instance();
   foreach (const auto tsplit, transaction.splits()) {
     auto acc = file->account(tsplit.accountId());
     if (tsplit.id() == split.id()) {
       security = file->security(acc.currencyId());
     } else if (acc.accountGroup() == eMyMoney::Account::Type::Expense) {
       feeSplits.append(tsplit);
       // feeAmount += tsplit.value();
     } else if (acc.accountGroup() == eMyMoney::Account::Type::Income) {
       interestSplits.append(tsplit);
       // interestAmount += tsplit.value();
     } else {
       if (assetAccountSplit == MyMoneySplit()) // first asset Account should be our requested brokerage account
         assetAccountSplit = tsplit;
       else if (tsplit.value().isNegative())  // the rest (if present) is handled as fee or interest
         feeSplits.append(tsplit);              // and shouldn't be allowed to override assetAccountSplit
       else if (tsplit.value().isPositive())
         interestSplits.append(tsplit);
     }
   }
 
   // determine transaction type
   if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::AddShares)) {
     transactionType = (!split.shares().isNegative()) ? eMyMoney::Split::InvestmentTransactionType::AddShares : eMyMoney::Split::InvestmentTransactionType::RemoveShares;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) {
     transactionType = (!split.value().isNegative()) ? eMyMoney::Split::InvestmentTransactionType::BuyShares : eMyMoney::Split::InvestmentTransactionType::SellShares;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend)) {
     transactionType = eMyMoney::Split::InvestmentTransactionType::Dividend;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend)) {
     transactionType = eMyMoney::Split::InvestmentTransactionType::ReinvestDividend;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Yield)) {
     transactionType = eMyMoney::Split::InvestmentTransactionType::Yield;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares)) {
     transactionType = eMyMoney::Split::InvestmentTransactionType::SplitShares;
   } else if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::InterestIncome)) {
     transactionType = eMyMoney::Split::InvestmentTransactionType::InterestIncome;
   } else
     transactionType = eMyMoney::Split::InvestmentTransactionType::BuyShares;
 
   currency.setTradingSymbol("???");
   try {
     currency = file->security(transaction.commodity());
   } catch (const MyMoneyException &) {
   }
 }
 
 void KMyMoneyUtils::processPriceList(const MyMoneyStatement &st)
 {
   auto file = MyMoneyFile::instance();
   QHash<QString, MyMoneySecurity> secBySymbol;
   QHash<QString, MyMoneySecurity> secByName;
 
   for (const auto& sec : file->securityList()) {
     secBySymbol[sec.tradingSymbol()] = sec;
     secByName[sec.name()] = sec;
   }
 
   for (const auto& stPrice : st.m_listPrices) {
     auto currency = file->baseCurrency().id();
     QString security;
 
     if (!stPrice.m_strCurrency.isEmpty()) {
       security = stPrice.m_strSecurity;
       currency = stPrice.m_strCurrency;
     } else if (secBySymbol.contains(stPrice.m_strSecurity)) {
       security = secBySymbol[stPrice.m_strSecurity].id();
       currency = file->security(file->security(security).tradingCurrency()).id();
     } else if (secByName.contains(stPrice.m_strSecurity)) {
       security = secByName[stPrice.m_strSecurity].id();
       currency = file->security(file->security(security).tradingCurrency()).id();
     } else
       return;
 
     MyMoneyPrice price(security,
                        currency,
                        stPrice.m_date,
                        stPrice.m_amount, stPrice.m_sourceName.isEmpty() ? i18n("Prices Importer") : stPrice.m_sourceName);
     file->addPrice(price);
   }
 }
 
 void KMyMoneyUtils::deleteSecurity(const MyMoneySecurity& security, QWidget* parent)
 {
   QString msg, msg2;
   QString dontAsk, dontAsk2;
   if (security.isCurrency()) {
     msg = i18n("<p>Do you really want to remove the currency <b>%1</b> from the file?</p>", security.name());
     msg2 = i18n("<p>All exchange rates for currency <b>%1</b> will be lost.</p><p>Do you still want to continue?</p>", security.name());
     dontAsk = "DeleteCurrency";
     dontAsk2 = "DeleteCurrencyRates";
   } else {
     msg = i18n("<p>Do you really want to remove the %1 <b>%2</b> from the file?</p>", MyMoneySecurity::securityTypeToString(security.securityType()), security.name());
     msg2 = i18n("<p>All price quotes for %1 <b>%2</b> will be lost.</p><p>Do you still want to continue?</p>", MyMoneySecurity::securityTypeToString(security.securityType()), security.name());
     dontAsk = "DeleteSecurity";
     dontAsk2 = "DeleteSecurityPrices";
   }
   if (KMessageBox::questionYesNo(parent, msg, i18n("Delete security"), KStandardGuiItem::yes(), KStandardGuiItem::no(), dontAsk) == KMessageBox::Yes) {
     MyMoneyFileTransaction ft;
     auto file = MyMoneyFile::instance();
 
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(true);
     skip.clearBit((int)eStorage::Reference::Price);
     if (file->isReferenced(security, skip)) {
       if (KMessageBox::questionYesNo(parent, msg2, i18n("Delete prices"), KStandardGuiItem::yes(), KStandardGuiItem::no(), dontAsk2) == KMessageBox::Yes) {
         try {
           QString secID = security.id();
           foreach (auto priceEntry, file->priceList()) {
             const MyMoneyPrice& price = priceEntry.first();
             if (price.from() == secID || price.to() == secID)
               file->removePrice(price);
           }
           ft.commit();
           ft.restart();
         } catch (const MyMoneyException &) {
           qDebug("Cannot delete price");
           return;
         }
       } else
         return;
     }
     try {
       if (security.isCurrency())
         file->removeCurrency(security);
       else
         file->removeSecurity(security);
       ft.commit();
     } catch (const MyMoneyException &) {
     }
   }
 }
 
 bool KMyMoneyUtils::fileExists(const QUrl &url)
 {
     bool fileExists = false;
     if (url.isValid()) {
         short int detailLevel = 0; // Lowest level: file/dir/symlink/none
         KIO::StatJob* statjob = KIO::stat(url, KIO::StatJob::SourceSide, detailLevel);
         bool noerror = statjob->exec();
         if (noerror) {
             // We want a file
             fileExists = !statjob->statResult().isDir();
         }
         statjob->kill();
     }
     return fileExists;
 }
 
 QString KMyMoneyUtils::downloadFile(const QUrl &url)
 {
   QString filename;
   KIO::StoredTransferJob *transferjob = KIO::storedGet (url);
 //  KJobWidgets::setWindow(transferjob, this);
   if (! transferjob->exec()) {
       KMessageBox::detailedError(nullptr,
                                i18n("Error while loading file '%1'.", url.url()),
                                transferjob->errorString(),
                                i18n("File access error"));
       return filename;
   }
 
   QTemporaryFile file;
   file.setAutoRemove(false);
   file.open();
   file.write(transferjob->data());
   filename = file.fileName();
   file.close();
   return filename;
 }
 
 bool KMyMoneyUtils::newPayee(const QString& newnameBase, QString& id)
 {
   bool doit = true;
 
   if (newnameBase != i18n("New Payee")) {
     // Ask the user if that is what he intended to do?
     const auto msg = i18n("<qt>Do you want to add <b>%1</b> as payer/receiver?</qt>", newnameBase);
 
     if (KMessageBox::questionYesNo(nullptr, msg, i18n("New payee/receiver"), KStandardGuiItem::yes(), KStandardGuiItem::no(), "NewPayee") == KMessageBox::No) {
       doit = false;
       // we should not keep the 'no' setting because that can confuse people like
       // I have seen in some usability tests. So we just delete it right away.
       KSharedConfigPtr kconfig = KSharedConfig::openConfig();
       if (kconfig) {
         kconfig->group(QLatin1String("Notification Messages")).deleteEntry(QLatin1String("NewPayee"));
       }
     }
   }
 
   if (doit) {
     MyMoneyFileTransaction ft;
     try {
       QString newname(newnameBase);
       // adjust name until a unique name has been created
       int count = 0;
       for (;;) {
         try {
           MyMoneyFile::instance()->payeeByName(newname);
           newname = QString::fromLatin1("%1 [%2]").arg(newnameBase).arg(++count);
         } catch (const MyMoneyException &) {
           break;
         }
       }
 
       MyMoneyPayee p;
       p.setName(newname);
       MyMoneyFile::instance()->addPayee(p);
       id = p.id();
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(nullptr, i18n("Unable to add payee"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(nullptr, i18n("Unable to add payee"), QString::fromLatin1(e.what()));
       doit = false;
     }
   }
   return doit;
 }
 
 void KMyMoneyUtils::newTag(const QString& newnameBase, QString& id)
 {
   bool doit = true;
 
   if (newnameBase != i18n("New Tag")) {
     // Ask the user if that is what he intended to do?
     const auto msg = i18n("<qt>Do you want to add <b>%1</b> as tag?</qt>", newnameBase);
 
     if (KMessageBox::questionYesNo(nullptr, msg, i18n("New tag"), KStandardGuiItem::yes(), KStandardGuiItem::no(), "NewTag") == KMessageBox::No) {
       doit = false;
       // we should not keep the 'no' setting because that can confuse people like
       // I have seen in some usability tests. So we just delete it right away.
       KSharedConfigPtr kconfig = KSharedConfig::openConfig();
       if (kconfig) {
         kconfig->group(QLatin1String("Notification Messages")).deleteEntry(QLatin1String("NewTag"));
       }
     }
   }
 
   if (doit) {
     MyMoneyFileTransaction ft;
     try {
       QString newname(newnameBase);
       // adjust name until a unique name has been created
       int count = 0;
       for (;;) {
         try {
           MyMoneyFile::instance()->tagByName(newname);
           newname = QString::fromLatin1("%1 [%2]").arg(newnameBase, ++count);
         } catch (const MyMoneyException &) {
           break;
         }
       }
 
       MyMoneyTag ta;
       ta.setName(newname);
       MyMoneyFile::instance()->addTag(ta);
       id = ta.id();
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(nullptr, i18n("Unable to add tag"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(nullptr, i18n("Unable to add tag"), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KMyMoneyUtils::newInstitution(MyMoneyInstitution& institution)
 {
   auto file = MyMoneyFile::instance();
 
   MyMoneyFileTransaction ft;
 
   try {
     file->addInstitution(institution);
     ft.commit();
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::information(nullptr, i18n("Cannot add institution: %1", e.what()));
+    KMessageBox::information(nullptr, i18n("Cannot add institution: %1", QString::fromLatin1(e.what())));
   }
 }
 
 QDebug KMyMoneyUtils::debug()
 {
   return qDebug() << QDateTime::currentDateTime().toString(QStringLiteral("HH:mm:ss.zzz"));
 }
 
 MyMoneyForecast KMyMoneyUtils::forecast()
 {
   MyMoneyForecast forecast;
 
   // override object defaults with those of the application
   forecast.setForecastCycles(KMyMoneySettings::forecastCycles());
   forecast.setAccountsCycle(KMyMoneySettings::forecastAccountCycle());
   forecast.setHistoryStartDate(QDate::currentDate().addDays(-forecast.forecastCycles()*forecast.accountsCycle()));
   forecast.setHistoryEndDate(QDate::currentDate().addDays(-1));
   forecast.setForecastDays(KMyMoneySettings::forecastDays());
   forecast.setBeginForecastDay(KMyMoneySettings::beginForecastDay());
   forecast.setForecastMethod(KMyMoneySettings::forecastMethod());
   forecast.setHistoryMethod(KMyMoneySettings::historyMethod());
   forecast.setIncludeFutureTransactions(KMyMoneySettings::includeFutureTransactions());
   forecast.setIncludeScheduledTransactions(KMyMoneySettings::includeScheduledTransactions());
 
   return forecast;
 }
diff --git a/kmymoney/main.cpp b/kmymoney/main.cpp
index 7aadafd0e..edb783a33 100644
--- a/kmymoney/main.cpp
+++ b/kmymoney/main.cpp
@@ -1,364 +1,363 @@
 /***************************************************************************
                           main.cpp
                              -------------------
     copyright            : (C) 2001 by Michael Edwardes
     email                : mte@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 <config-kmymoney.h>
 #include <config-kmymoney-version.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QWidget>
 #include <QStringList>
 #include <QApplication>
 #include <QCommandLineParser>
 #include <QSplashScreen>
 #include <QStandardPaths>
 #ifdef KMM_DBUS
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusInterface>
 #endif
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KTipDialog>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <Kdelibs4ConfigMigrator>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoney/mymoneyfile.h"
 #include "kmymoney.h"
 #include "kstartuplogo.h"
 #include "kcreditswindow.h"
 #include "kmymoneyutils.h"
 #include "kmymoneysettings.h"
 #include "misc/webconnect.h"
 #include "platformtools.h"
 
 #ifdef KMM_DEBUG
 #include "mymoneyutils.h"
 #include "mymoneytracer.h"
 #endif
 
 bool timersOn = false;
 
 KMyMoneyApp* kmymoney;
 
 static int runKMyMoney(QApplication& a, std::unique_ptr<QSplashScreen> splash, const QUrl & file, bool noFile);
 static void migrateConfigFiles();
 
 int main(int argc, char *argv[])
 {
   /**
    * Create application first
    */
   QApplication app(argc, argv);
   KLocalizedString::setApplicationDomain("kmymoney");
 
   migrateConfigFiles();
 
   /**
    * construct and register about data
    */
   KAboutData aboutData(QStringLiteral("kmymoney"), i18n("KMyMoney"), QStringLiteral(VERSION));
   aboutData.setOrganizationDomain("kde.org");
   KAboutData::setApplicationData(aboutData);
 
   QStringList fileUrls;
   bool isNoCatchOption = false;
   bool isNoFileOption = false;
 
 #ifdef KMM_DEBUG
   bool isDumpActionsOption = false;
 #endif
 
   if (argc != 0) {
     /**
    * Create command line parser and feed it with known options
    */
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
 
     // language
     //    const QCommandLineOption langOption(QStringLiteral("lang"), i18n("language to be used"));
     //    parser.addOption(langOption);
 
     // no file
     const QCommandLineOption noFileOption(QStringLiteral("n"), i18n("do not open last used file"));
     parser.addOption(noFileOption);
 
     // timers
     const QCommandLineOption timersOption(QStringLiteral("timers"), i18n("enable performance timers"));
     parser.addOption(timersOption);
 
     // no catch
     const QCommandLineOption noCatchOption(QStringLiteral("nocatch"), i18n("do not globally catch uncaught exceptions"));
     parser.addOption(noCatchOption);
 
 #ifdef KMM_DEBUG
     // The following options are only available when compiled in debug mode
     // trace
     const QCommandLineOption traceOption(QStringLiteral("trace"), i18n("turn on program traces"));
     parser.addOption(traceOption);
 
     // dump actions
     const QCommandLineOption dumpActionsOption(QStringLiteral("dump-actions"), i18n("dump the names of all defined QAction objects to stdout and quit"));
     parser.addOption(dumpActionsOption);
 #endif
 
     // INSERT YOUR COMMANDLINE OPTIONS HERE
     // url to open
     parser.addPositionalArgument(QStringLiteral("url"), i18n("file to open"));
 
     /**
    * do the command line parsing
    */
     parser.parse(QApplication::arguments());
 
     bool ishelpSet = parser.isSet(QStringLiteral("help"));
     if (ishelpSet || parser.isSet(QStringLiteral("author")) || parser.isSet(QStringLiteral("license"))) {
       aboutData = initializeCreditsData();
       if (ishelpSet)
         parser.showHelp();
     }
 
     if (parser.isSet(QStringLiteral("version")))
       parser.showVersion();
 
     /**
    * handle standard options
    */
     aboutData.processCommandLine(&parser);
 
 #ifdef KMM_DEBUG
     if (parser.isSet(traceOption))
       MyMoneyTracer::on();
     timersOn = parser.isSet(timersOption);
     isDumpActionsOption = parser.isSet(dumpActionsOption);
 #endif
 
     isNoCatchOption = parser.isSet(noCatchOption);
     isNoFileOption = parser.isSet(noFileOption);
     fileUrls = parser.positionalArguments();
   }
 
   // create the singletons before we start memory checking
   // to avoid false error reports
   auto file = MyMoneyFile::instance();
   Q_UNUSED(file)
 
   KMyMoneyUtils::checkConstants();
 
   // show startup logo
   std::unique_ptr<QSplashScreen> splash(KMyMoneySettings::showSplash() ? createStartupLogo() : nullptr);
   app.processEvents();
 
   // setup the MyMoneyMoney locale settings according to the KDE settings
   MyMoneyMoney::setThousandSeparator(QLocale().groupSeparator());
   MyMoneyMoney::setDecimalSeparator(QLocale().decimalPoint());
   // TODO: port to kf5 (negative numbers in parens)
   //MyMoneyMoney::setNegativeMonetarySignPosition(static_cast<MyMoneyMoney::signPosition>(KLocale::global()->negativeMonetarySignPosition()));
   //MyMoneyMoney::setPositiveMonetarySignPosition(static_cast<MyMoneyMoney::signPosition>(KLocale::global()->positiveMonetarySignPosition()));
   MyMoneyMoney::setNegativePrefixCurrencySymbol(platformTools::currencySymbolPosition(true) < platformTools::AfterQuantityMoney);
   MyMoneyMoney::setPositivePrefixCurrencySymbol(platformTools::currencySymbolPosition(false) < platformTools::AfterQuantityMoney);
 
 //  QString language = parser.value(langOption);
 //  if (!language.isEmpty()) {
     //if (!KLocale::global()->setLanguage(QStringList() << language)) {
     //  qWarning("Unable to select language '%s'. This has one of two reasons:\n\ta) the standard KDE message catalog is not installed\n\tb) the KMyMoney message catalog is not installed", qPrintable(language));
     //}
 //  }
 
   kmymoney = new KMyMoneyApp();
 
 #ifdef KMM_DEBUG
   if (isDumpActionsOption) {
     kmymoney->dumpActions();
 
     // Before we delete the application, we make sure that we destroy all
     // widgets by running the event loop for some time to catch all those
     // widgets that are requested to be destroyed using the deleteLater() method.
     //QApplication::eventLoop()->processEvents(QEventLoop::ExcludeUserInput, 10);
     QCoreApplication::processEvents(QEventLoop::ExcludeUserInputEvents, 10);
 
     delete kmymoney;
     exit(0);
   }
 #endif
 
   QString fname;
   // in case a filename is provided we need to check if it is a local
   // file. In case the name does not start with "file://" or "./" or "/"
   // we need to prepend "./" to fake a relative filename. Otherwiese, QUrl prepends
   // "http://" and uses the full path which will not work.
   //
   // The handling might be different on other OSes
   if (!fileUrls.isEmpty()) {
     fname = fileUrls.front();
     QFileInfo fi(fname);
     if (fi.isFile() && !fname.startsWith(QLatin1String("file://"))
     && !fname.startsWith(QLatin1String("./"))
     && !fname.startsWith(QLatin1String("/"))) {
         fname.prepend(QLatin1String("./"));
     }
   }
 
   const QUrl url = QUrl::fromUserInput(fname, QLatin1String("."), QUrl::AssumeLocalFile);
   int rc = 0;
   if (isNoCatchOption) {
     qDebug("Running w/o global try/catch block");
     rc = runKMyMoney(app, std::move(splash), url, isNoFileOption);
   } else {
     try {
       rc = runKMyMoney(app, std::move(splash), url, isNoFileOption);
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedError(0, i18n("Uncaught error. Please report the details to the developers"),
-                                 i18n("%1 in file %2 line %3", e.what(), e.file(), e.line()));
-      throw e;
+      KMessageBox::detailedError(0, i18n("Uncaught error. Please report the details to the developers"), QString::fromLatin1(e.what()));
+      throw;
     }
   }
 
   return rc;
 }
 
 int runKMyMoney(QApplication& a, std::unique_ptr<QSplashScreen> splash, const QUrl & file, bool noFile)
 {
   bool instantQuit = false;
 
   /**
    * enable high dpi icons
    */
   a.setAttribute(Qt::AA_UseHighDpiPixmaps);
 
   if (kmymoney->webConnect()->isClient()) {
     // If the user launches a second copy of the app and includes a file to
     // open, they are probably attempting a "WebConnect" session.  In this case,
     // we'll check to make sure it's an importable file that's passed in, and if so, we'll
     // notify the primary instance of the file and kill ourselves.
 
     if (file.isValid()) {
       if (kmymoney->isImportableFile(file)) {
         instantQuit = true;
         kmymoney->webConnect()->loadFile(file);
       }
     }
   }
 
   kmymoney->centralWidget()->setEnabled(false);
 
   // force complete paint of widgets
   qApp->processEvents();
 
   if (!instantQuit) {
     QString importfile;
     QUrl url;
     // make sure, we take the file provided on the command
     // line before we go and open the last one used
     if (file.isValid()) {
         // Check to see if this is an importable file, as opposed to a loadable
         // file.  If it is importable, what we really want to do is load the
         // last used file anyway and then immediately import this file.  This
         // implements a "web connect" session where there is not already an
         // instance of the program running.
 
         if (kmymoney->isImportableFile(file)) {
           importfile = file.path();
           url = QUrl::fromUserInput(kmymoney->readLastUsedFile());
         } else {
           url = file;
         }
 
     } else {
       url = QUrl::fromUserInput(kmymoney->readLastUsedFile());
     }
 
     KTipDialog::showTip(kmymoney, QString(), false);
     if (url.isValid() && !noFile) {
       kmymoney->slotFileOpenRecent(url);
     } else if (KMyMoneySettings::firstTimeRun()) {
       kmymoney->slotFileNew();
     }
     KMyMoneySettings::setFirstTimeRun(false);
 
     if (!importfile.isEmpty())
       kmymoney->webConnect(importfile, QByteArray());
 
   } else {
     // the instantQuit flag is set, so we force the app to quit right away
     kmymoney->slotFileQuit();
   }
 
   kmymoney->updateCaption();
   kmymoney->centralWidget()->setEnabled(true);
   kmymoney->show();
   splash.reset();
 
   const int rc = a.exec();      //krazy:exclude=crashy
   return rc;
 }
 
 static void migrateConfigFiles()
 {
   const QString sMainConfigName(QStringLiteral("kmymoneyrc"));
   const QString sMainConfigSubdirectory(QStringLiteral("kmymoney/")); // all KMM config files should be in ~/.config/kmymoney/
   const QString sMainConfigPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) +
                                   QLatin1Char('/') +
                                   sMainConfigSubdirectory;
 
   if (!QFile::exists(sMainConfigPath + sMainConfigName)) { // if main config file doesn't exist, then it's first run
 
     // it could be migration from KDE4 to KF5 so prepare list of configuration files to migrate
     QStringList sConfigNames
     {
       sMainConfigName,
       QStringLiteral("csvimporterrc"),
       QStringLiteral("printcheckpluginrc"),
       QStringLiteral("icalendarexportpluginrc"),
       QStringLiteral("kbankingrc"),
     };
 
     // Copy KDE 4 config files to the KF5 location
     Kdelibs4ConfigMigrator migrator(QStringLiteral("kmymoney"));
     migrator.setConfigFiles(sConfigNames);
     migrator.setUiFiles(QStringList{QStringLiteral("kmymoneyui.rc")});
     migrator.migrate();
 
     QFileInfo fileInfo(sMainConfigPath + sMainConfigName);
     QDir().mkpath(fileInfo.absolutePath());
     const QString sOldMainConfigPath = QStandardPaths::writableLocation(QStandardPaths::GenericConfigLocation) +
                                        QLatin1Char('/');
 
     // some files have changed their names during switch to KF5, so prepare map for name replacements
     QMap<QString, QString> configNamesChange {
       {QStringLiteral("printcheckpluginrc"), QStringLiteral("checkprintingrc")},
       {QStringLiteral("icalendarexportpluginrc"), QStringLiteral("icalendarexporterrc")}
     };
 
     for (const auto& sConfigName : sConfigNames) {
       const auto sOldConfigFilename = sOldMainConfigPath + sConfigName;
       const auto sNewConfigFilename = sMainConfigPath + configNamesChange.value(sConfigName, sConfigName);
       if (QFile::exists(sOldConfigFilename)) {
         if (QFile::copy(sOldConfigFilename, sNewConfigFilename))
           QFile::remove(sOldConfigFilename);
       }
     }
   }
   KConfig::setMainConfigName(sMainConfigSubdirectory + sMainConfigName); // otherwise it would be ~/.config/kmymoneyrc and not ~/.config/kmymoney/kmymoneyrc
 }
diff --git a/kmymoney/models/ledgermodel.cpp b/kmymoney/models/ledgermodel.cpp
index 4a706070d..4f3da4754 100644
--- a/kmymoney/models/ledgermodel.cpp
+++ b/kmymoney/models/ledgermodel.cpp
@@ -1,656 +1,656 @@
 /***************************************************************************
                           ledgermodel.cpp
                              -------------------
     begin                : Sat Aug 8 2015
     copyright            : (C) 2015 by Thomas Baumgart
     email                : Thomas Baumgart <tbaumgart@kde.org>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "ledgermodel.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDebug>
 #include <QString>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ledgerschedule.h"
 
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneyfile.h"
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "kmymoneysettings.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 
 using namespace eLedgerModel;
 using namespace eMyMoney;
 
 class LedgerModelPrivate
 {
 public:
   ~LedgerModelPrivate() {
     qDeleteAll(m_ledgerItems);
     m_ledgerItems.clear();
   }
   MyMoneyTransaction    m_lastTransactionStored;
   QVector<LedgerItem*>  m_ledgerItems;
 };
 
 LedgerModel::LedgerModel(QObject* parent) :
   QAbstractTableModel(parent),
   d_ptr(new LedgerModelPrivate)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   connect(file, &MyMoneyFile::objectAdded,    this, &LedgerModel::slotAddTransaction);
   connect(file, &MyMoneyFile::objectModified, this, &LedgerModel::modifyTransaction);
   connect(file, &MyMoneyFile::objectRemoved,  this, &LedgerModel::removeTransaction);
 
   connect(file, &MyMoneyFile::objectAdded,    this, &LedgerModel::addSchedule);
   connect(file, &MyMoneyFile::objectModified, this, &LedgerModel::modifySchedule);
   connect(file, &MyMoneyFile::objectRemoved,  this, &LedgerModel::removeSchedule);
 }
 
 LedgerModel::~LedgerModel()
 {
 }
 
 int LedgerModel::rowCount(const QModelIndex& parent) const
 {
   // since the ledger model is a simple table model, we only
   // return the rowCount for the hiddenRootItem. and zero otherwise
   if(parent.isValid()) {
     return 0;
   }
 
   Q_D(const LedgerModel);
   return d->m_ledgerItems.count();
 }
 
 int LedgerModel::columnCount(const QModelIndex& parent) const
 {
   Q_UNUSED(parent);
   return (int)Column::LastColumn;
 }
 
 Qt::ItemFlags LedgerModel::flags(const QModelIndex& index) const
 {
   Q_D(const LedgerModel);
   Qt::ItemFlags flags;
 
   if(!index.isValid())
     return flags;
   if(index.row() < 0 || index.row() >= d->m_ledgerItems.count())
     return flags;
 
   return d->m_ledgerItems[index.row()]->flags();
 }
 
 
 QVariant LedgerModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
     switch(section) {
       case (int)Column::Number:
         return i18nc("Cheque Number", "No.");
       case (int)Column::Date:
         return i18n("Date");
       case (int)Column::Security:
         return i18n("Security");
       case (int)Column::CostCenter:
         return i18n("CC");
       case (int)Column::Detail:
         return i18n("Detail");
       case (int)Column::Reconciliation:
         return i18n("C");
       case (int)Column::Payment:
         return i18nc("Payment made from account", "Payment");
       case (int)Column::Deposit:
         return i18nc("Deposit into account", "Deposit");
       case (int)Column::Quantity:
         return i18n("Quantity");
       case (int)Column::Price:
         return i18n("Price");
       case (int)Column::Amount:
         return i18n("Amount");
       case (int)Column::Value:
         return i18n("Value");
       case (int)Column::Balance:
         return i18n("Balance");
     }
   }
   else if(orientation == Qt::Vertical && role == Qt::SizeHintRole) {
     // as small as possible, so that the delegate has a chance
     // to override the information
     return QSize(10, 10);
   }
   return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 QVariant LedgerModel::data(const QModelIndex& index, int role) const
 {
   Q_D(const LedgerModel);
   if(!index.isValid())
     return QVariant();
   if(index.row() < 0 || index.row() >= d->m_ledgerItems.count())
     return QVariant();
 
   QVariant rc;
   switch(role) {
     case Qt::DisplayRole:
       // make sure to never return any displayable text for the dummy entry
       if(!d->m_ledgerItems[index.row()]->transactionSplitId().isEmpty()) {
         switch(index.column()) {
           case (int)Column::Number:
             rc = d->m_ledgerItems[index.row()]->transactionNumber();
             break;
           case (int)Column::Date:
             rc = QLocale().toString(d->m_ledgerItems[index.row()]->postDate(), QLocale::ShortFormat);
             break;
           case (int)Column::Detail:
             rc = d->m_ledgerItems[index.row()]->counterAccount();
             break;
           case (int)Column::Reconciliation:
             rc = d->m_ledgerItems[index.row()]->reconciliationStateShort();
             break;
           case (int)Column::Payment:
             rc = d->m_ledgerItems[index.row()]->payment();
             break;
           case (int)Column::Deposit:
             rc = d->m_ledgerItems[index.row()]->deposit();
             break;
           case (int)Column::Amount:
             rc = d->m_ledgerItems[index.row()]->signedSharesAmount();
             break;
           case (int)Column::Balance:
             rc = d->m_ledgerItems[index.row()]->balance();
             break;
         }
       }
       break;
 
     case Qt::TextAlignmentRole:
       switch(index.column()) {
         case (int)Column::Payment:
         case (int)Column::Deposit:
         case (int)Column::Amount:
         case (int)Column::Balance:
         case (int)Column::Value:
           rc = QVariant(Qt::AlignRight| Qt::AlignTop);
           break;
         case (int)Column::Reconciliation:
           rc = QVariant(Qt::AlignHCenter | Qt::AlignTop);
           break;
         default:
           rc = QVariant(Qt::AlignLeft | Qt::AlignTop);
           break;
       }
       break;
 
     case Qt::BackgroundColorRole:
       if(d->m_ledgerItems[index.row()]->isImported()) {
         return KMyMoneySettings::schemeColor(SchemeColor::TransactionImported);
       }
       break;
 
     case (int)Role::CounterAccount:
       rc = d->m_ledgerItems[index.row()]->counterAccount();
       break;
 
     case (int)Role::SplitCount:
       rc = d->m_ledgerItems[index.row()]->splitCount();
       break;
 
     case (int)Role::CostCenterId:
       rc = d->m_ledgerItems[index.row()]->costCenterId();
       break;
 
     case (int)Role::PostDate:
       rc = d->m_ledgerItems[index.row()]->postDate();
       break;
 
     case (int)Role::PayeeName:
       rc = d->m_ledgerItems[index.row()]->payeeName();
       break;
 
     case (int)Role::PayeeId:
       rc = d->m_ledgerItems[index.row()]->payeeId();
       break;
 
     case (int)Role::AccountId:
       rc = d->m_ledgerItems[index.row()]->accountId();
       break;
 
     case Qt::EditRole:
     case (int)Role::TransactionSplitId:
       rc = d->m_ledgerItems[index.row()]->transactionSplitId();
       break;
 
     case (int)Role::TransactionId:
       rc = d->m_ledgerItems[index.row()]->transactionId();
       break;
 
     case (int)Role::Reconciliation:
       rc = (int)d->m_ledgerItems[index.row()]->reconciliationState();
       break;
 
     case (int)Role::ReconciliationShort:
       rc = d->m_ledgerItems[index.row()]->reconciliationStateShort();
       break;
 
     case (int)Role::ReconciliationLong:
       rc = d->m_ledgerItems[index.row()]->reconciliationStateLong();
       break;
 
     case (int)Role::SplitValue:
       rc.setValue(d->m_ledgerItems[index.row()]->value());
       break;
 
     case (int)Role::SplitShares:
       rc.setValue(d->m_ledgerItems[index.row()]->shares());
       break;
 
     case (int)Role::ShareAmount:
       rc.setValue(d->m_ledgerItems[index.row()]->sharesAmount());
       break;
 
     case (int)Role::ShareAmountSuffix:
       rc.setValue(d->m_ledgerItems[index.row()]->sharesSuffix());
       break;
 
     case (int)Role::ScheduleId:
       {
       LedgerSchedule* schedule = 0;
       schedule = dynamic_cast<LedgerSchedule*>(d->m_ledgerItems[index.row()]);
       if(schedule) {
         rc = schedule->scheduleId();
       }
       break;
     }
 
     case (int)Role::Memo:
     case (int)Role::SingleLineMemo:
       rc.setValue(d->m_ledgerItems[index.row()]->memo());
       if(role == (int)Role::SingleLineMemo) {
         QString txt = rc.toString();
         // remove empty lines
         txt.replace("\n\n", "\n");
         // replace '\n' with ", "
         txt.replace('\n', ", ");
         rc.setValue(txt);
       }
       break;
 
     case (int)Role::Number:
       rc = d->m_ledgerItems[index.row()]->transactionNumber();
       break;
 
     case (int)Role::Erroneous:
       rc = d->m_ledgerItems[index.row()]->isErroneous();
       break;
 
     case (int)Role::Import:
       rc = d->m_ledgerItems[index.row()]->isImported();
       break;
 
     case (int)Role::CounterAccountId:
       rc = d->m_ledgerItems[index.row()]->counterAccountId();
       break;
 
     case (int)Role::TransactionCommodity:
       rc = d->m_ledgerItems[index.row()]->transactionCommodity();
       break;
 
     case (int)Role::Transaction:
       rc.setValue(d->m_ledgerItems[index.row()]->transaction());
       break;
 
     case (int)Role::Split:
       rc.setValue(d->m_ledgerItems[index.row()]->split());
       break;
   }
   return rc;
 }
 
 bool LedgerModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
   Q_D(LedgerModel);
   if(!index.isValid()) {
     return false;
   }
   if(role == Qt::DisplayRole && index.column() == (int)Column::Balance) {
     d->m_ledgerItems[index.row()]->setBalance(value.toString());
     return true;
   }
   qDebug() << "setData(" << index.row() << index.column() << ")" << value << role;
   return QAbstractItemModel::setData(index, value, role);
 }
 
 
 
 void LedgerModel::unload()
 {
   Q_D(LedgerModel);
   if(rowCount() > 0) {
     beginRemoveRows(QModelIndex(), 0, rowCount() - 1);
     for(int i = 0; i < rowCount(); ++i) {
       delete d->m_ledgerItems[i];
     }
     d->m_ledgerItems.clear();
     endRemoveRows();
   }
 }
 
 void LedgerModel::addTransactions(const QList< QPair<MyMoneyTransaction, MyMoneySplit> >& list)
 {
   Q_D(LedgerModel);
   if(list.count() > 0) {
     beginInsertRows(QModelIndex(), rowCount(), rowCount() + list.count() - 1);
     QList< QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
     for(it = list.constBegin(); it != list.constEnd(); ++it) {
       d->m_ledgerItems.append(new LedgerTransaction((*it).first, (*it).second));
     }
     endInsertRows();
   }
 }
 
 void LedgerModel::addTransaction(const LedgerTransaction& t)
 {
   Q_D(LedgerModel);
   beginInsertRows(QModelIndex(), rowCount(), rowCount());
   d->m_ledgerItems.append(new LedgerTransaction(t.transaction(), t.split()));
   endInsertRows();
 }
 
 void LedgerModel::addTransaction(const QString& transactionSplitId)
 {
   Q_D(LedgerModel);
   QRegExp transactionSplitIdExp("^(\\w+)-(\\w+)$");
   if(transactionSplitIdExp.exactMatch(transactionSplitId)) {
     const QString transactionId = transactionSplitIdExp.cap(1);
     const QString splitId = transactionSplitIdExp.cap(2);
     if(transactionId != d->m_lastTransactionStored.id()) {
       try {
         d->m_lastTransactionStored = MyMoneyFile::instance()->transaction(transactionId);
-      } catch(MyMoneyException& e) {
+      } catch (const MyMoneyException &) {
         d->m_lastTransactionStored = MyMoneyTransaction();
       }
     }
     try {
       MyMoneySplit split = d->m_lastTransactionStored.splitById(splitId);
       beginInsertRows(QModelIndex(), rowCount(), rowCount());
       d->m_ledgerItems.append(new LedgerTransaction(d->m_lastTransactionStored, split));
       endInsertRows();
-    } catch(MyMoneyException& e) {
+    } catch (const MyMoneyException &) {
       d->m_lastTransactionStored = MyMoneyTransaction();
     }
   }
 }
 
 void LedgerModel::addSchedules(const QList<MyMoneySchedule> & list, int previewPeriod)
 {
   Q_D(LedgerModel);
   if(list.count() > 0) {
     QVector<LedgerItem*> newList;
 
     // create dummy entries for the scheduled transactions if sorted by postdate
     // show scheduled transactions which have a scheduled postdate
     // within the next 'previewPeriod' days. In reconciliation mode, the
     // previewPeriod starts on the statement date.
     QDate endDate = QDate::currentDate().addDays(previewPeriod);
 
 #if 0
     if (isReconciliationAccount())
       endDate = reconciliationDate.addDays(previewPeriod);
 #endif
 
     QList<MyMoneySchedule>::const_iterator it;
     for(it = list.constBegin(); it != list.constEnd(); ++it) {
       MyMoneySchedule schedule = *it;
 
       // now create entries for this schedule until the endDate is reached
       for (;;) {
         if (schedule.isFinished() || schedule.adjustedNextDueDate() > endDate) {
           break;
         }
 
         MyMoneyTransaction t(schedule.id(), KMyMoneyUtils::scheduledTransaction(schedule));
         // if the transaction is scheduled and overdue, it can't
         // certainly be posted in the past. So we take today's date
         // as the alternative
         if (schedule.isOverdue()) {
           t.setPostDate(schedule.adjustedDate(QDate::currentDate(), schedule.weekendOption()));
         } else {
           t.setPostDate(schedule.adjustedNextDueDate());
         }
 
         // create a model entry for each split of the schedule
         foreach (const auto split, t.splits())
           newList.append(new LedgerSchedule(schedule, t, split));
 
         // keep track of this payment locally (not in the engine)
         if (schedule.isOverdue()) {
           schedule.setLastPayment(QDate::currentDate());
         } else {
           schedule.setLastPayment(schedule.nextDueDate());
         }
 
         // if this is a one time schedule, we can bail out here as we're done
         if (schedule.occurrence() == Schedule::Occurrence::Once)
           break;
 
         // for all others, we check if the next payment date is still 'in range'
         QDate nextDueDate = schedule.nextPayment(schedule.nextDueDate());
         if (nextDueDate.isValid()) {
           schedule.setNextDueDate(nextDueDate);
         } else {
           break;
         }
       }
     }
     if(!newList.isEmpty()) {
       beginInsertRows(QModelIndex(), rowCount(), rowCount() + newList.count() - 1);
       d->m_ledgerItems += newList;
       endInsertRows();
     }
   }
 }
 
 void LedgerModel::load()
 {
   qDebug() << "Start loading splits";
   // load all transactions and splits into the model
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > tList;
   MyMoneyTransactionFilter filter;
   MyMoneyFile::instance()->transactionList(tList, filter);
   addTransactions(tList);
   qDebug() << "Loaded" << rowCount() << "elements";
 
   // load all scheduled transactoins and splits into the model
   const int splitCount = rowCount();
   QList<MyMoneySchedule> sList = MyMoneyFile::instance()->scheduleList();
   addSchedules(sList, KMyMoneySettings::schedulePreview());
   qDebug() << "Loaded" << rowCount()-splitCount << "elements";
 
   // create a dummy entry for new transactions
   addTransaction(LedgerTransaction::newTransactionEntry());
 
   qDebug() << "Loaded" << rowCount() << "elements";
 }
 
 void LedgerModel::slotAddTransaction(File::Object objType, const QString& id)
 {
   if(objType != File::Object::Transaction) {
     return;
   }
   Q_D(LedgerModel);
   qDebug() << "Adding transaction" << id;
 
   const auto t = MyMoneyFile::instance()->transaction(id);
 
   beginInsertRows(QModelIndex(), rowCount(), rowCount() + t.splitCount() - 1);
   foreach (auto s, t.splits())
     d->m_ledgerItems.append(new LedgerTransaction(t, s));
   endInsertRows();
 
   // just make sure we're in sync
   Q_ASSERT(d->m_ledgerItems.count() == rowCount());
 }
 
 void LedgerModel::modifyTransaction(File::Object objType, const QString& id)
 {
   if(objType != File::Object::Transaction) {
     return;
   }
 
   Q_D(LedgerModel);
   const auto t = MyMoneyFile::instance()->transaction(id);
   // get indexes of all existing splits for this transaction
   auto list = match(index(0, 0), (int)Role::TransactionId, id, -1);
   // get list of splits to be stored
   auto splits = t.splits();
 
   int lastRowUsed = -1;
   int firstRowUsed = 99999999;
   if(list.count()) {
     firstRowUsed = list.first().row();
     lastRowUsed = list.last().row();
   }
 
   qDebug() << "first:" << firstRowUsed << "last:" << lastRowUsed;
 
   while(!list.isEmpty() && !splits.isEmpty()) {
     QModelIndex index = list.takeFirst();
     MyMoneySplit split = splits.takeFirst();
     // get rid of the old split and store new split
     qDebug() << "Modify split in row:" << index.row() << t.id() << split.id();
     delete d->m_ledgerItems[index.row()];
     d->m_ledgerItems[index.row()] = new LedgerTransaction(t, split);
   }
 
   // inform every one else about the changes
   if(lastRowUsed != -1) {
     qDebug() << "emit dataChanged from" << firstRowUsed << "to" << lastRowUsed;
     emit dataChanged(index(firstRowUsed, 0), index(lastRowUsed, columnCount()-1));
 
   } else {
     lastRowUsed = rowCount();
   }
 
   // now check if we need to add more splits ...
   if(!splits.isEmpty() && list.isEmpty()) {
     beginInsertRows(QModelIndex(), lastRowUsed, lastRowUsed + splits.count() - 1);
     d->m_ledgerItems.insert(lastRowUsed, splits.count(), 0);
     while(!splits.isEmpty()) {
       MyMoneySplit split = splits.takeFirst();
       d->m_ledgerItems[lastRowUsed] = new LedgerTransaction(t, split);
       lastRowUsed++;
     }
     endInsertRows();
   }
 
   // ... or remove some leftovers
   if(splits.isEmpty() && !list.isEmpty()) {
     firstRowUsed = lastRowUsed - list.count() + 1;
     beginRemoveRows(QModelIndex(), firstRowUsed, lastRowUsed);
     int count = 0;
     while(!list.isEmpty()) {
       ++count;
       QModelIndex index = list.takeFirst();
       // get rid of the old split and store new split
       qDebug() << "Delete split in row:" << index.row() << data(index, (int)Role::TransactionSplitId).toString();
       delete d->m_ledgerItems[index.row()];
     }
     d->m_ledgerItems.remove(firstRowUsed, count);
     endRemoveRows();
   }
 
   // just make sure we're in sync
   Q_ASSERT(d->m_ledgerItems.count() == rowCount());
 }
 
 void LedgerModel::removeTransaction(File::Object objType, const QString& id)
 {
   if(objType != File::Object::Transaction) {
     return;
   }
   Q_D(LedgerModel);
 
   QModelIndexList list = match(index(0, 0), (int)Role::TransactionId, id, -1);
 
   if(list.count()) {
     const int firstRowUsed = list[0].row();
     beginRemoveRows(QModelIndex(), firstRowUsed, firstRowUsed + list.count() - 1);
     for(int row = firstRowUsed; row < firstRowUsed + list.count(); ++row) {
       delete d->m_ledgerItems[row];
     }
     d->m_ledgerItems.remove(firstRowUsed, list.count());
     endRemoveRows();
 
     // just make sure we're in sync
     Q_ASSERT(d->m_ledgerItems.count() == rowCount());
   }
 }
 
 void LedgerModel::addSchedule(File::Object objType, const QString& id)
 {
   Q_UNUSED(id);
   if(objType != File::Object::Schedule) {
     return;
   }
 
   /// @todo implement LedgerModel::addSchedule
 }
 
 void LedgerModel::modifySchedule(File::Object objType, const QString& id)
 {
   Q_UNUSED(id);
   if(objType != File::Object::Schedule) {
     return;
   }
 
   /// @todo implement LedgerModel::modifySchedule
 }
 
 void LedgerModel::removeSchedule(File::Object objType, const QString& id)
 {
   Q_UNUSED(id);
   if(objType != File::Object::Schedule) {
     return;
   }
 
   /// @todo implement LedgerModel::removeSchedule
 }
 
 QString LedgerModel::transactionIdFromTransactionSplitId(const QString& transactionSplitId) const
 {
   QRegExp transactionSplitIdExp("^(\\w+)-\\w+$");
   if(transactionSplitIdExp.exactMatch(transactionSplitId)) {
     return transactionSplitIdExp.cap(1);
   }
   return QString();
 }
diff --git a/kmymoney/models/ledgersplit.cpp b/kmymoney/models/ledgersplit.cpp
index 6e65d8637..a65a81a73 100644
--- a/kmymoney/models/ledgersplit.cpp
+++ b/kmymoney/models/ledgersplit.cpp
@@ -1,80 +1,80 @@
 /***************************************************************************
                           ledgersplit.cpp
                              -------------------
     begin                : Sat Aug 8 2015
     copyright            : (C) 2015 by Thomas Baumgart
     email                : Thomas Baumgart <tbaumgart@kde.org>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "ledgersplit.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDebug>
 #include <QString>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ledgertransaction_p.h"
 #include "mymoneytransaction.h"
 #include "mymoneyfile.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 
 using namespace eMyMoney;
 
 class LedgerSplitPrivate : public LedgerTransactionPrivate
 {
 public:
 };
 
 LedgerSplit::LedgerSplit() :
   LedgerTransaction(*new LedgerSplitPrivate, MyMoneyTransaction(), MyMoneySplit())
 {
 }
 
 LedgerSplit::LedgerSplit(const MyMoneyTransaction& t, const MyMoneySplit& s) :
   LedgerTransaction(*new LedgerSplitPrivate, t, s)
 {
   Q_D(LedgerSplit);
   // override the settings made in the base class
   d->m_payeeName.clear();
   d->m_payeeId = d->m_split.payeeId();
   if(!d->m_payeeId.isEmpty()) {
     try {
       d->m_payeeName = MyMoneyFile::instance()->payee(d->m_payeeId).name();
-    } catch(MyMoneyException&) {
+    } catch (const MyMoneyException &) {
       qDebug() << "payee" << d->m_payeeId << "not found.";
     }
   }
 }
 
 LedgerSplit::LedgerSplit(const LedgerSplit& other) :
   LedgerTransaction(*new LedgerSplitPrivate(*other.d_func()))
 {
 }
 
 LedgerSplit::~LedgerSplit()
 {
 }
 
 QString LedgerSplit::memo() const
 {
   Q_D(const LedgerSplit);
   return d->m_split.memo();
 }
diff --git a/kmymoney/models/splitmodel.cpp b/kmymoney/models/splitmodel.cpp
index 8e411cb2c..73ee03258 100644
--- a/kmymoney/models/splitmodel.cpp
+++ b/kmymoney/models/splitmodel.cpp
@@ -1,447 +1,447 @@
 /***************************************************************************
                           ledgermodel.cpp
                              -------------------
     begin                : Sat Aug 8 2015
     copyright            : (C) 2015 by Thomas Baumgart
     email                : Thomas Baumgart <tbaumgart@kde.org>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "splitmodel.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "models.h"
 #include "costcentermodel.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneypayee.h"
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "modelenums.h"
 
 using namespace eLedgerModel;
 using namespace eMyMoney;
 
 class SplitModelPrivate
 {
 public:
   SplitModelPrivate()
   : m_invertValues(false)
   {}
 
   bool isCreateSplitEntry(const QString& id) const {
     return id.isEmpty();
   }
 
   MyMoneyTransaction    m_transaction;
   QVector<MyMoneySplit> m_splits;
   bool                  m_invertValues;
 };
 
 SplitModel::SplitModel(QObject* parent) :
   QAbstractTableModel(parent),
   d_ptr(new SplitModelPrivate)
 {
 }
 
 SplitModel::~SplitModel()
 {
 }
 
 QString SplitModel::newSplitId()
 {
   return QLatin1String("New-ID");
 }
 
 bool SplitModel::isNewSplitId(const QString& id)
 {
   return id.compare(newSplitId()) == 0;
 }
 
 
 int SplitModel::rowCount(const QModelIndex& parent) const
 {
   Q_D(const SplitModel);
   Q_UNUSED(parent);
   return d->m_splits.count();
 }
 
 int SplitModel::columnCount(const QModelIndex& parent) const
 {
   Q_UNUSED(parent);
   return (int)Column::LastColumn;
 }
 
 
 void SplitModel::deepCopy(const SplitModel& right, bool revertSplitSign)
 {
   Q_D(SplitModel);
   beginInsertRows(QModelIndex(), 0, right.rowCount());
   d->m_splits = right.d_func()->m_splits;
   d->m_transaction = right.d_func()->m_transaction;
   if(revertSplitSign) {
     for(int idx = 0; idx < d->m_splits.count(); ++idx) {
       MyMoneySplit& split = d->m_splits[idx];
       split.setShares(-split.shares());
       split.setValue(-split.value());
     }
   }
   endInsertRows();
 }
 
 QVariant SplitModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if(orientation == Qt::Horizontal && role == Qt::DisplayRole) {
     switch(section) {
       case (int)Column::CostCenter:
         return i18n("Cost Center");
       case (int)Column::Detail:
         return i18n("Category");
       case (int)Column::Number:
         return i18n("No");
       case (int)Column::Date:
         return i18n("Date");
       case (int)Column::Security:
         return i18n("Security");
       case (int)Column::Reconciliation:
         return i18n("C");
       case (int)Column::Payment:
         return i18n("Payment");
       case (int)Column::Deposit:
         return i18n("Deposit");
       case (int)Column::Quantity:
         return i18n("Quantity");
       case (int)Column::Price:
         return i18n("Price");
       case (int)Column::Amount:
         return i18n("Amount");
       case (int)Column::Value:
         return i18n("Value");
       case (int)Column::Balance:
         return i18n("Balance");
     }
   }
   return QAbstractItemModel::headerData(section, orientation, role);
 }
 
 QVariant SplitModel::data(const QModelIndex& index, int role) const
 {
   Q_D(const SplitModel);
   if(!index.isValid())
     return QVariant();
   if(index.row() < 0 || index.row() >= d->m_splits.count())
     return QVariant();
 
   QVariant rc;
   MyMoneyAccount acc;
   MyMoneyMoney value;
   const MyMoneySplit& split = d->m_splits[index.row()];
   QModelIndex subIndex;
   CostCenterModel* ccModel = Models::instance()->costCenterModel();
 
   switch(role) {
     case Qt::DisplayRole:
       // make sure to never return any displayable text for the dummy entry
       if(!d->isCreateSplitEntry(split.id())) {
         switch(index.column()) {
           case (int)Column::Detail:
             rc = MyMoneyFile::instance()->accountToCategory(split.accountId());
             break;
           case (int)Column::CostCenter:
             subIndex = Models::indexById(ccModel, CostCenterModel::CostCenterIdRole, split.costCenterId());
             rc = ccModel->data(subIndex);
             break;
           case (int)Column::Number:
             rc = split.number();
             break;
           case (int)Column::Reconciliation:
             rc = KMyMoneyUtils::reconcileStateToString(split.reconcileFlag(), false);
             break;
           case (int)Column::Payment:
             if(split.value().isNegative()) {
               acc = MyMoneyFile::instance()->account(split.accountId());
               rc = (-split).value(d->m_transaction.commodity(), acc.currencyId()).formatMoney(acc.fraction());
             }
             break;
           case (int)Column::Deposit:
             if(!split.value().isNegative()) {
               acc = MyMoneyFile::instance()->account(split.accountId());
               rc = split.value(d->m_transaction.commodity(), acc.currencyId()).formatMoney(acc.fraction());
             }
             break;
           default:
             break;
         }
       }
       break;
 
     case Qt::TextAlignmentRole:
       switch(index.column()) {
         case (int)Column::Payment:
         case (int)Column::Deposit:
         case (int)Column::Amount:
         case (int)Column::Balance:
         case (int)Column::Value:
           rc = QVariant(Qt::AlignRight| Qt::AlignTop);
           break;
         case (int)Column::Reconciliation:
           rc = QVariant(Qt::AlignHCenter | Qt::AlignTop);
           break;
         default:
           rc = QVariant(Qt::AlignLeft | Qt::AlignTop);
           break;
       }
       break;
 
     case (int)Role::AccountId:
       rc = split.accountId();
       break;
 
     case (int)Role::Account:
       rc = MyMoneyFile::instance()->accountToCategory(split.accountId());
       break;
 
     case (int)Role::TransactionId:
       rc = QString("%1").arg(d->m_transaction.id());
       break;
 
     case (int)Role::TransactionSplitId:
       rc = QString("%1-%2").arg(d->m_transaction.id()).arg(split.id());
       break;
 
     case (int)Role::SplitId:
       rc = split.id();
       break;
 
     case (int)Role::Memo:
     case (int)Role::SingleLineMemo:
       rc = split.memo();
       if(role == (int)Role::SingleLineMemo) {
         QString txt = rc.toString();
         // remove empty lines
         txt.replace("\n\n", "\n");
         // replace '\n' with ", "
         txt.replace('\n', ", ");
         rc = txt;
       }
       break;
 
     case (int)Role::SplitShares:
       rc = QVariant::fromValue<MyMoneyMoney>(split.shares());
       break;
 
     case (int)Role::SplitValue:
       acc = MyMoneyFile::instance()->account(split.accountId());
       rc = QVariant::fromValue<MyMoneyMoney>(split.value(d->m_transaction.commodity(), acc.currencyId()));
       break;
 
     case (int)Role::PayeeName:
       try {
         rc = MyMoneyFile::instance()->payee(split.payeeId()).name();
-      } catch(MyMoneyException&e) {
+      } catch (const MyMoneyException &e) {
       }
       break;
 
     case (int)Role::CostCenterId:
       rc = split.costCenterId();
       break;
 
     case (int)Role::TransactionCommodity:
       return d->m_transaction.commodity();
       break;
 
     case (int)Role::Number:
       rc = split.number();
       break;
 
     case (int)Role::PayeeId:
       rc = split.payeeId();
       break;
 
     default:
       if(role >= Qt::UserRole) {
         qWarning() << "Undefined role" << role << "(" << role-Qt::UserRole << ") in SplitModel::data";
       }
       break;
   }
   return rc;
 }
 
 bool SplitModel::setData(const QModelIndex& index, const QVariant& value, int role)
 {
   Q_D(SplitModel);
   bool rc = false;
   if(index.isValid()) {
     MyMoneySplit& split = d->m_splits[index.row()];
     if(split.id().isEmpty()) {
       split = MyMoneySplit(newSplitId(), split);
     }
     QString val;
     rc = true;
     switch(role) {
       case (int)Role::PayeeId:
         split.setPayeeId(value.toString());
         break;
 
       case (int)Role::AccountId:
         split.setAccountId(value.toString());
         break;
 
       case (int)Role::Memo:
         split.setMemo(value.toString());
         break;
 
       case (int)Role::CostCenterId:
         val = value.toString();
         split.setCostCenterId(value.toString());
         break;
 
       case (int)Role::Number:
         split.setNumber(value.toString());
         break;
 
       case (int)Role::SplitShares:
         split.setShares(value.value<MyMoneyMoney>());
         break;
 
       case (int)Role::SplitValue:
         split.setValue(value.value<MyMoneyMoney>());
         break;
 
       case (int)Role::EmitDataChanged:
         {
           // the whole row changed
           QModelIndex topLeft = this->index(index.row(), 0);
           QModelIndex bottomRight = this->index(index.row(), this->columnCount()-1);
           emit dataChanged(topLeft, bottomRight);
         }
         break;
 
       default:
         rc = false;
         break;
     }
   }
 
   return rc;
 }
 
 
 void SplitModel::addSplit(const QString& transactionSplitId)
 {
   Q_D(SplitModel);
   QRegExp transactionSplitIdExp("^(\\w+)-(\\w+)$");
   if(transactionSplitIdExp.exactMatch(transactionSplitId)) {
     const QString transactionId = transactionSplitIdExp.cap(1);
     const QString splitId = transactionSplitIdExp.cap(2);
     if(transactionId != d->m_transaction.id()) {
       try {
         d->m_transaction = MyMoneyFile::instance()->transaction(transactionId);
-      } catch(MyMoneyException& e) {
+      } catch (const MyMoneyException &e) {
         d->m_transaction = MyMoneyTransaction();
       }
     }
     try {
       beginInsertRows(QModelIndex(), rowCount(), rowCount());
       d->m_splits.append(d->m_transaction.splitById(splitId));
       endInsertRows();
-    } catch(MyMoneyException& e) {
+    } catch (const MyMoneyException &e) {
       d->m_transaction = MyMoneyTransaction();
     }
   }
 }
 
 void SplitModel::addEmptySplitEntry()
 {
   Q_D(SplitModel);
   QModelIndexList list = match(index(0, 0), (int)Role::SplitId, QString(), -1, Qt::MatchExactly);
   if(list.count() == 0) {
     beginInsertRows(QModelIndex(), rowCount(), rowCount());
     // d->m_splits.append(MyMoneySplit(d->newSplitEntryId(), MyMoneySplit()));
     d->m_splits.append(MyMoneySplit());
     endInsertRows();
   }
 }
 
 void SplitModel::removeEmptySplitEntry()
 {
   Q_D(SplitModel);
   // QModelIndexList list = match(index(0, 0), SplitIdRole, d->newSplitEntryId(), -1, Qt::MatchExactly);
   QModelIndexList list = match(index(0, 0), (int)Role::SplitId, QString(), -1, Qt::MatchExactly);
   if(list.count()) {
     QModelIndex index = list.at(0);
     beginRemoveRows(QModelIndex(), index.row(), index.row());
     d->m_splits.remove(index.row(), 1);
     endRemoveRows();
   }
 }
 
 bool SplitModel::removeRows(int row, int count, const QModelIndex& parent)
 {
   Q_D(SplitModel);
   bool rc = false;
   if(count > 0) {
     beginRemoveRows(parent, row, row + count - 1);
     d->m_splits.remove(row, count);
     endRemoveRows();
     rc = true;
   }
   return rc;
 }
 
 Qt::ItemFlags SplitModel::flags(const QModelIndex& index) const
 {
   Q_D(const SplitModel);
   Qt::ItemFlags flags;
 
   if(!index.isValid())
     return flags;
   if(index.row() < 0 || index.row() >= d->m_splits.count())
     return flags;
 
   return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
 }
 
 
 #if 0
 void SplitModel::removeSplit(const LedgerTransaction& t)
 {
   Q_D(SplitModel);
   QModelIndexList list = match(index(0, 0), TransactionSplitIdRole, t.transactionSplitId(), -1, Qt::MatchExactly);
   if(list.count()) {
     QModelIndex index = list.at(0);
     beginRemoveRows(QModelIndex(), index.row(), index.row());
     delete d->m_ledgerItems[index.row()];
     d->m_ledgerItems.remove(index.row(), 1);
     endRemoveRows();
 
     // just make sure we're in sync
     Q_ASSERT(d->m_ledgerItems.count() == rowCount());
   }
 }
 #endif
diff --git a/kmymoney/mymoney/CMakeLists.txt b/kmymoney/mymoney/CMakeLists.txt
index 90893b8a5..b38219b2f 100644
--- a/kmymoney/mymoney/CMakeLists.txt
+++ b/kmymoney/mymoney/CMakeLists.txt
@@ -1,110 +1,110 @@
 add_subdirectory( storage )
 add_subdirectory( payeeidentifier )
 
 ########### next target ###############
 
 set(kmm_mymoney_LIB_SRCS
   mymoneymoney.cpp mymoneyfinancialcalculator.cpp
   mymoneytransactionfilter.cpp
   mymoneyfile.cpp mymoneykeyvaluecontainer.cpp
   mymoneyobject.cpp
   mymoneypayeeidentifiercontainer.cpp
   mymoneysplit.cpp mymoneyinstitution.cpp
-  mymoneyexception.cpp mymoneyinvesttransaction.cpp mymoneyutils.cpp
+  mymoneyinvesttransaction.cpp mymoneyutils.cpp
   mymoneysecurity.cpp mymoneytransaction.cpp mymoneyschedule.cpp
   mymoneypayee.cpp mymoneytracer.cpp
   mymoneytag.cpp
   mymoneycategory.cpp
   mymoneycostcenter.cpp
   mymoneyaccount.cpp mymoneyaccountloan.cpp
   mymoneyreport.cpp mymoneystatement.cpp mymoneyprice.cpp mymoneybudget.cpp
   mymoneyforecast.cpp
   mymoneybalancecache.cpp
   onlinejob.cpp
   onlinejobadministration.cpp
   onlinejobmessage.cpp
   onlinejobfolder.cpp
   mymoneycontact.cpp
   payeeidentifiermodel.cpp
   )
 
   # storage_a_SOURCES cannot be set in storage directory on MS Windows
   # because, while building kmm_storage, linker reports many undefined symbols
   # which are in fact available in kmm_mymoney
   set(storage_a_SOURCES
     ./storage/imymoneystorageformat.cpp
     ./storage/mymoneystoragexml.cpp
     ./storage/mymoneystoragemgr.cpp
     ./storage/mymoneystorageanon.cpp
     ./storage/kmymoneystorageplugin.cpp
     ./storage/mymoneystoragenames.cpp
     )
 
 list(APPEND storage_a_SOURCES $<$<OR:$<CONFIG:Debug>,$<CONFIG:DebugFull>,$<CONFIG:DebugKMM>>: ./storage/mymoneystoragedump.cpp>)
 
 list(APPEND kmm_mymoney_LIB_SRCS ${storage_a_SOURCES})
 
 set(mymoney_HEADERS ${CMAKE_CURRENT_BINARY_DIR}/kmm_mymoney_export.h
   mymoneyobject.h mymoneyaccount.h mymoneycategory.h mymoneyexception.h
   mymoneyfile.h mymoneyfinancialcalculator.h mymoneyinstitution.h
   mymoneyinvesttransaction.h mymoneykeyvaluecontainer.h mymoneymoney.h
   mymoneypayee.h mymoneytag.h mymoneyprice.h mymoneyreport.h
   mymoneyschedule.h mymoneysecurity.h mymoneysplit.h mymoneystatement.h
   mymoneytransactionfilter.h mymoneytransaction.h
   mymoneyutils.h mymoneybudget.h mymoneyforecast.h
   imymoneyprocessingcalendar.h
   mymoneycostcenter.h
   mymoneyunittestable.h
   mymoneypayeeidentifiercontainer.h
   onlinejob.h
   onlinejobtyped.h
   onlinejobmessage.h
   onlinejobfolder.h
   )
 
 add_library(kmm_mymoney SHARED ${kmm_mymoney_LIB_SRCS})
 kde_target_enable_exceptions(kmm_mymoney PUBLIC)
 
 target_compile_features(kmm_mymoney PUBLIC cxx_nullptr PRIVATE cxx_decltype cxx_lambdas cxx_constexpr cxx_range_for)
 
 generate_export_header(kmm_mymoney BASE_NAME kmm_mymoney)
 
 target_link_libraries(kmm_mymoney
                       PUBLIC
                       kmm_icons
                       Qt5::Xml
                       Qt5::Core
                       Qt5::Gui
                       Qt5::Sql
                       KF5::Service
                       KF5::I18n
                       Alkimia::alkimia
                       kmm_payeeidentifier_loader
                       kmm_payeeidentifier
                       payeeidentifier_iban_bic
                       payeeidentifier_nationalAccount
                       # TODO: fix this
                       KF5::XmlGui
                       PRIVATE
                       onlinetask_unavailabletask
 )
 
 if(KMM_ADDRESSBOOK_FOUND)
 target_link_libraries(kmm_mymoney PUBLIC KF5::IdentityManagement KF5::AkonadiCore KF5::Contacts)
 endif()
 
 set_target_properties(kmm_mymoney PROPERTIES VERSION ${PROJECT_VERSION} SOVERSION ${PROJECT_VERSION_MAJOR})
 
 ########### install files ###############
 
 install(TARGETS kmm_mymoney
   ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} )
 
 install(FILES ${mymoney_HEADERS}
   DESTINATION ${INCLUDE_INSTALL_DIR}/kmymoney COMPONENT Devel)
 
 ############## tests ####################
 
 if(BUILD_TESTING)
   add_subdirectory(tests)
 endif()
diff --git a/kmymoney/mymoney/mymoneyaccount.cpp b/kmymoney/mymoney/mymoneyaccount.cpp
index 7da38f368..d0b4ffaf1 100644
--- a/kmymoney/mymoney/mymoneyaccount.cpp
+++ b/kmymoney/mymoney/mymoneyaccount.cpp
@@ -1,728 +1,726 @@
 /***************************************************************************
                           mymoneyaccount.cpp
                           -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                            (C) 2002 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyaccount.h"
 #include "mymoneyaccount_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QRegExp>
 #include <QPixmap>
 #include <QPixmapCache>
 #include <QPainter>
 #include <QIcon>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyutils.h"
 #include "mymoneyexception.h"
 #include "mymoneysplit.h"
 #include "mymoneyfile.h"
 #include "mymoneysecurity.h"
 #include "mymoneyinstitution.h"
 #include "mymoneypayee.h"
 #include "payeeidentifier/payeeidentifiertyped.h"
 #include "payeeidentifier/ibanandbic/ibanbic.h"
 #include "payeeidentifier/nationalaccount/nationalaccount.h"
 #include "mymoneystoragenames.h"
 #include "icons/icons.h"
 
 using namespace MyMoneyStorageNodes;
 using namespace Icons;
 
 MyMoneyAccount::MyMoneyAccount() :
   MyMoneyObject(*new MyMoneyAccountPrivate),
   MyMoneyKeyValueContainer()
 {
 }
 
 MyMoneyAccount::MyMoneyAccount(const QDomElement& node) :
     MyMoneyObject(*new MyMoneyAccountPrivate, node),
     MyMoneyKeyValueContainer(node.elementsByTagName(nodeNames[nnKeyValuePairs]).item(0).toElement())
 {
   if (nodeNames[nnAccount] != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not ACCOUNT");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not ACCOUNT");
 
   Q_D(MyMoneyAccount);
   setName(node.attribute(d->getAttrName(Account::Attribute::Name)));
 
   // qDebug("Reading information for account %s", acc.name().data());
 
   setParentAccountId(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::ParentAccount))));
   setLastModified(MyMoneyUtils::stringToDate(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::LastModified)))));
   setLastReconciliationDate(MyMoneyUtils::stringToDate(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::LastReconciled)))));
 
   if (!d->m_lastReconciliationDate.isValid()) {
     // for some reason, I was unable to access our own kvp at this point through
     // the value() method. It always returned empty strings. The workaround for
     // this is to construct a local kvp the same way as we have done before and
     // extract the value from it.
     //
     // Since we want to get rid of the lastStatementDate record anyway, this seems
     // to be ok for now. (ipwizard - 2008-08-14)
     QString txt = MyMoneyKeyValueContainer(node.elementsByTagName(nodeNames[nnKeyValuePairs]).item(0).toElement()).value("lastStatementDate");
     if (!txt.isEmpty()) {
       setLastReconciliationDate(QDate::fromString(txt, Qt::ISODate));
     }
   }
 
   setInstitutionId(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::Institution))));
   setNumber(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::Number))));
   setOpeningDate(MyMoneyUtils::stringToDate(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::Opened)))));
   setCurrencyId(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::Currency))));
 
   QString tmp = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::Type)));
   bool bOK = false;
   int type = tmp.toInt(&bOK);
   if (bOK) {
     setAccountType(static_cast<Account::Type>(type));
   } else {
     qWarning("XMLREADER: Account %s had invalid or no account type information.", qPrintable(name()));
   }
 
-  if (node.hasAttribute(d->getAttrName(Account::Attribute::OpeningBalance))) {
-    if (!MyMoneyMoney(node.attribute(d->getAttrName(Account::Attribute::OpeningBalance))).isZero()) {
-      QString msg = i18n("Account %1 contains an opening balance. Please use KMyMoney version 0.8 or later and earlier than version 0.9 to correct the problem.", d->m_name);
-      throw MYMONEYEXCEPTION(msg);
-    }
-  }
+  if (node.hasAttribute(d->getAttrName(Account::Attribute::OpeningBalance)))
+    if (!MyMoneyMoney(node.attribute(d->getAttrName(Account::Attribute::OpeningBalance))).isZero())
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Account %1 contains an opening balance. Please use KMyMoney version 0.8 or later and earlier than version 0.9 to correct the problem.").arg(d->m_name));
+
   setDescription(node.attribute(d->getAttrName(Account::Attribute::Description)));
 
   d->m_id = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Account::Attribute::ID)));
   // qDebug("Account %s has id of %s, type of %d, parent is %s.", acc.name().data(), id.data(), type, acc.parentAccountId().data());
 
   //  Process any Sub-Account information found inside the account entry.
   d->m_accountList.clear();
   QDomNodeList nodeList = node.elementsByTagName(d->getElName(Account::Element::SubAccounts));
   if (nodeList.count() > 0) {
     nodeList = nodeList.item(0).toElement().elementsByTagName(d->getElName(Account::Element::SubAccount));
     for (int i = 0; i < nodeList.count(); ++i) {
       addAccountId(QString(nodeList.item(i).toElement().attribute(d->getAttrName(Account::Attribute::ID))));
     }
   }
 
   nodeList = node.elementsByTagName(d->getElName(Account::Element::OnlineBanking));
   if (nodeList.count() > 0) {
     QDomNamedNodeMap attributes = nodeList.item(0).toElement().attributes();
     for (int i = 0; i < attributes.count(); ++i) {
       const QDomAttr& it_attr = attributes.item(i).toAttr();
       d->m_onlineBankingSettings.setValue(it_attr.name(), it_attr.value());
     }
   }
 
   // Up to and including version 4.6.6 the new account dialog stored the iban in the kvp-key "IBAN".
   // But the rest of the software uses "iban". So correct this:
   if (!value("IBAN").isEmpty()) {
     // If "iban" was not set, set it now. If it is set, the user reseted it already, so remove
     // the garbage.
     if (value(d->getAttrName(Account::Attribute::IBAN)).isEmpty())
       setValue(d->getAttrName(Account::Attribute::IBAN), value("IBAN"));
     deletePair("IBAN");
   }
 }
 
 MyMoneyAccount::MyMoneyAccount(const MyMoneyAccount& other) :
   MyMoneyObject(*new MyMoneyAccountPrivate(*other.d_func()), other.id()),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneyAccount::MyMoneyAccount(const QString& id, const MyMoneyAccount& other) :
   MyMoneyObject(*new MyMoneyAccountPrivate(*other.d_func()), id),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneyAccount::~MyMoneyAccount()
 {
 }
 
 void MyMoneyAccount::touch()
 {
   setLastModified(QDate::currentDate());
 }
 
 eMyMoney::Account::Type MyMoneyAccount::accountType() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_accountType;
 }
 
 void MyMoneyAccount::setAccountType(const Account::Type type)
 {
   Q_D(MyMoneyAccount);
   d->m_accountType = type;
 }
 
 QString MyMoneyAccount::institutionId() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_institution;
 }
 
 void MyMoneyAccount::setInstitutionId(const QString& id)
 {
   Q_D(MyMoneyAccount);
   d->m_institution = id;
 }
 
 QString MyMoneyAccount::name() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_name;
 }
 
 void MyMoneyAccount::setName(const QString& name)
 {
   Q_D(MyMoneyAccount);
   d->m_name = name;
 }
 
 QString MyMoneyAccount::number() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_number;
 }
 
 void MyMoneyAccount::setNumber(const QString& number)
 {
   Q_D(MyMoneyAccount);
   d->m_number = number;
 }
 
 QString MyMoneyAccount::description() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_description;
 }
 
 void MyMoneyAccount::setDescription(const QString& desc)
 {
   Q_D(MyMoneyAccount);
   d->m_description = desc;
 }
 
 QDate MyMoneyAccount::openingDate() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_openingDate;
 }
 
 void MyMoneyAccount::setOpeningDate(const QDate& date)
 {
   Q_D(MyMoneyAccount);
   d->m_openingDate = date;
 }
 
 QDate MyMoneyAccount::lastReconciliationDate() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_lastReconciliationDate;
 }
 
 void MyMoneyAccount::setLastReconciliationDate(const QDate& date)
 {
   Q_D(MyMoneyAccount);
   // FIXME: for a limited time (maybe until we delivered 1.0) we
   // keep the last reconciliation date also in the KVP for backward
   // compatibility. After that, the setValue() statemetn should be removed
   // and the XML ctor should remove the value completely from the KVP
   setValue("lastStatementDate", date.toString(Qt::ISODate));
   d->m_lastReconciliationDate = date;
 }
 
 QDate MyMoneyAccount::lastModified() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_lastModified;
 }
 
 void MyMoneyAccount::setLastModified(const QDate& date)
 {
   Q_D(MyMoneyAccount);
   d->m_lastModified = date;
 }
 
 QString MyMoneyAccount::parentAccountId() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_parentAccount;
 }
 
 void MyMoneyAccount::setParentAccountId(const QString& parent)
 {
   Q_D(MyMoneyAccount);
   d->m_parentAccount = parent;
 }
 
 QStringList MyMoneyAccount::accountList() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_accountList;
 }
 
 int MyMoneyAccount::accountCount() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_accountList.count();
 }
 
 void MyMoneyAccount::addAccountId(const QString& account)
 {
   Q_D(MyMoneyAccount);
   if (!d->m_accountList.contains(account))
     d->m_accountList += account;
 }
 
 void MyMoneyAccount::removeAccountIds()
 {
   Q_D(MyMoneyAccount);
   d->m_accountList.clear();
 }
 
 void MyMoneyAccount::removeAccountId(const QString& account)
 {
   Q_D(MyMoneyAccount);
   const auto pos = d->m_accountList.indexOf(account);
   if (pos != -1)
     d->m_accountList.removeAt(pos);
 }
 
 bool MyMoneyAccount::operator == (const MyMoneyAccount& right) const
 {
   Q_D(const MyMoneyAccount);
   auto d2 = static_cast<const MyMoneyAccountPrivate *>(right.d_func());
   return (MyMoneyKeyValueContainer::operator==(right) &&
           MyMoneyObject::operator==(right) &&
           (d->m_accountList == d2->m_accountList) &&
           (d->m_accountType == d2->m_accountType) &&
           (d->m_lastModified == d2->m_lastModified) &&
           (d->m_lastReconciliationDate == d2->m_lastReconciliationDate) &&
           ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)) &&
           ((d->m_number.length() == 0 && d2->m_number.length() == 0) || (d->m_number == d2->m_number)) &&
           ((d->m_description.length() == 0 && d2->m_description.length() == 0) || (d->m_description == d2->m_description)) &&
           (d->m_openingDate == d2->m_openingDate) &&
           (d->m_parentAccount == d2->m_parentAccount) &&
           (d->m_currencyId == d2->m_currencyId) &&
           (d->m_institution == d2->m_institution));
 }
 
 Account::Type MyMoneyAccount::accountGroup() const
 {
   Q_D(const MyMoneyAccount);
   switch (d->m_accountType) {
     case Account::Type::Checkings:
     case Account::Type::Savings:
     case Account::Type::Cash:
     case Account::Type::Currency:
     case Account::Type::Investment:
     case Account::Type::MoneyMarket:
     case Account::Type::CertificateDep:
     case Account::Type::AssetLoan:
     case Account::Type::Stock:
       return Account::Type::Asset;
 
     case Account::Type::CreditCard:
     case Account::Type::Loan:
       return Account::Type::Liability;
 
     default:
       return d->m_accountType;
   }
 }
 
 QString MyMoneyAccount::currencyId() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_currencyId;
 }
 
 void MyMoneyAccount::setCurrencyId(const QString& id)
 {
   Q_D(MyMoneyAccount);
   d->m_currencyId = id;
 }
 
 bool MyMoneyAccount::isAssetLiability() const
 {
   return accountGroup() == Account::Type::Asset || accountGroup() == Account::Type::Liability;
 }
 
 bool MyMoneyAccount::isIncomeExpense() const
 {
   return accountGroup() == Account::Type::Income || accountGroup() == Account::Type::Expense;
 }
 
 bool MyMoneyAccount::isLoan() const
 {
   return accountType() == Account::Type::Loan || accountType() == Account::Type::AssetLoan;
 }
 
 bool MyMoneyAccount::isInvest() const
 {
   return accountType() == Account::Type::Stock;
 }
 
 bool MyMoneyAccount::isLiquidAsset() const
 {
   return accountType() == Account::Type::Checkings ||
          accountType() == Account::Type::Savings ||
          accountType() == Account::Type::Cash;
 }
 
 bool MyMoneyAccount::isCostCenterRequired() const
 {
   return value("CostCenter").toLower() == QLatin1String("yes");
 }
 
 void MyMoneyAccount::setCostCenterRequired(bool required)
 {
   if(required) {
     setValue("CostCenter", "yes");
   } else {
     deletePair("CostCenter");
   }
 }
 
 void MyMoneyAccount::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   auto el = document.createElement(nodeNames[nnAccount]);
 
   Q_D(const MyMoneyAccount);
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Account::Attribute::ParentAccount), parentAccountId());
   el.setAttribute(d->getAttrName(Account::Attribute::LastReconciled), MyMoneyUtils::dateToString(lastReconciliationDate()));
   el.setAttribute(d->getAttrName(Account::Attribute::LastModified), MyMoneyUtils::dateToString(lastModified()));
   el.setAttribute(d->getAttrName(Account::Attribute::Institution), institutionId());
   el.setAttribute(d->getAttrName(Account::Attribute::Opened), MyMoneyUtils::dateToString(openingDate()));
   el.setAttribute(d->getAttrName(Account::Attribute::Number), number());
   // el.setAttribute(getAttrName(anOpeningBalance), openingBalance().toString());
   el.setAttribute(d->getAttrName(Account::Attribute::Type), (int)accountType());
   el.setAttribute(d->getAttrName(Account::Attribute::Name), name());
   el.setAttribute(d->getAttrName(Account::Attribute::Description), description());
   if (!currencyId().isEmpty())
     el.setAttribute(d->getAttrName(Account::Attribute::Currency), currencyId());
 
   //Add in subaccount information, if this account has subaccounts.
   if (accountCount()) {
     QDomElement subAccounts = document.createElement(d->getElName(Account::Element::SubAccounts));
     foreach (const auto accountID, accountList()) {
       QDomElement temp = document.createElement(d->getElName(Account::Element::SubAccount));
       temp.setAttribute(d->getAttrName(Account::Attribute::ID), accountID);
       subAccounts.appendChild(temp);
     }
 
     el.appendChild(subAccounts);
   }
 
   // Write online banking settings
   if (d->m_onlineBankingSettings.pairs().count()) {
     QDomElement onlinesettings = document.createElement(d->getElName(Account::Element::OnlineBanking));
     QMap<QString, QString>::const_iterator it_key = d->m_onlineBankingSettings.pairs().constBegin();
     while (it_key != d->m_onlineBankingSettings.pairs().constEnd()) {
       onlinesettings.setAttribute(it_key.key(), it_key.value());
       ++it_key;
     }
     el.appendChild(onlinesettings);
   }
 
   // FIXME drop the lastStatementDate record from the KVP when it is
   // not stored there after setLastReconciliationDate() has been changed
   // See comment there when this will happen
   // deletePair("lastStatementDate");
 
 
   //Add in Key-Value Pairs for accounts.
   MyMoneyKeyValueContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneyAccount::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneyAccount);
   return (id == d->m_institution) || (id == d->m_parentAccount) || (id == d->m_currencyId);
 }
 
 void MyMoneyAccount::setOnlineBankingSettings(const MyMoneyKeyValueContainer& values)
 {
   Q_D(MyMoneyAccount);
   d->m_onlineBankingSettings = values;
 }
 
 MyMoneyKeyValueContainer MyMoneyAccount::onlineBankingSettings() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_onlineBankingSettings;
 }
 
 void MyMoneyAccount::setClosed(bool closed)
 {
   if (closed)
     setValue("mm-closed", "yes");
   else
     deletePair("mm-closed");
 }
 
 bool MyMoneyAccount::isClosed() const
 {
   return !(value("mm-closed").isEmpty());
 }
 
 int MyMoneyAccount::fraction(const MyMoneySecurity& sec) const
 {
   Q_D(const MyMoneyAccount);
   int fraction;
   if (d->m_accountType == Account::Type::Cash)
     fraction = sec.smallestCashFraction();
   else
     fraction = sec.smallestAccountFraction();
   return fraction;
 }
 
 int MyMoneyAccount::fraction(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyAccount);
   if (d->m_accountType == Account::Type::Cash)
     d->m_fraction = sec.smallestCashFraction();
   else
     d->m_fraction = sec.smallestAccountFraction();
   return d->m_fraction;
 }
 
 int MyMoneyAccount::fraction() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_fraction;
 }
 
 bool MyMoneyAccount::isCategory() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_accountType == Account::Type::Income || d->m_accountType == Account::Type::Expense;
 }
 
 QString MyMoneyAccount::brokerageName() const
 {
   Q_D(const MyMoneyAccount);
   if (d->m_accountType == Account::Type::Investment)
     return QString("%1 (%2)").arg(d->m_name, i18nc("Brokerage (suffix for account names)", "Brokerage"));
   return d->m_name;
 }
 
 MyMoneyMoney MyMoneyAccount::balance() const
 {
   Q_D(const MyMoneyAccount);
   return d->m_balance;
 }
 
 void MyMoneyAccount::adjustBalance(const MyMoneySplit& s, bool reverse)
 {
   Q_D(MyMoneyAccount);
   if (s.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares)) {
     if (reverse)
       d->m_balance = d->m_balance / s.shares();
     else
       d->m_balance = d->m_balance * s.shares();
   } else {
     if (reverse)
       d->m_balance -= s.shares();
     else
       d->m_balance += s.shares();
   }
 
 }
 
 void MyMoneyAccount::setBalance(const MyMoneyMoney& val)
 {
   Q_D(MyMoneyAccount);
   d->m_balance = val;
 }
 
 QPixmap MyMoneyAccount::accountPixmap(const bool reconcileFlag, const int size) const
 {
   static const QHash<Account::Type, Icon> accToIco {
     {Account::Type::Asset, Icon::ViewAsset},
     {Account::Type::Investment, Icon::ViewStock},
     {Account::Type::Stock, Icon::ViewStock},
     {Account::Type::MoneyMarket, Icon::ViewStock},
     {Account::Type::Checkings, Icon::ViewChecking},
     {Account::Type::Savings, Icon::ViewSaving},
     {Account::Type::AssetLoan, Icon::ViewLoanAsset},
     {Account::Type::Loan, Icon::ViewLoan},
     {Account::Type::CreditCard, Icon::ViewCreditCard},
     {Account::Type::Asset, Icon::ViewAsset},
     {Account::Type::Cash, Icon::ViewCash},
     {Account::Type::Income, Icon::ViewIncome},
     {Account::Type::Expense, Icon::ViewExpense},
     {Account::Type::Equity, Icon::ViewEquity}
   };
 
   Icon ixIcon = accToIco.value(accountType(), Icon::ViewLiability);
 
   QString kyIcon = accountTypeToString(accountType()) + QString::number(size);
   QPixmap pxIcon;
 
   if (!QPixmapCache::find(kyIcon, pxIcon)) {
     pxIcon = Icons::get(ixIcon).pixmap(size); // Qt::AA_UseHighDpiPixmaps (in Qt 5.7) doesn't return highdpi pixmap
     QPixmapCache::insert(kyIcon, pxIcon);
   }
 
   if (isClosed())
     ixIcon = Icon::AccountClosed;
   else if (reconcileFlag)
     ixIcon = Icon::FlagGreen;
   else if (hasOnlineMapping())
     ixIcon = Icon::Download;
   else
     return pxIcon;
 
   QPixmap pxOverlay = Icons::get(ixIcon).pixmap(size);
   QPainter pxPainter(&pxIcon);
   const QSize szIcon = pxIcon.size();
   pxPainter.drawPixmap(szIcon.width() / 2, szIcon.height() / 2,
                        szIcon.width() / 2, szIcon.height() / 2, pxOverlay);
   return pxIcon;
 }
 
 QString MyMoneyAccount::accountTypeToString(const Account::Type accountType)
 {
   switch (accountType) {
     case Account::Type::Checkings:
       return i18nc("Account type", "Checking");
     case Account::Type::Savings:
       return i18nc("Account type", "Savings");
     case Account::Type::CreditCard:
       return i18nc("Account type", "Credit Card");
     case Account::Type::Cash:
       return i18nc("Account type", "Cash");
     case Account::Type::Loan:
       return i18nc("Account type", "Loan");
     case Account::Type::CertificateDep:
       return i18nc("Account type", "Certificate of Deposit");
     case Account::Type::Investment:
       return i18nc("Account type", "Investment");
     case Account::Type::MoneyMarket:
       return i18nc("Account type", "Money Market");
     case Account::Type::Asset:
       return i18nc("Account type", "Asset");
     case Account::Type::Liability:
       return i18nc("Account type", "Liability");
     case Account::Type::Currency:
       return i18nc("Account type", "Currency");
     case Account::Type::Income:
       return i18nc("Account type", "Income");
     case Account::Type::Expense:
       return i18nc("Account type", "Expense");
     case Account::Type::AssetLoan:
       return i18nc("Account type", "Investment Loan");
     case Account::Type::Stock:
       return i18nc("Account type", "Stock");
     case Account::Type::Equity:
       return i18nc("Account type", "Equity");
     default:
       return i18nc("Account type", "Unknown");
   }
 }
 
 bool MyMoneyAccount::addReconciliation(const QDate& date, const MyMoneyMoney& amount)
 {
   Q_D(MyMoneyAccount);
   d->m_reconciliationHistory[date] = amount;
   QString history, sep;
   QMap<QDate, MyMoneyMoney>::const_iterator it;
   for (it = d->m_reconciliationHistory.constBegin();
        it != d->m_reconciliationHistory.constEnd();
        ++it) {
 
     history += QString("%1%2:%3").arg(sep,
                                       it.key().toString(Qt::ISODate),
                                       (*it).toString());
     sep = QLatin1Char(';');
   }
   setValue("reconciliationHistory", history);
   return true;
 }
 
 QMap<QDate, MyMoneyMoney> MyMoneyAccount::reconciliationHistory()
 {
   Q_D(MyMoneyAccount);
   // check if the internal history member is already loaded
   if (d->m_reconciliationHistory.count() == 0
       && !value("reconciliationHistory").isEmpty()) {
     QStringList entries = value("reconciliationHistory").split(';');
     foreach (const QString& entry, entries) {
       QStringList parts = entry.split(':');
       QDate date = QDate::fromString(parts[0], Qt::ISODate);
       MyMoneyMoney amount(parts[1]);
       if (parts.count() == 2 && date.isValid()) {
         d->m_reconciliationHistory[date] = amount;
       }
     }
   }
 
   return d->m_reconciliationHistory;
 }
 
 /**
  * @todo Improve setting of country for nationalAccount
  */
 QList< payeeIdentifier > MyMoneyAccount::payeeIdentifiers() const
 {
   Q_D(const MyMoneyAccount);
   QList< payeeIdentifier > list;
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   // Iban & Bic
   if (!value(d->getAttrName(Account::Attribute::IBAN)).isEmpty()) {
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> iban(new payeeIdentifiers::ibanBic);
     iban->setIban(value(d->getAttrName(Account::Attribute::IBAN)));
     iban->setBic(file->institution(institutionId()).value(d->getAttrName(Account::Attribute::BIC)));
     iban->setOwnerName(file->user().name());
     list.append(iban);
   }
 
   // National Account number
   if (!number().isEmpty()) {
     payeeIdentifierTyped<payeeIdentifiers::nationalAccount> national(new payeeIdentifiers::nationalAccount);
     national->setAccountNumber(number());
     national->setBankCode(file->institution(institutionId()).sortcode());
     if (file->user().state().length() == 2)
       national->setCountry(file->user().state());
     national->setOwnerName(file->user().name());
     list.append(national);
   }
 
   return list;
 }
 
 bool MyMoneyAccount::hasOnlineMapping() const
 {
   Q_D(const MyMoneyAccount);
   return !d->m_onlineBankingSettings.value(QLatin1String("provider")).isEmpty();
 }
diff --git a/kmymoney/mymoney/mymoneycostcenter.cpp b/kmymoney/mymoney/mymoneycostcenter.cpp
index 3edb9ba01..d9a6e247c 100644
--- a/kmymoney/mymoney/mymoneycostcenter.cpp
+++ b/kmymoney/mymoney/mymoneycostcenter.cpp
@@ -1,139 +1,139 @@
 /***************************************************************************
                           mymoneycostcenter.cpp
                              -------------------
     copyright            : (C) 2015 Thomas Baumgart <tbaumgart@kde.org>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneycostcenter.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDomElement>
 #include <QCollator>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyobject_p.h"
 #include "mymoneyexception.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 
 MyMoneyCostCenter MyMoneyCostCenter::null;
 
 class MyMoneyCostCenterPrivate : public MyMoneyObjectPrivate
 {
 public:
   QString m_name;
 };
 
 MyMoneyCostCenter::MyMoneyCostCenter() :
   MyMoneyObject(*new MyMoneyCostCenterPrivate)
 {
 }
 
 MyMoneyCostCenter::MyMoneyCostCenter(const QString& name) :
   MyMoneyObject(*new MyMoneyCostCenterPrivate)
 {
   Q_D(MyMoneyCostCenter);
   d->m_name = name;
 }
 
 MyMoneyCostCenter::MyMoneyCostCenter(const QDomElement& node) :
     MyMoneyObject(*new MyMoneyCostCenterPrivate, node)
 {
   if (nodeNames[nnCostCenter] != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not COSTCENTER");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not COSTCENTER");
 
   Q_D(MyMoneyCostCenter);
   d->m_name = node.attribute(getAttrName(Attribute::Name));
 }
 
 MyMoneyCostCenter::MyMoneyCostCenter(const MyMoneyCostCenter& other) :
   MyMoneyObject(*new MyMoneyCostCenterPrivate(*other.d_func()), other.id())
 {
 }
 
 MyMoneyCostCenter::MyMoneyCostCenter(const QString& id, const MyMoneyCostCenter& other) :
   MyMoneyObject(*new MyMoneyCostCenterPrivate(*other.d_func()), id)
 {
 }
 
 MyMoneyCostCenter::~MyMoneyCostCenter()
 {
 }
 
 bool MyMoneyCostCenter::operator == (const MyMoneyCostCenter& right) const
 {
   Q_D(const MyMoneyCostCenter);
   auto d2 = static_cast<const MyMoneyCostCenterPrivate *>(right.d_func());
   return (MyMoneyObject::operator==(right) &&
           ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)));
 }
 
 bool MyMoneyCostCenter::operator < (const MyMoneyCostCenter& right) const
 {
   Q_D(const MyMoneyCostCenter);
   auto d2 = static_cast<const MyMoneyCostCenterPrivate *>(right.d_func());
   QCollator col;
   return col.compare(d->m_name, d2->m_name);
 }
 
 void MyMoneyCostCenter::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   auto el = document.createElement(nodeNames[nnCostCenter]);
 
   Q_D(const MyMoneyCostCenter);
   d->writeBaseXML(document, el);
 
   el.setAttribute(getAttrName(Attribute::Name), d->m_name);
   parent.appendChild(el);
 }
 
 bool MyMoneyCostCenter::hasReferenceTo(const QString& /*id*/) const
 {
   return false;
 }
 
 QString MyMoneyCostCenter::name() const
 {
   Q_D(const MyMoneyCostCenter);
   return d->m_name;
 }
 
 void MyMoneyCostCenter::setName(const QString& val)
 {
   Q_D(MyMoneyCostCenter);
   d->m_name = val;
 }
 
 
 QString MyMoneyCostCenter::shortName() const
 {
   Q_D(const MyMoneyCostCenter);
   QRegExp shortNumberExp("^(\\d+)\\s.+");
   if(shortNumberExp.exactMatch(d->m_name)) {
     return shortNumberExp.cap(1);
   }
   return d->m_name;
 }
 
 QString MyMoneyCostCenter::getAttrName(const Attribute attr)
 {
   static const QMap<Attribute, QString> attrNames = {
     {Attribute::Name, QStringLiteral("name")},
   };
   return attrNames[attr];
 }
diff --git a/kmymoney/mymoney/mymoneyexception.cpp b/kmymoney/mymoney/mymoneyexception.cpp
deleted file mode 100644
index 5a0b45bc6..000000000
--- a/kmymoney/mymoney/mymoneyexception.cpp
+++ /dev/null
@@ -1,105 +0,0 @@
-/***************************************************************************
-                          mymoneyexception.cpp  -  description
-                             -------------------
-    begin                : Sun Apr 28 2002
-    copyright            : (C) 2000-2002 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>
-                           (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
- ***************************************************************************/
-
-/***************************************************************************
- *                                                                         *
- *   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 "mymoneyexception.h"
-
-// ----------------------------------------------------------------------------
-// QT Includes
-
-#include <QString>
-
-// ----------------------------------------------------------------------------
-// KDE Includes
-
-// ----------------------------------------------------------------------------
-// Project Includes
-
-class MyMoneyExceptionPrivate
-{
-public:
-  MyMoneyExceptionPrivate() :
-    m_line(0)
-  {
-  }
-
-  /**
-    * This member variable holds the message
-    */
-  QString m_msg;
-
-  /**
-    * This member variable holds the filename
-    */
-  QString m_file;
-
-  /**
-    * This member variable holds the line number
-    */
-  unsigned long m_line;
-};
-
-MyMoneyException::MyMoneyException() :
-  d_ptr(new MyMoneyExceptionPrivate)
-{
-}
-
-MyMoneyException::MyMoneyException(const QString& msg,
-                                   const QString& file,
-                                   const unsigned long line) :
-  d_ptr(new MyMoneyExceptionPrivate)
-{
-  Q_D(MyMoneyException);
-  // qDebug("MyMoneyException(%s,%s,%ul)", qPrintable(msg), qPrintable(file), line);
-  d->m_msg = msg;
-  d->m_file = file;
-  d->m_line = line;
-}
-
-MyMoneyException::MyMoneyException(const MyMoneyException& other) :
-  d_ptr(new MyMoneyExceptionPrivate(*other.d_func()))
-{
-}
-
-MyMoneyException::~MyMoneyException()
-{
-  Q_D(MyMoneyException);
-  delete d;
-}
-
-QString MyMoneyException::what() const
-{
-  Q_D(const MyMoneyException);
-  return d->m_msg;
-}
-
-QString MyMoneyException::file() const
-{
-  Q_D(const MyMoneyException);
-  return d->m_file;
-}
-
-unsigned long MyMoneyException::line() const
-{
-  Q_D(const MyMoneyException);
-  return d->m_line;
-}
diff --git a/kmymoney/mymoney/mymoneyexception.h b/kmymoney/mymoney/mymoneyexception.h
index 86456d452..e4dd696b0 100644
--- a/kmymoney/mymoney/mymoneyexception.h
+++ b/kmymoney/mymoney/mymoneyexception.h
@@ -1,133 +1,65 @@
 /***************************************************************************
                           mymoneyexception.h  -  description
                              -------------------
     begin                : Sun Apr 28 2002
-    copyright            : (C) 2000-2002 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>
-                           (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
+    copyright            Thomas Baumgart <ipwizard@users.sourceforge.net>
+                         (C) 2017-2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYEXCEPTION_H
 #define MYMONEYEXCEPTION_H
 
-#include "kmm_mymoney_export.h"
+#define KMM_STRINGIFY(x) #x
+#define KMM_TOSTRING(x) KMM_STRINGIFY(x)
 
-// ----------------------------------------------------------------------------
-// QT Includes
-
-#include <qglobal.h>
-
-class QString;
+#include <stdexcept>
 
 /**
   * @file
   * @author Thomas Baumgart
+  * @author Łukasz Wojniłowicz
   */
 
 /**
-  * This class describes an exception that is thrown by the engine
-  * in case of a failure.
-  */
-
-class MyMoneyExceptionPrivate;
-class KMM_MYMONEY_EXPORT MyMoneyException
-{
-public:
-
-  /**
-    * @def MYMONEYEXCEPTION(text)
-    * This is the preferred constructor to create a new exception
-    * object. It automatically inserts the filename and the source
-    * code line into the object upon creation.
-    *
-    * It is equivilant to MyMoneyException(text, __FILE__, __LINE__)
-    */
-#define MYMONEYEXCEPTION(what) MyMoneyException(what, __FILE__, __LINE__)
-
-  /**
-    * The constructor to create a new MyMoneyException object.
-    *
-    * @param msg reference to QString containing the message
-    * @param file reference to QString containing the name of the sourcefile where
-    *             the exception was thrown
-    * @param line unsigned long containing the line number of the line where
-    *             the exception was thrown in the file.
-    *
-    * An easier way to use this constructor is to use the macro
-    * MYMONEYEXCEPTION(text) instead. It automatically assigns the file
-    * and line parameter to the correct values.
-    */
-  explicit MyMoneyException(const QString& msg,
-                            const QString& file,
-                            const unsigned long line);
-
-  MyMoneyException(const MyMoneyException & other);
-  MyMoneyException(MyMoneyException && other);
-  MyMoneyException & operator=(MyMoneyException other);
-  friend void swap(MyMoneyException& first, MyMoneyException& second);
-
-  ~MyMoneyException();
+ * @def The MYMONEYEXCEPTION(exceptionMessage) define
+ * This is the preferred constructor to create a new exception
+ * object. It automatically inserts the filename and the source
+ * code line into the object upon creation.
+ */
 
-  /**
-    * This method is used to return the message that was passed
-    * during the creation of the exception object.
-    *
-    * @return reference to QString containing the message
-    */
-  QString what() const;
+#define MYMONEYEXCEPTION(exceptionMessage) MyMoneyException(qPrintable(QString::fromLatin1("%1 %2:%3").arg(exceptionMessage, QString::fromLatin1(__FILE__), QString::number(__LINE__))))
 
-  /**
-    * This method is used to return the filename that was passed
-    * during the creation of the exception object.
-    *
-    * @return reference to QString containing the filename
-    */
-  QString file() const;
-
-  /**
-    * This method is used to return the linenumber that was passed
-    * during the creation of the exception object.
-    *
-    * @return long integer containing the line number
-    */
-  unsigned long line() const;
-
-private:
-  // #define MYMONEYEXCEPTION(what) requires non-const d_ptr
-  MyMoneyExceptionPrivate * d_ptr; // krazy:exclude=dpointer
-  Q_DECLARE_PRIVATE(MyMoneyException)
-  MyMoneyException();
-};
+/**
+ * @def The MYMONEYEXCEPTION(what) define
+ * This is alternative constructor to create a new exception
+ * object. It avoids needless string conversion if the input string is const char*
+ */
 
-inline void swap(MyMoneyException& first, MyMoneyException& second) // krazy:exclude=inline
-{
-  using std::swap;
-  swap(first.d_ptr, second.d_ptr);
-}
+#define MYMONEYEXCEPTION_CSTRING(exceptionMessage) MyMoneyException(exceptionMessage " " __FILE__ ":" KMM_TOSTRING(__LINE__))
 
-inline MyMoneyException::MyMoneyException(MyMoneyException && other) : MyMoneyException() // krazy:exclude=inline
-{
-  swap(*this, other);
-}
+/**
+  * The constructor to create a new MyMoneyException object.
+  *
+  * @param exceptionMessage reference to const char * containing the message
+  *
+  * An easier way to use this constructor is to use the macro
+  * MYMONEYEXCEPTION(text) instead. It automatically assigns the file
+  * and line parameter to the correct values.
+  */
 
-inline MyMoneyException & MyMoneyException::operator=(MyMoneyException other) // krazy:exclude=inline
+class MyMoneyException : public std::runtime_error
 {
-  swap(*this, other);
-  return *this;
-}
+public:
+  explicit MyMoneyException(const char *exceptionMessage) : std::runtime_error(exceptionMessage) {}
+};
 
 #endif
diff --git a/kmymoney/mymoney/mymoneyfile.cpp b/kmymoney/mymoney/mymoneyfile.cpp
index de70bfe8d..253023b4a 100644
--- a/kmymoney/mymoney/mymoneyfile.cpp
+++ b/kmymoney/mymoney/mymoneyfile.cpp
@@ -1,3469 +1,3467 @@
 /***************************************************************************
                           mymoneyfile.cpp
                              -------------------
     copyright    : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                    (C) 2002, 2007-2011 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                    (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyfile.h"
 
 #include <utility>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QList>
 #include <QUuid>
 #include <QLocale>
 #include <QBitArray>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneystoragemgr.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneysecurity.h"
 #include "mymoneyreport.h"
 #include "mymoneybalancecache.h"
 #include "mymoneybudget.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneycostcenter.h"
 #include "mymoneyexception.h"
 #include "onlinejob.h"
 #include "storageenums.h"
 #include "mymoneystoragenames.h"
 #include "mymoneyenums.h"
 
 // include the following line to get a 'cout' for debug purposes
 // #include <iostream>
 
 using namespace eMyMoney;
 using namespace MyMoneyStandardAccounts;
 
 const QString MyMoneyFile::AccountSeparator = QChar(':');
 
 MyMoneyFile MyMoneyFile::file;
 
 typedef QList<std::pair<QString, QDate> > BalanceNotifyList;
 typedef QMap<QString, bool> CacheNotifyList;
 
 /// @todo make this template based
 class MyMoneyNotification
 {
 public:
   MyMoneyNotification(File::Mode mode, const MyMoneyTransaction& t) :
       m_objType(File::Object::Transaction),
       m_notificationMode(mode),
       m_id(t.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneyAccount& acc) :
       m_objType(File::Object::Account),
       m_notificationMode(mode),
       m_id(acc.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneyInstitution& institution) :
       m_objType(File::Object::Institution),
       m_notificationMode(mode),
       m_id(institution.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneyPayee& payee) :
       m_objType(File::Object::Payee),
       m_notificationMode(mode),
       m_id(payee.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneyTag& tag) :
       m_objType(File::Object::Tag),
       m_notificationMode(mode),
       m_id(tag.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneySchedule& schedule) :
       m_objType(File::Object::Schedule),
       m_notificationMode(mode),
       m_id(schedule.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const MyMoneySecurity& security) :
       m_objType(File::Object::Security),
       m_notificationMode(mode),
       m_id(security.id()) {
   }
 
   MyMoneyNotification(File::Mode mode, const onlineJob& job) :
       m_objType(File::Object::OnlineJob),
       m_notificationMode(mode),
       m_id(job.id()) {
   }
 
   File::Object objectType() const {
     return m_objType;
   }
   File::Mode notificationMode() const {
     return m_notificationMode;
   }
   const QString& id() const {
     return m_id;
   }
 
 protected:
   MyMoneyNotification(File::Object obj,
                       File::Mode mode,
                       const QString& id) :
       m_objType(obj),
       m_notificationMode(mode),
       m_id(id) {}
 
 private:
   File::Object   m_objType;
   File::Mode     m_notificationMode;
   QString                            m_id;
 };
 
 
 
 
 
 class MyMoneyFile::Private
 {
 public:
   Private() :
       m_storage(0),
       m_inTransaction(false) {}
 
   ~Private() {
     delete m_storage;
   }
   /**
     * This method is used to add an id to the list of objects
     * to be removed from the cache. If id is empty, then nothing is added to the list.
     *
     * @param id id of object to be notified
     * @param reload reload the object (@c true) or not (@c false). The default is @c true
     * @see attach, detach
     */
   void addCacheNotification(const QString& id, const QDate& date) {
     if (!id.isEmpty())
       m_balanceNotifyList.append(std::make_pair(id, date));
   }
 
   /**
     * This method is used to clear the notification list
     */
   void clearCacheNotification() {
     // reset list to be empty
     m_balanceNotifyList.clear();
   }
 
   /**
     * This method is used to clear all
     * objects mentioned in m_notificationList from the cache.
     */
   void notify() {
     foreach (const BalanceNotifyList::value_type & i, m_balanceNotifyList) {
       m_balanceChangedSet += i.first;
       if (i.second.isValid()) {
         m_balanceCache.clear(i.first, i.second);
       } else {
         m_balanceCache.clear(i.first);
       }
     }
 
     clearCacheNotification();
   }
 
   /**
     * This method checks if a storage object is attached and
     * throws and exception if not.
     */
   inline void checkStorage() const {
     if (m_storage == 0)
-      throw MYMONEYEXCEPTION("No storage object attached to MyMoneyFile");
+      throw MYMONEYEXCEPTION_CSTRING("No storage object attached to MyMoneyFile");
   }
 
   /**
     * This method checks that a transaction has been started with
     * startTransaction() and throws an exception otherwise. Calls
     * checkStorage() to make sure a storage object is present and attached.
     */
   void checkTransaction(const char* txt) const {
     checkStorage();
-    if (!m_inTransaction) {
-      throw MYMONEYEXCEPTION(QString("No transaction started for %1").arg(txt));
-    }
+    if (!m_inTransaction)
+      throw MYMONEYEXCEPTION(QString::fromLatin1("No transaction started for %1").arg(QString::fromLatin1(txt)));
   }
 
   void priceChanged(const MyMoneyFile& file, const MyMoneyPrice price) {
     // get all affected accounts and add them to the m_valueChangedSet
     QList<MyMoneyAccount> accList;
     file.accountList(accList);
     QList<MyMoneyAccount>::const_iterator account_it;
     for (account_it = accList.constBegin(); account_it != accList.constEnd(); ++account_it) {
       QString currencyId = account_it->currencyId();
       if (currencyId != file.baseCurrency().id() && (currencyId == price.from() || currencyId == price.to())) {
         // this account is not in the base currency and the price affects it's value
         m_valueChangedSet.insert(account_it->id());
       }
     }
   }
 
   /**
     * This member points to the storage strategy
     */
   MyMoneyStorageMgr *m_storage;
 
 
   bool                   m_inTransaction;
   MyMoneySecurity        m_baseCurrency;
 
   /**
    * @brief Cache for MyMoneyObjects
    *
    * It is also used to emit the objectAdded() and objectModified() signals.
    * => If one of these signals is used, you must use this cache.
    */
   MyMoneyPriceList       m_priceCache;
   MyMoneyBalanceCache    m_balanceCache;
 
   /**
     * This member keeps a list of account ids to notify
     * after a single operation is completed. The balance cache
     * is cleared for that account and all dates on or after
     * the one supplied. If the date is invalid, the entire
     * balance cache is cleared for that account.
     */
   BalanceNotifyList m_balanceNotifyList;
 
   /**
     * This member keeps a list of account ids for which
     * a balanceChanged() signal needs to be emitted when
     * a set of operations has been committed.
     *
     * @sa MyMoneyFile::commitTransaction()
     */
   QSet<QString>     m_balanceChangedSet;
 
   /**
     * This member keeps a list of account ids for which
     * a valueChanged() signal needs to be emitted when
     * a set of operations has been committed.
     *
     * @sa MyMoneyFile::commitTransaction()
     */
   QSet<QString>     m_valueChangedSet;
 
   /**
     * This member keeps the list of changes in the engine
     * in historical order. The type can be 'added', 'modified'
     * or removed.
     */
   QList<MyMoneyNotification> m_changeSet;
 };
 
 
 class MyMoneyNotifier
 {
 public:
   MyMoneyNotifier(MyMoneyFile::Private* file) {
     m_file = file; m_file->clearCacheNotification();
   }
   ~MyMoneyNotifier() {
     m_file->notify();
   }
 private:
   MyMoneyFile::Private* m_file;
 };
 
 
 
 MyMoneyFile::MyMoneyFile() :
     d(new Private)
 {
 }
 
 MyMoneyFile::~MyMoneyFile()
 {
   delete d;
 }
 
 MyMoneyFile::MyMoneyFile(MyMoneyStorageMgr *storage) :
     d(new Private)
 {
   attachStorage(storage);
 }
 
 MyMoneyFile* MyMoneyFile::instance()
 {
   return &file;
 }
 
 void MyMoneyFile::attachStorage(MyMoneyStorageMgr* const storage)
 {
   if (d->m_storage != 0)
-    throw MYMONEYEXCEPTION("Storage already attached");
+    throw MYMONEYEXCEPTION_CSTRING("Storage already attached");
 
   if (storage == 0)
-    throw MYMONEYEXCEPTION("Storage must not be 0");
+    throw MYMONEYEXCEPTION_CSTRING("Storage must not be 0");
 
   d->m_storage = storage;
 
   // force reload of base currency
   d->m_baseCurrency = MyMoneySecurity();
 
   // and the whole cache
   d->m_balanceCache.clear();
   d->m_priceCache.clear();
 
   // notify application about new data availability
   emit beginChangeNotification();
   emit dataChanged();
   emit endChangeNotification();
 }
 
 void MyMoneyFile::detachStorage(MyMoneyStorageMgr* const /* storage */)
 {
   d->m_balanceCache.clear();
   d->m_priceCache.clear();
   d->m_storage = nullptr;
 }
 
 MyMoneyStorageMgr* MyMoneyFile::storage() const
 {
   return d->m_storage;
 }
 
 bool MyMoneyFile::storageAttached() const
 {
   return d->m_storage != 0;
 }
 
 void MyMoneyFile::startTransaction()
 {
   d->checkStorage();
   if (d->m_inTransaction) {
-    throw MYMONEYEXCEPTION("Already started a transaction!");
+    throw MYMONEYEXCEPTION_CSTRING("Already started a transaction!");
   }
 
   d->m_storage->startTransaction();
   d->m_inTransaction = true;
   d->m_changeSet.clear();
 }
 
 bool MyMoneyFile::hasTransaction() const
 {
   return d->m_inTransaction;
 }
 
 void MyMoneyFile::commitTransaction()
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // commit the transaction in the storage
   const auto changed = d->m_storage->commitTransaction();
   d->m_inTransaction = false;
 
   // inform the outside world about the beginning of notifications
   emit beginChangeNotification();
 
   // Now it's time to send out some signals to the outside world
   // First we go through the d->m_changeSet and emit respective
   // signals about addition, modification and removal of engine objects
   const auto& changes = d->m_changeSet;
   for (const auto& change : changes) {
     switch (change.notificationMode()) {
       case File::Mode::Remove:
         emit objectRemoved(change.objectType(), change.id());
         // if there is a balance change recorded for this account remove it since the account itself will be removed
         // this can happen when deleting categories that have transactions and the reassign category feature was used
         d->m_balanceChangedSet.remove(change.id());
         break;
       case File::Mode::Add:
         emit objectAdded(change.objectType(), change.id());
         break;
       case File::Mode::Modify:
         emit objectModified(change.objectType(), change.id());
         break;
     }
   }
 
   // we're done with the change set, so we clear it
   d->m_changeSet.clear();
 
   // now send out the balanceChanged signal for all those
   // accounts for which we have an indication about a possible
   // change.
   const auto& balanceChanges = d->m_balanceChangedSet;
   for (const auto& id : balanceChanges) {
     // if we notify about balance change we don't need to notify about value change
     // for the same account since a balance change implies a value change
     d->m_valueChangedSet.remove(id);
     emit balanceChanged(account(id));
   }
   d->m_balanceChangedSet.clear();
 
   // now notify about the remaining value changes
   const auto& m_valueChanges = d->m_valueChangedSet;
   for (const auto& id : m_valueChanges)
     emit valueChanged(account(id));
 
   d->m_valueChangedSet.clear();
 
   // as a last action, send out the global dataChanged signal
   if (changed)
     emit dataChanged();
 
   // inform the outside world about the end of notifications
   emit endChangeNotification();
 }
 
 void MyMoneyFile::rollbackTransaction()
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->rollbackTransaction();
   d->m_inTransaction = false;
   d->m_balanceChangedSet.clear();
   d->m_valueChangedSet.clear();
   d->m_changeSet.clear();
 }
 
 void MyMoneyFile::addInstitution(MyMoneyInstitution& institution)
 {
   // perform some checks to see that the institution stuff is OK. For
   // now we assume that the institution must have a name, the ID is not set
   // and it does not have a parent (MyMoneyFile).
 
   if (institution.name().length() == 0
       || institution.id().length() != 0)
-    throw MYMONEYEXCEPTION("Not a new institution");
+    throw MYMONEYEXCEPTION_CSTRING("Not a new institution");
 
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addInstitution(institution);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, institution);
 }
 
 void MyMoneyFile::modifyInstitution(const MyMoneyInstitution& institution)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifyInstitution(institution);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, institution);
 }
 
 void MyMoneyFile::modifyTransaction(const MyMoneyTransaction& transaction)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyTransaction tCopy(transaction);
 
   // now check the splits
   bool loanAccountAffected = false;
   const auto splits1 = transaction.splits();
   for (const auto& split : splits1) {
     // the following line will throw an exception if the
     // account does not exist
     auto acc = MyMoneyFile::account(split.accountId());
     if (acc.id().isEmpty())
-      throw MYMONEYEXCEPTION("Cannot store split with no account assigned");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot store split with no account assigned");
     if (isStandardAccount(split.accountId()))
-      throw MYMONEYEXCEPTION("Cannot store split referencing standard account");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot store split referencing standard account");
     if (acc.isLoan() && (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer)))
       loanAccountAffected = true;
   }
 
   // change transfer splits between asset/liability and loan accounts
   // into amortization splits
   if (loanAccountAffected) {
     const auto splits = transaction.splits();
     for (const auto& split : splits) {
       if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer)) {
         auto acc = MyMoneyFile::account(split.accountId());
 
         if (acc.isAssetLiability()) {
           MyMoneySplit s = split;
           s.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization));
           tCopy.modifySplit(s);
         }
       }
     }
   }
 
   // clear all changed objects from cache
   MyMoneyNotifier notifier(d);
 
   // get the current setting of this transaction
   MyMoneyTransaction tr = MyMoneyFile::transaction(transaction.id());
 
   // scan the splits again to update notification list
   // and mark all accounts that are referenced
   const auto splits2 = tr.splits();
   foreach (const auto& split, splits2)
     d->addCacheNotification(split.accountId(), tr.postDate());
 
   // make sure the value is rounded to the accounts precision
   fixSplitPrecision(tCopy);
 
   // perform modification
   d->m_storage->modifyTransaction(tCopy);
 
   // and mark all accounts that are referenced
   const auto splits3 = tCopy.splits();
   for (const auto& split : splits3)
     d->addCacheNotification(split.accountId(), tCopy.postDate());
 
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, transaction);
 }
 
 void MyMoneyFile::modifyAccount(const MyMoneyAccount& _account)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyAccount account(_account);
 
   auto acc = MyMoneyFile::account(account.id());
 
   // check that for standard accounts only specific parameters are changed
   if (isStandardAccount(account.id())) {
     // make sure to use the stuff we found on file
     account = acc;
 
     // and only use the changes that are allowed
     account.setName(_account.name());
     account.setCurrencyId(_account.currencyId());
 
     // now check that it is the same
     if (!(account == _account))
-      throw MYMONEYEXCEPTION("Unable to modify the standard account groups");
+      throw MYMONEYEXCEPTION_CSTRING("Unable to modify the standard account groups");
   }
 
   if (account.accountType() != acc.accountType() &&
       !account.isLiquidAsset() && !acc.isLiquidAsset())
-    throw MYMONEYEXCEPTION("Unable to change account type");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to change account type");
 
   // if the account was moved to another institution, we notify
   // the old one as well as the new one and the structure change
   if (acc.institutionId() != account.institutionId()) {
     MyMoneyInstitution inst;
     if (!acc.institutionId().isEmpty()) {
       inst = institution(acc.institutionId());
       inst.removeAccountId(acc.id());
       modifyInstitution(inst);
       // modifyInstitution updates d->m_changeSet already
     }
     if (!account.institutionId().isEmpty()) {
       inst = institution(account.institutionId());
       inst.addAccountId(acc.id());
       modifyInstitution(inst);
       // modifyInstitution updates d->m_changeSet already
     }
   }
 
   d->m_storage->modifyAccount(account);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, account);
 }
 
 void MyMoneyFile::reparentAccount(MyMoneyAccount &acc, MyMoneyAccount& parent)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // check that it's not one of the standard account groups
   if (isStandardAccount(acc.id()))
-    throw MYMONEYEXCEPTION("Unable to reparent the standard account groups");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to reparent the standard account groups");
 
   if (acc.accountGroup() == parent.accountGroup()
       || (acc.accountType() == Account::Type::Income && parent.accountType() == Account::Type::Expense)
       || (acc.accountType() == Account::Type::Expense && parent.accountType() == Account::Type::Income)) {
 
     if (acc.isInvest() && parent.accountType() != Account::Type::Investment)
-      throw MYMONEYEXCEPTION("Unable to reparent Stock to non-investment account");
+      throw MYMONEYEXCEPTION_CSTRING("Unable to reparent Stock to non-investment account");
 
     if (parent.accountType() == Account::Type::Investment && !acc.isInvest())
-      throw MYMONEYEXCEPTION("Unable to reparent non-stock to investment account");
+      throw MYMONEYEXCEPTION_CSTRING("Unable to reparent non-stock to investment account");
 
     // keep a notification of the current parent
     MyMoneyAccount curParent = account(acc.parentAccountId());
 
     d->m_storage->reparentAccount(acc, parent);
 
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, curParent);
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, parent);
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, acc);
 
   } else
-    throw MYMONEYEXCEPTION("Unable to reparent to different account type");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to reparent to different account type");
 }
 
 MyMoneyInstitution MyMoneyFile::institution(const QString& id) const
 {
   return d->m_storage->institution(id);
 }
 
 MyMoneyAccount MyMoneyFile::account(const QString& id) const
 {
   if (Q_UNLIKELY(id.isEmpty())) // FIXME: Stop requesting accounts with empty id
     return MyMoneyAccount();
 
   return d->m_storage->account(id);
 }
 
 MyMoneyAccount MyMoneyFile::subAccountByName(const MyMoneyAccount& account, const QString& name) const
 {
   static MyMoneyAccount nullAccount;
 
   const auto accounts = account.accountList();
   for (const auto& acc : accounts) {
     const auto sacc = MyMoneyFile::account(acc);
     if (sacc.name().compare(name) == 0)
       return sacc;
   }
   return nullAccount;
 }
 
 MyMoneyAccount MyMoneyFile::accountByName(const QString& name) const
 {
   try {
     return d->m_storage->accountByName(name);
-  } catch(const MyMoneyException&) {
+  } catch (const MyMoneyException &) {
   }
   return MyMoneyAccount();
 }
 
 void MyMoneyFile::removeTransaction(const MyMoneyTransaction& transaction)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // clear all changed objects from cache
   MyMoneyNotifier notifier(d);
 
   // get the engine's idea about this transaction
   MyMoneyTransaction tr = MyMoneyFile::transaction(transaction.id());
 
   // scan the splits again to update notification list
   const auto splits = tr.splits();
   for (const auto& split : splits) {
     auto acc = account(split.accountId());
     if (acc.isClosed())
-      throw MYMONEYEXCEPTION(i18n("Cannot remove transaction that references a closed account."));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove transaction that references a closed account."));
     d->addCacheNotification(split.accountId(), tr.postDate());
     //FIXME-ALEX Do I need to add d->addCacheNotification(split.tagList()); ??
   }
 
   d->m_storage->removeTransaction(transaction);
 
   // remove a possible notification of that same object from the changeSet
   QList<MyMoneyNotification>::iterator it;
   for(it = d->m_changeSet.begin(); it != d->m_changeSet.end();) {
     if((*it).id() == transaction.id()) {
       it = d->m_changeSet.erase(it);
     } else {
       ++it;
     }
   }
 
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, transaction);
 }
 
 
 bool MyMoneyFile::hasActiveSplits(const QString& id) const
 {
   d->checkStorage();
 
   return d->m_storage->hasActiveSplits(id);
 }
 
 bool MyMoneyFile::isStandardAccount(const QString& id) const
 {
   d->checkStorage();
 
   return d->m_storage->isStandardAccount(id);
 }
 
 void MyMoneyFile::setAccountName(const QString& id, const QString& name) const
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   auto acc = account(id);
   d->m_storage->setAccountName(id, name);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, acc);
 }
 
 void MyMoneyFile::removeAccount(const MyMoneyAccount& account)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyAccount parent;
   MyMoneyAccount acc;
   MyMoneyInstitution institution;
 
   // check that the account and its parent exist
   // this will throw an exception if the id is unknown
   acc = MyMoneyFile::account(account.id());
   parent = MyMoneyFile::account(account.parentAccountId());
   if (!acc.institutionId().isEmpty())
     institution = MyMoneyFile::institution(acc.institutionId());
 
   // check that it's not one of the standard account groups
   if (isStandardAccount(account.id()))
-    throw MYMONEYEXCEPTION("Unable to remove the standard account groups");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to remove the standard account groups");
 
   if (hasActiveSplits(account.id())) {
-    throw MYMONEYEXCEPTION("Unable to remove account with active splits");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to remove account with active splits");
   }
 
   // collect all sub-ordinate accounts for notification
   const auto accounts = acc.accountList();
   for (const auto& id : accounts)
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, MyMoneyFile::account(id));
 
   // don't forget the parent and a possible institution
 
   if (!institution.id().isEmpty()) {
     institution.removeAccountId(account.id());
     d->m_storage->modifyInstitution(institution);
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, institution);
   }
   acc.setInstitutionId(QString());
 
   d->m_storage->removeAccount(acc);
 
   d->m_balanceCache.clear(acc.id());
 
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, parent);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, acc);
 }
 
 void MyMoneyFile::removeAccountList(const QStringList& account_list, unsigned int level)
 {
   if (level > 100)
-    throw MYMONEYEXCEPTION("Too deep recursion in [MyMoneyFile::removeAccountList]!");
+    throw MYMONEYEXCEPTION_CSTRING("Too deep recursion in [MyMoneyFile::removeAccountList]!");
 
   d->checkTransaction(Q_FUNC_INFO);
 
   // upon entry, we check that we could proceed with the operation
   if (!level) {
     if (!hasOnlyUnusedAccounts(account_list, 0)) {
-      throw MYMONEYEXCEPTION("One or more accounts cannot be removed");
+      throw MYMONEYEXCEPTION_CSTRING("One or more accounts cannot be removed");
     }
   }
 
   // process all accounts in the list and test if they have transactions assigned
   foreach (const auto sAccount, account_list) {
     auto a = d->m_storage->account(sAccount);
     //qDebug() << "Deleting account '"<< a.name() << "'";
 
     // first remove all sub-accounts
     if (!a.accountList().isEmpty()) {
       removeAccountList(a.accountList(), level + 1);
 
       // then remove account itself, but we first have to get
       // rid of the account list that is still stored in
       // the MyMoneyAccount object. Easiest way is to get a fresh copy.
       a = d->m_storage->account(sAccount);
     }
 
     // make sure to remove the item from the cache
     removeAccount(a);
   }
 }
 
 bool MyMoneyFile::hasOnlyUnusedAccounts(const QStringList& account_list, unsigned int level)
 {
   if (level > 100)
-    throw MYMONEYEXCEPTION("Too deep recursion in [MyMoneyFile::hasOnlyUnusedAccounts]!");
+    throw MYMONEYEXCEPTION_CSTRING("Too deep recursion in [MyMoneyFile::hasOnlyUnusedAccounts]!");
   // process all accounts in the list and test if they have transactions assigned
   for (const auto& sAccount : account_list) {
     if (transactionCount(sAccount) != 0)
       return false; // the current account has a transaction assigned
     if (!hasOnlyUnusedAccounts(account(sAccount).accountList(), level + 1))
       return false; // some sub-account has a transaction assigned
   }
   return true; // all subaccounts unused
 }
 
 
 void MyMoneyFile::removeInstitution(const MyMoneyInstitution& institution)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyInstitution inst = MyMoneyFile::institution(institution.id());
 
   bool blocked = signalsBlocked();
   blockSignals(true);
   const auto accounts = inst.accountList();
   for (const auto& acc : accounts) {
     auto a = account(acc);
     a.setInstitutionId(QString());
     modifyAccount(a);
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, a);
   }
   blockSignals(blocked);
 
   d->m_storage->removeInstitution(institution);
 
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, institution);
 }
 
 void MyMoneyFile::createAccount(MyMoneyAccount& newAccount, MyMoneyAccount& parentAccount, MyMoneyAccount& brokerageAccount, MyMoneyMoney openingBal)
 {
   // make sure we have a currency. If none is assigned, we assume base currency
   if (newAccount.currencyId().isEmpty())
     newAccount.setCurrencyId(baseCurrency().id());
 
   MyMoneyFileTransaction ft;
   try {
     int pos;
     // check for ':' in the name and use it as separator for a hierarchy
     while ((pos = newAccount.name().indexOf(MyMoneyFile::AccountSeparator)) != -1) {
       QString part = newAccount.name().left(pos);
       QString remainder = newAccount.name().mid(pos + 1);
       const MyMoneyAccount& existingAccount = subAccountByName(parentAccount, part);
       if (existingAccount.id().isEmpty()) {
         newAccount.setName(part);
 
         addAccount(newAccount, parentAccount);
         parentAccount = newAccount;
       } else {
         parentAccount = existingAccount;
       }
       newAccount.setParentAccountId(QString());  // make sure, there's no parent
       newAccount.clearId();                       // and no id set for adding
       newAccount.removeAccountIds();              // and no sub-account ids
       newAccount.setName(remainder);
     }
 
     addAccount(newAccount, parentAccount);
 
     // in case of a loan account, we add the initial payment
     if ((newAccount.accountType() == Account::Type::Loan
          || newAccount.accountType() == Account::Type::AssetLoan)
         && !newAccount.value("kmm-loan-payment-acc").isEmpty()
         && !newAccount.value("kmm-loan-payment-date").isEmpty()) {
       MyMoneyAccountLoan acc(newAccount);
       MyMoneyTransaction t;
       MyMoneySplit a, b;
       a.setAccountId(acc.id());
       b.setAccountId(acc.value("kmm-loan-payment-acc").toLatin1());
       a.setValue(acc.loanAmount());
       if (acc.accountType() == Account::Type::Loan)
         a.setValue(-a.value());
 
       a.setShares(a.value());
       b.setValue(-a.value());
       b.setShares(b.value());
       a.setMemo(i18n("Loan payout"));
       b.setMemo(i18n("Loan payout"));
       t.setPostDate(QDate::fromString(acc.value("kmm-loan-payment-date"), Qt::ISODate));
       newAccount.deletePair("kmm-loan-payment-acc");
       newAccount.deletePair("kmm-loan-payment-date");
       MyMoneyFile::instance()->modifyAccount(newAccount);
 
       t.addSplit(a);
       t.addSplit(b);
       addTransaction(t);
       createOpeningBalanceTransaction(newAccount, openingBal);
 
       // in case of an investment account we check if we should create
       // a brokerage account
     } else if (newAccount.accountType() == Account::Type::Investment
                && !brokerageAccount.name().isEmpty()) {
       addAccount(brokerageAccount, parentAccount);
 
       // set a link from the investment account to the brokerage account
       modifyAccount(newAccount);
       createOpeningBalanceTransaction(brokerageAccount, openingBal);
 
     } else
       createOpeningBalanceTransaction(newAccount, openingBal);
 
     ft.commit();
   } catch (const MyMoneyException &e) {
-    qWarning("Unable to create account: %s", qPrintable(e.what()));
-    throw MYMONEYEXCEPTION(e.what());
+    qWarning("Unable to create account: %s", e.what());
+    throw;
   }
 }
 
 void MyMoneyFile::addAccount(MyMoneyAccount& account, MyMoneyAccount& parent)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyInstitution institution;
 
   // perform some checks to see that the account stuff is OK. For
   // now we assume that the account must have a name, has no
   // transaction and sub-accounts and parent account
   // it's own ID is not set and it does not have a pointer to (MyMoneyFile)
 
   if (account.name().length() == 0)
-    throw MYMONEYEXCEPTION("Account has no name");
+    throw MYMONEYEXCEPTION_CSTRING("Account has no name");
 
   if (account.id().length() != 0)
-    throw MYMONEYEXCEPTION("New account must have no id");
+    throw MYMONEYEXCEPTION_CSTRING("New account must have no id");
 
   if (account.accountList().count() != 0)
-    throw MYMONEYEXCEPTION("New account must have no sub-accounts");
+    throw MYMONEYEXCEPTION_CSTRING("New account must have no sub-accounts");
 
   if (!account.parentAccountId().isEmpty())
-    throw MYMONEYEXCEPTION("New account must have no parent-id");
+    throw MYMONEYEXCEPTION_CSTRING("New account must have no parent-id");
 
   if (account.accountType() == Account::Type::Unknown)
-    throw MYMONEYEXCEPTION("Account has invalid type");
+    throw MYMONEYEXCEPTION_CSTRING("Account has invalid type");
 
   // make sure, that the parent account exists
   // if not, an exception is thrown. If it exists,
   // get a copy of the current data
   auto acc = MyMoneyFile::account(parent.id());
 
 #if 0
   // TODO: remove the following code as we now can have multiple accounts
   // with the same name even in the same hierarchy position of the account tree
   //
   // check if the selected name is currently not among the child accounts
   // if we find one, then return it as the new account
   QStringList::const_iterator it_a;
   foreach (const auto accountID, acc.accountList()) {
     MyMoneyAccount a = MyMoneyFile::account(accountID);
     if (account.name() == a.name()) {
       account = a;
       return;
     }
   }
 #endif
 
   // FIXME: make sure, that the parent has the same type
   // I left it out here because I don't know, if there is
   // a tight coupling between e.g. checking accounts and the
   // class asset. It certainly does not make sense to create an
   // expense account under an income account. Maybe it does, I don't know.
 
   // We enforce, that a stock account can never be a parent and
   // that the parent for a stock account must be an investment. Also,
   // an investment cannot have another investment account as it's parent
   if (parent.isInvest())
-    throw MYMONEYEXCEPTION("Stock account cannot be parent account");
+    throw MYMONEYEXCEPTION_CSTRING("Stock account cannot be parent account");
 
   if (account.isInvest() && parent.accountType() != Account::Type::Investment)
-    throw MYMONEYEXCEPTION("Stock account must have investment account as parent ");
+    throw MYMONEYEXCEPTION_CSTRING("Stock account must have investment account as parent ");
 
   if (!account.isInvest() && parent.accountType() == Account::Type::Investment)
-    throw MYMONEYEXCEPTION("Investment account can only have stock accounts as children");
+    throw MYMONEYEXCEPTION_CSTRING("Investment account can only have stock accounts as children");
 
   // if an institution is set, verify that it exists
   if (account.institutionId().length() != 0) {
     // check the presence of the institution. if it
     // does not exist, an exception is thrown
     institution = MyMoneyFile::institution(account.institutionId());
   }
 
   // if we don't have a valid opening date use today
   if (!account.openingDate().isValid()) {
     account.setOpeningDate(QDate::currentDate());
   }
 
   // make sure to set the opening date for categories to a
   // fixed date (1900-1-1). See #313793 on b.k.o for details
   if (account.isIncomeExpense()) {
     account.setOpeningDate(QDate(1900, 1, 1));
   }
 
   // if we don't have a currency assigned use the base currency
   if (account.currencyId().isEmpty()) {
     account.setCurrencyId(baseCurrency().id());
   }
 
   // make sure the parent id is setup
   account.setParentAccountId(parent.id());
 
   d->m_storage->addAccount(account);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, account);
 
   d->m_storage->addAccount(parent, account);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, parent);
 
   if (account.institutionId().length() != 0) {
     institution.addAccountId(account.id());
     d->m_storage->modifyInstitution(institution);
     d->m_changeSet += MyMoneyNotification(File::Mode::Modify, institution);
   }
 }
 
 MyMoneyTransaction MyMoneyFile::createOpeningBalanceTransaction(const MyMoneyAccount& acc, const MyMoneyMoney& balance)
 {
   MyMoneyTransaction t;
   // if the opening balance is not zero, we need
   // to create the respective transaction
   if (!balance.isZero()) {
     d->checkTransaction(Q_FUNC_INFO);
 
     MyMoneySecurity currency = security(acc.currencyId());
     MyMoneyAccount openAcc = openingBalanceAccount(currency);
 
     if (openAcc.openingDate() > acc.openingDate()) {
       openAcc.setOpeningDate(acc.openingDate());
       modifyAccount(openAcc);
     }
 
     MyMoneySplit s;
 
     t.setPostDate(acc.openingDate());
     t.setCommodity(acc.currencyId());
 
     s.setAccountId(acc.id());
     s.setShares(balance);
     s.setValue(balance);
     t.addSplit(s);
 
     s.clearId();
     s.setAccountId(openAcc.id());
     s.setShares(-balance);
     s.setValue(-balance);
     t.addSplit(s);
 
     addTransaction(t);
   }
   return t;
 }
 
 QString MyMoneyFile::openingBalanceTransaction(const MyMoneyAccount& acc) const
 {
   QString result;
 
   MyMoneySecurity currency = security(acc.currencyId());
   MyMoneyAccount openAcc;
 
   try {
     openAcc = openingBalanceAccount(currency);
   } catch (const MyMoneyException &) {
     return result;
   }
 
   // Iterate over all the opening balance transactions for this currency
   MyMoneyTransactionFilter filter;
   filter.addAccount(openAcc.id());
   QList<MyMoneyTransaction> transactions = transactionList(filter);
   QList<MyMoneyTransaction>::const_iterator it_t = transactions.constBegin();
   while (it_t != transactions.constEnd()) {
     try {
       // Test whether the transaction also includes a split into
       // this account
       (*it_t).splitByAccount(acc.id(), true /*match*/);
 
       // If so, we have a winner!
       result = (*it_t).id();
       break;
     } catch (const MyMoneyException &) {
       // If not, keep searching
       ++it_t;
     }
   }
 
   return result;
 }
 
 MyMoneyAccount MyMoneyFile::openingBalanceAccount(const MyMoneySecurity& security)
 {
   if (!security.isCurrency())
-    throw MYMONEYEXCEPTION("Opening balance for non currencies not supported");
+    throw MYMONEYEXCEPTION_CSTRING("Opening balance for non currencies not supported");
 
   try {
     return openingBalanceAccount_internal(security);
   } catch (const MyMoneyException &) {
     MyMoneyFileTransaction ft;
     MyMoneyAccount acc;
 
     try {
       acc = createOpeningBalanceAccount(security);
       ft.commit();
 
     } catch (const MyMoneyException &) {
       qDebug("Unable to create opening balance account for security %s", qPrintable(security.id()));
     }
     return acc;
   }
 }
 
 MyMoneyAccount MyMoneyFile::openingBalanceAccount(const MyMoneySecurity& security) const
 {
   return openingBalanceAccount_internal(security);
 }
 
 MyMoneyAccount MyMoneyFile::openingBalanceAccount_internal(const MyMoneySecurity& security) const
 {
   if (!security.isCurrency())
-    throw MYMONEYEXCEPTION("Opening balance for non currencies not supported");
+    throw MYMONEYEXCEPTION_CSTRING("Opening balance for non currencies not supported");
 
   MyMoneyAccount acc;
   QList<MyMoneyAccount> accounts;
   QList<MyMoneyAccount>::ConstIterator it;
 
   accountList(accounts, equity().accountList(), true);
 
   for (it = accounts.constBegin(); it != accounts.constEnd(); ++it) {
     if (it->value("OpeningBalanceAccount") == QLatin1String("Yes")
         && it->currencyId() == security.id()) {
       acc = *it;
       break;
     }
   }
 
   if (acc.id().isEmpty()) {
     for (it = accounts.constBegin(); it != accounts.constEnd(); ++it) {
       if (it->name().startsWith(MyMoneyFile::openingBalancesPrefix())
           && it->currencyId() == security.id()) {
         acc = *it;
         break;
       }
     }
   }
 
-  if (acc.id().isEmpty()) {
-    throw MYMONEYEXCEPTION(QString("No opening balance account for %1").arg(security.tradingSymbol()));
-  }
+  if (acc.id().isEmpty())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("No opening balance account for %1").arg(security.tradingSymbol()));
 
   return acc;
 }
 
 MyMoneyAccount MyMoneyFile::createOpeningBalanceAccount(const MyMoneySecurity& security)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyAccount acc;
   QList<MyMoneyAccount> accounts;
   QList<MyMoneyAccount>::ConstIterator it;
 
   accountList(accounts, equity().accountList(), true);
 
   // find present opening balance accounts without containing '('
   QString name;
   QString parentAccountId;
   QRegExp exp(QString("\\([A-Z]{3}\\)"));
 
   for (it = accounts.constBegin(); it != accounts.constEnd(); ++it) {
     if (it->value("OpeningBalanceAccount") == QLatin1String("Yes")
         && exp.indexIn(it->name()) == -1) {
       name = it->name();
       parentAccountId = it->parentAccountId();
       break;
     }
   }
 
   if (name.isEmpty())
     name = MyMoneyFile::openingBalancesPrefix();
   if (security.id() != baseCurrency().id()) {
     name += QString(" (%1)").arg(security.id());
   }
   acc.setName(name);
   acc.setAccountType(Account::Type::Equity);
   acc.setCurrencyId(security.id());
   acc.setValue("OpeningBalanceAccount", "Yes");
 
   MyMoneyAccount parent = !parentAccountId.isEmpty() ? account(parentAccountId) : equity();
   this->addAccount(acc, parent);
   return acc;
 }
 
 void MyMoneyFile::addTransaction(MyMoneyTransaction& transaction)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // clear all changed objects from cache
   MyMoneyNotifier notifier(d);
 
   // perform some checks to see that the transaction stuff is OK. For
   // now we assume that
   // * no ids are assigned
   // * the date valid (must not be empty)
   // * the referenced accounts in the splits exist
 
   // first perform all the checks
   if (!transaction.id().isEmpty())
-    throw MYMONEYEXCEPTION("Unable to add transaction with id set");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to add transaction with id set");
   if (!transaction.postDate().isValid())
-    throw MYMONEYEXCEPTION("Unable to add transaction with invalid postdate");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to add transaction with invalid postdate");
 
   // now check the splits
   auto loanAccountAffected = false;
   const auto splits1 = transaction.splits();
   for (const auto& split : splits1) {
     // the following line will throw an exception if the
     // account does not exist or is one of the standard accounts
     auto acc = MyMoneyFile::account(split.accountId());
     if (acc.id().isEmpty())
-      throw MYMONEYEXCEPTION("Cannot add split with no account assigned");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot add split with no account assigned");
     if (acc.isLoan())
       loanAccountAffected = true;
     if (isStandardAccount(split.accountId()))
-      throw MYMONEYEXCEPTION("Cannot add split referencing standard account");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot add split referencing standard account");
   }
 
   // change transfer splits between asset/liability and loan accounts
   // into amortization splits
   if (loanAccountAffected) {
     foreach (const auto split, transaction.splits()) {
       if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer)) {
         auto acc = MyMoneyFile::account(split.accountId());
 
         if (acc.isAssetLiability()) {
           MyMoneySplit s = split;
           s.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization));
           transaction.modifySplit(s);
         }
       }
     }
   }
 
   // check that we have a commodity
   if (transaction.commodity().isEmpty()) {
     transaction.setCommodity(baseCurrency().id());
   }
 
   // make sure the value is rounded to the accounts precision
   fixSplitPrecision(transaction);
 
   // then add the transaction to the file global pool
   d->m_storage->addTransaction(transaction);
 
   // scan the splits again to update notification list
   const auto splits2 = transaction.splits();
   for (const auto& split : splits2)
     d->addCacheNotification(split.accountId(), transaction.postDate());
 
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, transaction);
 }
 
 MyMoneyTransaction MyMoneyFile::transaction(const QString& id) const
 {
   d->checkStorage();
 
   return d->m_storage->transaction(id);
 }
 
 MyMoneyTransaction MyMoneyFile::transaction(const QString& account, const int idx) const
 {
   d->checkStorage();
 
   return d->m_storage->transaction(account, idx);
 }
 
 void MyMoneyFile::addPayee(MyMoneyPayee& payee)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addPayee(payee);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, payee);
 }
 
 MyMoneyPayee MyMoneyFile::payee(const QString& id) const
 {
   if (Q_UNLIKELY(id.isEmpty()))
     return MyMoneyPayee();
 
   return d->m_storage->payee(id);
 }
 
 MyMoneyPayee MyMoneyFile::payeeByName(const QString& name) const
 {
   d->checkStorage();
 
   return d->m_storage->payeeByName(name);
 }
 
 void MyMoneyFile::modifyPayee(const MyMoneyPayee& payee)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifyPayee(payee);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, payee);
 }
 
 void MyMoneyFile::removePayee(const MyMoneyPayee& payee)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // FIXME we need to make sure, that the payee is not referenced anymore
   d->m_storage->removePayee(payee);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, payee);
 }
 
 void MyMoneyFile::addTag(MyMoneyTag& tag)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addTag(tag);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, tag);
 }
 
 MyMoneyTag MyMoneyFile::tag(const QString& id) const
 {
   return d->m_storage->tag(id);
 }
 
 MyMoneyTag MyMoneyFile::tagByName(const QString& name) const
 {
   d->checkStorage();
 
   return d->m_storage->tagByName(name);
 }
 
 void MyMoneyFile::modifyTag(const MyMoneyTag& tag)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifyTag(tag);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, tag);
 }
 
 void MyMoneyFile::removeTag(const MyMoneyTag& tag)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // FIXME we need to make sure, that the tag is not referenced anymore
   d->m_storage->removeTag(tag);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, tag);
 }
 
 void MyMoneyFile::accountList(QList<MyMoneyAccount>& list, const QStringList& idlist, const bool recursive) const
 {
   if (idlist.isEmpty()) {
     d->m_storage->accountList(list);
 
 #if 0
     // TODO: I have no idea what this was good for, but it caused the networth report
     //       to show double the numbers so I commented it out (ipwizard, 2008-05-24)
     if (d->m_storage && (list.isEmpty() || list.size() != d->m_storage->accountCount())) {
       d->m_storage->accountList(list);
       d->m_cache.preloadAccount(list);
     }
 #endif
 
     QList<MyMoneyAccount>::Iterator it;
     for (it = list.begin(); it != list.end();) {
       if (isStandardAccount((*it).id())) {
         it = list.erase(it);
       } else {
         ++it;
       }
     }
   } else {
     QList<MyMoneyAccount>::ConstIterator it;
     QList<MyMoneyAccount> list_a;
     d->m_storage->accountList(list_a);
 
     for (it = list_a.constBegin(); it != list_a.constEnd(); ++it) {
       if (!isStandardAccount((*it).id())) {
         if (idlist.indexOf((*it).id()) != -1) {
           list.append(*it);
           if (recursive == true && !(*it).accountList().isEmpty()) {
             accountList(list, (*it).accountList(), true);
           }
         }
       }
     }
   }
 }
 
 QList<MyMoneyInstitution> MyMoneyFile::institutionList() const
 {
   return d->m_storage->institutionList();
 }
 
 // general get functions
 MyMoneyPayee MyMoneyFile::user() const
 {
   d->checkStorage();
   return d->m_storage->user();
 }
 
 // general set functions
 void MyMoneyFile::setUser(const MyMoneyPayee& user)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->setUser(user);
 }
 
 bool MyMoneyFile::dirty() const
 {
   if (!d->m_storage)
     return false;
 
   return d->m_storage->dirty();
 }
 
 void MyMoneyFile::setDirty() const
 {
   d->checkStorage();
 
   d->m_storage->setDirty();
 }
 
 unsigned int MyMoneyFile::accountCount() const
 {
   d->checkStorage();
 
   return d->m_storage->accountCount();
 }
 
 void MyMoneyFile::ensureDefaultCurrency(MyMoneyAccount& acc) const
 {
   if (acc.currencyId().isEmpty()) {
     if (!baseCurrency().id().isEmpty())
       acc.setCurrencyId(baseCurrency().id());
   }
 }
 
 MyMoneyAccount MyMoneyFile::liability() const
 {
   d->checkStorage();
 
   return account(stdAccNames[stdAccLiability]);
 }
 
 MyMoneyAccount MyMoneyFile::asset() const
 {
   d->checkStorage();
 
   return account(stdAccNames[stdAccAsset]);
 }
 
 MyMoneyAccount MyMoneyFile::expense() const
 {
   d->checkStorage();
 
   return account(stdAccNames[stdAccExpense]);
 }
 
 MyMoneyAccount MyMoneyFile::income() const
 {
   d->checkStorage();
 
   return account(stdAccNames[stdAccIncome]);
 }
 
 MyMoneyAccount MyMoneyFile::equity() const
 {
   d->checkStorage();
 
   return account(stdAccNames[stdAccEquity]);
 }
 
 unsigned int MyMoneyFile::transactionCount(const QString& account) const
 {
   d->checkStorage();
 
   return d->m_storage->transactionCount(account);
 }
 
 unsigned int MyMoneyFile::transactionCount() const
 {
   return transactionCount(QString());
 }
 
 QMap<QString, unsigned long> MyMoneyFile::transactionCountMap() const
 {
   d->checkStorage();
 
   return d->m_storage->transactionCountMap();
 }
 
 unsigned int MyMoneyFile::institutionCount() const
 {
   d->checkStorage();
 
   return d->m_storage->institutionCount();
 }
 
 MyMoneyMoney MyMoneyFile::balance(const QString& id, const QDate& date) const
 {
   if (date.isValid()) {
     MyMoneyBalanceCacheItem bal = d->m_balanceCache.balance(id, date);
     if (bal.isValid())
       return bal.balance();
   }
 
   d->checkStorage();
 
   MyMoneyMoney returnValue = d->m_storage->balance(id, date);
 
   if (date.isValid()) {
     d->m_balanceCache.insert(id, date, returnValue);
   }
 
   return returnValue;
 }
 
 MyMoneyMoney MyMoneyFile::balance(const QString& id) const
 {
   return balance(id, QDate());
 }
 
 MyMoneyMoney MyMoneyFile::clearedBalance(const QString &id, const QDate& date) const
 {
   MyMoneyMoney cleared;
   QList<MyMoneyTransaction> list;
 
   cleared = balance(id, date);
 
   MyMoneyAccount account = this->account(id);
   MyMoneyMoney factor(1, 1);
   if (account.accountGroup() == Account::Type::Liability || account.accountGroup() == Account::Type::Equity)
     factor = -factor;
 
   MyMoneyTransactionFilter filter;
   filter.addAccount(id);
   filter.setDateFilter(QDate(), date);
   filter.setReportAllSplits(false);
   filter.addState((int)TransactionFilter::State::NotReconciled);
   transactionList(list, filter);
 
   for (QList<MyMoneyTransaction>::const_iterator it_t = list.constBegin(); it_t != list.constEnd(); ++it_t) {
     const QList<MyMoneySplit>& splits = (*it_t).splits();
     for (QList<MyMoneySplit>::const_iterator it_s = splits.constBegin(); it_s != splits.constEnd(); ++it_s) {
       const MyMoneySplit &split = (*it_s);
       if (split.accountId() != id)
         continue;
       cleared -= split.shares();
     }
   }
   return cleared * factor;
 }
 
 MyMoneyMoney MyMoneyFile::totalBalance(const QString& id, const QDate& date) const
 {
   d->checkStorage();
 
   return d->m_storage->totalBalance(id, date);
 }
 
 MyMoneyMoney MyMoneyFile::totalBalance(const QString& id) const
 {
   return totalBalance(id, QDate());
 }
 
 void MyMoneyFile::warningMissingRate(const QString& fromId, const QString& toId) const
 {
   MyMoneySecurity from, to;
   try {
     from = security(fromId);
     to = security(toId);
     qWarning("Missing price info for conversion from %s to %s", qPrintable(from.name()), qPrintable(to.name()));
 
   } catch (const MyMoneyException &e) {
-    qWarning("Missing security caught in MyMoneyFile::warningMissingRate(): %s(%ld) %s", qPrintable(e.file()), e.line(), qPrintable(e.what()));
+    qWarning("Missing security caught in MyMoneyFile::warningMissingRate(). %s", e.what());
   }
 }
 
 void MyMoneyFile::transactionList(QList<QPair<MyMoneyTransaction, MyMoneySplit> >& list, MyMoneyTransactionFilter& filter) const
 {
   d->checkStorage();
   d->m_storage->transactionList(list, filter);
 }
 
 void MyMoneyFile::transactionList(QList<MyMoneyTransaction>& list, MyMoneyTransactionFilter& filter) const
 {
   d->checkStorage();
   d->m_storage->transactionList(list, filter);
 }
 
 QList<MyMoneyTransaction> MyMoneyFile::transactionList(MyMoneyTransactionFilter& filter) const
 {
   d->checkStorage();
   return d->m_storage->transactionList(filter);
 }
 
 QList<MyMoneyPayee> MyMoneyFile::payeeList() const
 {
   return d->m_storage->payeeList();
 }
 
 QList<MyMoneyTag> MyMoneyFile::tagList() const
 {
   return d->m_storage->tagList();
 }
 
 QString MyMoneyFile::accountToCategory(const QString& accountId, bool includeStandardAccounts) const
 {
   MyMoneyAccount acc;
   QString rc;
 
   if (!accountId.isEmpty()) {
     acc = account(accountId);
     do {
       if (!rc.isEmpty())
         rc = AccountSeparator + rc;
       rc = acc.name() + rc;
       acc = account(acc.parentAccountId());
     } while (!acc.id().isEmpty() && (includeStandardAccounts || !isStandardAccount(acc.id())));
   }
   return rc;
 }
 
 QString MyMoneyFile::categoryToAccount(const QString& category, Account::Type type) const
 {
   QString id;
 
   // search the category in the expense accounts and if it is not found, try
   // to locate it in the income accounts
   if (type == Account::Type::Unknown
       || type == Account::Type::Expense) {
     id = locateSubAccount(MyMoneyFile::instance()->expense(), category);
   }
 
   if ((id.isEmpty() && type == Account::Type::Unknown)
       || type == Account::Type::Income) {
     id = locateSubAccount(MyMoneyFile::instance()->income(), category);
   }
 
   return id;
 }
 
 QString MyMoneyFile::categoryToAccount(const QString& category) const
 {
   return categoryToAccount(category, Account::Type::Unknown);
 }
 
 QString MyMoneyFile::nameToAccount(const QString& name) const
 {
   QString id;
 
   // search the category in the asset accounts and if it is not found, try
   // to locate it in the liability accounts
   id = locateSubAccount(MyMoneyFile::instance()->asset(), name);
   if (id.isEmpty())
     id = locateSubAccount(MyMoneyFile::instance()->liability(), name);
 
   return id;
 }
 
 QString MyMoneyFile::parentName(const QString& name) const
 {
   return name.section(AccountSeparator, 0, -2);
 }
 
 QString MyMoneyFile::locateSubAccount(const MyMoneyAccount& base, const QString& category) const
 {
   MyMoneyAccount nextBase;
   QString level, remainder;
   level = category.section(AccountSeparator, 0, 0);
   remainder = category.section(AccountSeparator, 1);
 
   foreach (const auto sAccount, base.accountList()) {
     nextBase = account(sAccount);
     if (nextBase.name() == level) {
       if (remainder.isEmpty()) {
         return nextBase.id();
       }
       return locateSubAccount(nextBase, remainder);
     }
   }
   return QString();
 }
 
 QString MyMoneyFile::value(const QString& key) const
 {
   d->checkStorage();
 
   return d->m_storage->value(key);
 }
 
 void MyMoneyFile::setValue(const QString& key, const QString& val)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->setValue(key, val);
 }
 
 void MyMoneyFile::deletePair(const QString& key)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->deletePair(key);
 }
 
 void MyMoneyFile::addSchedule(MyMoneySchedule& sched)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   const auto splits = sched.transaction().splits();
   for (const auto& split : splits) {
     // the following line will throw an exception if the
     // account does not exist or is one of the standard accounts
     const auto acc = account(split.accountId());
     if (acc.id().isEmpty())
-      throw MYMONEYEXCEPTION("Cannot add split with no account assigned");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot add split with no account assigned");
     if (isStandardAccount(split.accountId()))
-      throw MYMONEYEXCEPTION("Cannot add split referencing standard account");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot add split referencing standard account");
   }
 
   d->m_storage->addSchedule(sched);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, sched);
 }
 
 void MyMoneyFile::modifySchedule(const MyMoneySchedule& sched)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   foreach (const auto split, sched.transaction().splits()) {
     // the following line will throw an exception if the
     // account does not exist or is one of the standard accounts
     auto acc = MyMoneyFile::account(split.accountId());
     if (acc.id().isEmpty())
-      throw MYMONEYEXCEPTION("Cannot store split with no account assigned");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot store split with no account assigned");
     if (isStandardAccount(split.accountId()))
-      throw MYMONEYEXCEPTION("Cannot store split referencing standard account");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot store split referencing standard account");
   }
 
   d->m_storage->modifySchedule(sched);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, sched);
 }
 
 void MyMoneyFile::removeSchedule(const MyMoneySchedule& sched)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->removeSchedule(sched);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, sched);
 }
 
 MyMoneySchedule MyMoneyFile::schedule(const QString& id) const
 {
   return d->m_storage->schedule(id);
 }
 
 QList<MyMoneySchedule> MyMoneyFile::scheduleList(
   const QString& accountId,
   const Schedule::Type type,
   const Schedule::Occurrence occurrence,
   const Schedule::PaymentType paymentType,
   const QDate& startDate,
   const QDate& endDate,
   const bool overdue) const
 {
   d->checkStorage();
 
   return d->m_storage->scheduleList(accountId, type, occurrence, paymentType, startDate, endDate, overdue);
 }
 
 QList<MyMoneySchedule> MyMoneyFile::scheduleList(
     const QString& accountId) const
 {
   return scheduleList(accountId, Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                       QDate(), QDate(), false);
 }
 
 QList<MyMoneySchedule> MyMoneyFile::scheduleList() const
 {
   return scheduleList(QString(), Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                       QDate(), QDate(), false);
 }
 
 QStringList MyMoneyFile::consistencyCheck()
 {
   QList<MyMoneyAccount> list;
   QList<MyMoneyAccount>::Iterator it_a;
   QList<MyMoneySchedule>::Iterator it_sch;
   QList<MyMoneyPayee>::Iterator it_p;
   QList<MyMoneyTransaction>::Iterator it_t;
   QList<MyMoneyReport>::Iterator it_r;
   QStringList accountRebuild;
 
   QMap<QString, bool> interestAccounts;
 
   MyMoneyAccount parent;
   MyMoneyAccount child;
   MyMoneyAccount toplevel;
 
   QString parentId;
   QStringList rc;
 
   int problemCount = 0;
   int unfixedCount = 0;
   QString problemAccount;
 
   // check that we have a storage object
   d->checkTransaction(Q_FUNC_INFO);
 
   // get the current list of accounts
   accountList(list);
   // add the standard accounts
   list << MyMoneyFile::instance()->asset();
   list << MyMoneyFile::instance()->liability();
   list << MyMoneyFile::instance()->income();
   list << MyMoneyFile::instance()->expense();
 
   for (it_a = list.begin(); it_a != list.end(); ++it_a) {
     // no more checks for standard accounts
     if (isStandardAccount((*it_a).id())) {
       continue;
     }
 
     switch ((*it_a).accountGroup()) {
       case Account::Type::Asset:
         toplevel = asset();
         break;
       case Account::Type::Liability:
         toplevel = liability();
         break;
       case Account::Type::Expense:
         toplevel = expense();
         break;
       case Account::Type::Income:
         toplevel = income();
         break;
       case Account::Type::Equity:
         toplevel = equity();
         break;
       default:
         qWarning("%s:%d This should never happen!", __FILE__ , __LINE__);
         break;
     }
 
     // check for loops in the hierarchy
     parentId = (*it_a).parentAccountId();
     try {
       bool dropOut = false;
       while (!isStandardAccount(parentId) && !dropOut) {
         parent = account(parentId);
         if (parent.id() == (*it_a).id()) {
           // parent loops, so we need to re-parent to toplevel account
           // find parent account in our list
           problemCount++;
           QList<MyMoneyAccount>::Iterator it_b;
           for (it_b = list.begin(); it_b != list.end(); ++it_b) {
             if ((*it_b).id() == parent.id()) {
               if (problemAccount != (*it_a).name()) {
                 problemAccount = (*it_a).name();
                 rc << i18n("* Problem with account '%1'", problemAccount);
                 rc << i18n("  * Loop detected between this account and account '%1'.", (*it_b).name());
                 rc << i18n("    Reparenting account '%2' to top level account '%1'.", toplevel.name(), (*it_a).name());
                 (*it_a).setParentAccountId(toplevel.id());
                 if (accountRebuild.contains(toplevel.id()) == 0)
                   accountRebuild << toplevel.id();
                 if (accountRebuild.contains((*it_a).id()) == 0)
                   accountRebuild << (*it_a).id();
                 dropOut = true;
                 break;
               }
             }
           }
         }
         parentId = parent.parentAccountId();
       }
 
     } catch (const MyMoneyException &) {
       // if we don't know about a parent, we catch it later
     }
 
     // check that the parent exists
     parentId = (*it_a).parentAccountId();
     try {
       parent = account(parentId);
       if ((*it_a).accountGroup() != parent.accountGroup()) {
         problemCount++;
         if (problemAccount != (*it_a).name()) {
           problemAccount = (*it_a).name();
           rc << i18n("* Problem with account '%1'", problemAccount);
         }
         // the parent belongs to a different group, so we reconnect to the
         // master group account (asset, liability, etc) to which this account
         // should belong and update it in the engine.
         rc << i18n("  * Parent account '%1' belongs to a different group.", parent.name());
         rc << i18n("    New parent account is the top level account '%1'.", toplevel.name());
         (*it_a).setParentAccountId(toplevel.id());
 
         // make sure to rebuild the sub-accounts of the top account
         // and the one we removed this account from
         if (accountRebuild.contains(toplevel.id()) == 0)
           accountRebuild << toplevel.id();
         if (accountRebuild.contains(parent.id()) == 0)
           accountRebuild << parent.id();
       } else if (!parent.accountList().contains((*it_a).id())) {
         problemCount++;
         if (problemAccount != (*it_a).name()) {
           problemAccount = (*it_a).name();
           rc << i18n("* Problem with account '%1'", problemAccount);
         }
         // parent exists, but does not have a reference to the account
         rc << i18n("  * Parent account '%1' does not contain '%2' as sub-account.", parent.name(), problemAccount);
         if (accountRebuild.contains(parent.id()) == 0)
           accountRebuild << parent.id();
       }
     } catch (const MyMoneyException &) {
       // apparently, the parent does not exist anymore. we reconnect to the
       // master group account (asset, liability, etc) to which this account
       // should belong and update it in the engine.
       problemCount++;
       if (problemAccount != (*it_a).name()) {
         problemAccount = (*it_a).name();
         rc << i18n("* Problem with account '%1'", problemAccount);
       }
       rc << i18n("  * The parent with id %1 does not exist anymore.", parentId);
       rc << i18n("    New parent account is the top level account '%1'.", toplevel.name());
       (*it_a).setParentAccountId(toplevel.id());
 
       // make sure to rebuild the sub-accounts of the top account
       if (accountRebuild.contains(toplevel.id()) == 0)
         accountRebuild << toplevel.id();
     }
 
     // now check that all the children exist and have the correct type
     foreach (const auto accountID, (*it_a).accountList()) {
       // check that the child exists
       try {
         child = account(accountID);
         if (child.parentAccountId() != (*it_a).id()) {
-          throw MYMONEYEXCEPTION("Child account has a different parent");
+          throw MYMONEYEXCEPTION_CSTRING("Child account has a different parent");
         }
       } catch (const MyMoneyException &) {
         problemCount++;
         if (problemAccount != (*it_a).name()) {
           problemAccount = (*it_a).name();
           rc << i18n("* Problem with account '%1'", problemAccount);
         }
         rc << i18n("  * Child account with id %1 does not exist anymore.", accountID);
         rc << i18n("    The child account list will be reconstructed.");
         if (accountRebuild.contains((*it_a).id()) == 0)
           accountRebuild << (*it_a).id();
       }
     }
 
     // see if it is a loan account. if so, remember the assigned interest account
     if ((*it_a).isLoan()) {
       MyMoneyAccountLoan loan(*it_a);
       if (!loan.interestAccountId().isEmpty()) {
         interestAccounts[loan.interestAccountId()] = true;
       }
       try {
         payee(loan.payee());
       } catch (const MyMoneyException &) {
         problemCount++;
         if (problemAccount != (*it_a).name()) {
           problemAccount = (*it_a).name();
           rc << i18n("* Problem with account '%1'", problemAccount);
         }
         rc << i18n("  * The payee with id %1 referenced by the loan does not exist anymore.", loan.payee());
         rc << i18n("    The payee will be removed.");
         // remove the payee - the account will be modified in the engine later
         (*it_a).deletePair("payee");
       }
     }
 
     // check if it is a category and set the date to 1900-01-01 if different
     if ((*it_a).isIncomeExpense()) {
       if (((*it_a).openingDate().isValid() == false) || ((*it_a).openingDate() != QDate(1900, 1, 1))) {
         (*it_a).setOpeningDate(QDate(1900, 1, 1));
       }
     }
 
     // check for clear text online password in the online settings
     if (!(*it_a).onlineBankingSettings().value("password").isEmpty()) {
       if (problemAccount != (*it_a).name()) {
         problemAccount = (*it_a).name();
         rc << i18n("* Problem with account '%1'", problemAccount);
       }
       rc << i18n("  * Older versions of KMyMoney stored an OFX password for this account in cleartext.");
       rc << i18n("    Please open it in the account editor (Account/Edit account) once and press OK.");
       rc << i18n("    This will store the password in the KDE wallet and remove the cleartext version.");
       ++unfixedCount;
     }
 
     // if the account was modified, we need to update it in the engine
     if (!(d->m_storage->account((*it_a).id()) == (*it_a))) {
       try {
         d->m_storage->modifyAccount(*it_a, true);
       } catch (const MyMoneyException &) {
         rc << i18n("  * Unable to update account data in engine.");
         return rc;
       }
     }
   }
 
   if (accountRebuild.count() != 0) {
     rc << i18n("* Reconstructing the child lists for");
   }
 
   // clear the affected lists
   for (it_a = list.begin(); it_a != list.end(); ++it_a) {
     if (accountRebuild.contains((*it_a).id())) {
       rc << QString("  %1").arg((*it_a).name());
       // clear the account list
       (*it_a).removeAccountIds();
     }
   }
 
   // reconstruct the lists
   for (it_a = list.begin(); it_a != list.end(); ++it_a) {
     QList<MyMoneyAccount>::Iterator it;
     parentId = (*it_a).parentAccountId();
     if (accountRebuild.contains(parentId)) {
       for (it = list.begin(); it != list.end(); ++it) {
         if ((*it).id() == parentId) {
           (*it).addAccountId((*it_a).id());
           break;
         }
       }
     }
   }
 
   // update the engine objects
   for (it_a = list.begin(); it_a != list.end(); ++it_a) {
     if (accountRebuild.contains((*it_a).id())) {
       try {
         d->m_storage->modifyAccount(*it_a, true);
       } catch (const MyMoneyException &) {
         rc << i18n("  * Unable to update account data for account %1 in engine", (*it_a).name());
       }
     }
   }
 
   // For some reason, files exist with invalid ids. This has been found in the payee id
   // so we fix them here
   QList<MyMoneyPayee> pList = payeeList();
   QMap<QString, QString>payeeConversionMap;
 
   for (it_p = pList.begin(); it_p != pList.end(); ++it_p) {
     if ((*it_p).id().length() > 7) {
       // found one of those with an invalid ids
       // create a new one and store it in the map.
       MyMoneyPayee payee = (*it_p);
       payee.clearId();
       d->m_storage->addPayee(payee);
       payeeConversionMap[(*it_p).id()] = payee.id();
       rc << i18n("  * Payee %1 recreated with fixed id", payee.name());
       ++problemCount;
     }
   }
 
   // Fix the transactions
   MyMoneyTransactionFilter filter;
   filter.setReportAllSplits(false);
   const auto tList = d->m_storage->transactionList(filter);
   // Generate the list of interest accounts
   for (const auto& transaction : tList) {
     const auto splits = transaction.splits();
     for (const auto& split : splits) {
       if (split.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest))
         interestAccounts[split.accountId()] = true;
     }
   }
   QSet<Account::Type> supportedAccountTypes;
   supportedAccountTypes << Account::Type::Checkings
   << Account::Type::Savings
   << Account::Type::Cash
   << Account::Type::CreditCard
   << Account::Type::Asset
   << Account::Type::Liability;
   QSet<QString> reportedUnsupportedAccounts;
 
   for (const auto& transaction : tList) {
     MyMoneyTransaction t = transaction;
     bool tChanged = false;
     QDate accountOpeningDate;
     QStringList accountList;
     const auto splits = t.splits();
     foreach (const auto split, splits) {
       bool sChanged = false;
       MyMoneySplit s = split;
       if (payeeConversionMap.find(split.payeeId()) != payeeConversionMap.end()) {
         s.setPayeeId(payeeConversionMap[s.payeeId()]);
         sChanged = true;
         rc << i18n("  * Payee id updated in split of transaction '%1'.", t.id());
         ++problemCount;
       }
 
       try {
         const auto acc = this->account(s.accountId());
         // compute the newest opening date of all accounts involved in the transaction
         // in case the newest opening date is newer than the transaction post date, do one
         // of the following:
         //
         // a) for category and stock accounts: update the opening date of the account
         // b) for account types where the user cannot modify the opening date through
         //    the UI issue a warning (for each account only once)
         // c) others will be caught later
         if (!acc.isIncomeExpense() && !acc.isInvest()) {
           if (acc.openingDate() > t.postDate()) {
             if (!accountOpeningDate.isValid() || acc.openingDate() > accountOpeningDate) {
               accountOpeningDate = acc.openingDate();
             }
             accountList << this->accountToCategory(acc.id());
             if (!supportedAccountTypes.contains(acc.accountType())
                 && !reportedUnsupportedAccounts.contains(acc.id())) {
               rc << i18n("  * Opening date of Account '%1' cannot be changed to support transaction '%2' post date.",
                          this->accountToCategory(acc.id()), t.id());
               reportedUnsupportedAccounts << acc.id();
               ++unfixedCount;
             }
           }
         } else {
           if (acc.openingDate() > t.postDate()) {
             rc << i18n("  * Transaction '%1' post date '%2' is older than opening date '%4' of account '%3'.",
                        t.id(), t.postDate().toString(Qt::ISODate), this->accountToCategory(acc.id()), acc.openingDate().toString(Qt::ISODate));
 
             rc << i18n("    Account opening date updated.");
             MyMoneyAccount newAcc = acc;
             newAcc.setOpeningDate(t.postDate());
             this->modifyAccount(newAcc);
             ++problemCount;
           }
         }
 
         // make sure, that shares and value have the same number if they
         // represent the same currency.
         if (t.commodity() == acc.currencyId() && s.shares().reduce() != s.value().reduce()) {
           // use the value as master if the transaction is balanced
           if (t.splitSum().isZero()) {
             s.setShares(s.value());
             rc << i18n("  * shares set to value in split of transaction '%1'.", t.id());
           } else {
             s.setValue(s.shares());
             rc << i18n("  * value set to shares in split of transaction '%1'.", t.id());
           }
           sChanged = true;
           ++problemCount;
         }
       } catch (const MyMoneyException &) {
         rc << i18n("  * Split %2 in transaction '%1' contains a reference to invalid account %3. Please fix manually.", t.id(), split.id(), split.accountId());
         ++unfixedCount;
       }
 
       // make sure the interest splits are marked correct as such
       if (interestAccounts.find(s.accountId()) != interestAccounts.end()
           && s.action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
         s.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Interest));
         sChanged = true;
         rc << i18n("  * action marked as interest in split of transaction '%1'.", t.id());
         ++problemCount;
       }
 
       if (sChanged) {
         tChanged = true;
         t.modifySplit(s);
       }
     }
 
     // make sure that the transaction's post date is valid
     if (!t.postDate().isValid()) {
       tChanged = true;
       t.setPostDate(t.entryDate().isValid() ? t.entryDate() : QDate::currentDate());
       rc << i18n("  * Transaction '%1' has an invalid post date.", t.id());
       rc << i18n("    The post date was updated to '%1'.", QLocale().toString(t.postDate(), QLocale::ShortFormat));
       ++problemCount;
     }
     // check if the transaction's post date is after the opening date
     // of all accounts involved in the transaction. In case it is not,
     // issue a warning with the details about the transaction incl.
     // the account names and dates involved
     if (accountOpeningDate.isValid() && t.postDate() < accountOpeningDate) {
       QDate originalPostDate = t.postDate();
 #if 0
       // for now we do not activate the logic to move the post date to a later
       // point in time. This could cause some severe trouble if you have lots
       // of ancient data collected with older versions of KMyMoney that did not
       // enforce certain conditions like we do now.
       t.setPostDate(accountOpeningDate);
       tChanged = true;
       // copy the price information for investments to the new date
       QList<MyMoneySplit>::const_iterator it_t;
       foreach (const auto split, t.splits()) {
         if ((split.action() != "Buy") &&
             (split.action() != "Reinvest")) {
           continue;
         }
         QString id = split.accountId();
         auto acc = this->account(id);
         MyMoneySecurity sec = this->security(acc.currencyId());
         MyMoneyPrice price(acc.currencyId(),
                            sec.tradingCurrency(),
                            t.postDate(),
                            split.price(), "Transaction");
         this->addPrice(price);
         break;
       }
 #endif
       rc << i18n("  * Transaction '%1' has a post date '%2' before one of the referenced account's opening date.", t.id(), QLocale().toString(originalPostDate, QLocale::ShortFormat));
       rc << i18n("    Referenced accounts: %1", accountList.join(","));
       rc << i18n("    The post date was not updated to '%1'.", QLocale().toString(accountOpeningDate, QLocale::ShortFormat));
       ++unfixedCount;
     }
 
     if (tChanged) {
       d->m_storage->modifyTransaction(t);
     }
   }
 
   // Fix the schedules
   QList<MyMoneySchedule> schList = scheduleList();
   for (it_sch = schList.begin(); it_sch != schList.end(); ++it_sch) {
     MyMoneySchedule sch = (*it_sch);
     MyMoneyTransaction t = sch.transaction();
     auto tChanged = false;
     foreach (const auto split, t.splits()) {
       MyMoneySplit s = split;
       bool sChanged = false;
       if (payeeConversionMap.find(split.payeeId()) != payeeConversionMap.end()) {
         s.setPayeeId(payeeConversionMap[s.payeeId()]);
         sChanged = true;
         rc << i18n("  * Payee id updated in split of schedule '%1'.", (*it_sch).name());
         ++problemCount;
       }
       if (!split.value().isZero() && split.shares().isZero()) {
         s.setShares(s.value());
         sChanged = true;
         rc << i18n("  * Split in scheduled transaction '%1' contained value != 0 and shares == 0.", (*it_sch).name());
         rc << i18n("    Shares set to value.");
         ++problemCount;
       }
 
       // make sure, we don't have a bankid stored with a split in a schedule
       if (!split.bankID().isEmpty()) {
         s.setBankID(QString());
         sChanged = true;
         rc << i18n("  * Removed bankid from split in scheduled transaction '%1'.", (*it_sch).name());
         ++problemCount;
       }
 
       // make sure, that shares and value have the same number if they
       // represent the same currency.
       try {
         const auto acc = this->account(s.accountId());
         if (t.commodity() == acc.currencyId()
             && s.shares().reduce() != s.value().reduce()) {
           // use the value as master if the transaction is balanced
           if (t.splitSum().isZero()) {
             s.setShares(s.value());
             rc << i18n("  * shares set to value in split in schedule '%1'.", (*it_sch).name());
           } else {
             s.setValue(s.shares());
             rc << i18n("  * value set to shares in split in schedule '%1'.", (*it_sch).name());
           }
           sChanged = true;
           ++problemCount;
         }
       } catch (const MyMoneyException &) {
         rc << i18n("  * Split %2 in schedule '%1' contains a reference to invalid account %3. Please fix manually.", (*it_sch).name(), split.id(), split.accountId());
         ++unfixedCount;
       }
       if (sChanged) {
         t.modifySplit(s);
         tChanged = true;
       }
     }
     if (tChanged) {
       sch.setTransaction(t);
       d->m_storage->modifySchedule(sch);
     }
   }
 
   // Fix the reports
   QList<MyMoneyReport> rList = reportList();
   for (it_r = rList.begin(); it_r != rList.end(); ++it_r) {
     MyMoneyReport r = *it_r;
     QStringList payeeList;
     (*it_r).payees(payeeList);
     bool rChanged = false;
     for (auto it_payee = payeeList.begin(); it_payee != payeeList.end(); ++it_payee) {
       if (payeeConversionMap.find(*it_payee) != payeeConversionMap.end()) {
         rc << i18n("  * Payee id updated in report '%1'.", (*it_r).name());
         ++problemCount;
         r.removeReference(*it_payee);
         r.addPayee(payeeConversionMap[*it_payee]);
         rChanged = true;
       }
     }
     if (rChanged) {
       d->m_storage->modifyReport(r);
     }
   }
 
   // erase old payee ids
   QMap<QString, QString>::Iterator it_m;
   for (it_m = payeeConversionMap.begin(); it_m != payeeConversionMap.end(); ++it_m) {
     MyMoneyPayee payee = this->payee(it_m.key());
     removePayee(payee);
     rc << i18n("  * Payee '%1' removed.", payee.id());
     ++problemCount;
   }
 
   //look for accounts which have currencies other than the base currency but no price on the opening date
   //all accounts using base currency are excluded, since that's the base used for foreing currency calculation
   //thus it is considered as always present
   //accounts that represent Income/Expense categories are also excluded as price is irrelevant for their
   //fake opening date since a forex rate is required for all multi-currency transactions
 
   //get all currencies in use
   QStringList currencyList;
   QList<MyMoneyAccount> accountForeignCurrency;
   QList<MyMoneyAccount> accList;
   accountList(accList);
   QList<MyMoneyAccount>::const_iterator account_it;
   for (account_it = accList.constBegin(); account_it != accList.constEnd(); ++account_it) {
     MyMoneyAccount account = *account_it;
     if (!account.isIncomeExpense()
         && !currencyList.contains(account.currencyId())
         && account.currencyId() != baseCurrency().id()
         && !account.currencyId().isEmpty()) {
       //add the currency and the account-currency pair
       currencyList.append(account.currencyId());
       accountForeignCurrency.append(account);
     }
   }
 
   MyMoneyPriceList pricesList = priceList();
   QMap<MyMoneySecurityPair, QDate> securityPriceDate;
 
   //get the first date of the price for each security
   MyMoneyPriceList::const_iterator prices_it;
   for (prices_it = pricesList.constBegin(); prices_it != pricesList.constEnd(); ++prices_it) {
     MyMoneyPrice firstPrice = (*((*prices_it).constBegin()));
 
     //only check the price if the currency is in use
     if (currencyList.contains(firstPrice.from()) || currencyList.contains(firstPrice.to())) {
       //check the security in the from field
       //if it is there, check if it is older
       QPair<QString, QString> pricePair = qMakePair(firstPrice.from(), firstPrice.to());
       securityPriceDate[pricePair] = firstPrice.date();
     }
   }
 
   //compare the dates with the opening dates of the accounts using each currency
   QList<MyMoneyAccount>::const_iterator accForeignList_it;
   bool firstInvProblem = true;
   for (accForeignList_it = accountForeignCurrency.constBegin(); accForeignList_it != accountForeignCurrency.constEnd(); ++accForeignList_it) {
     //setup the price pair correctly
     QPair<QString, QString> pricePair;
     //setup the reverse, which can also be used for rate conversion
     QPair<QString, QString> reversePricePair;
     if ((*accForeignList_it).isInvest()) {
       //if it is a stock, we have to search for a price from its stock to the currency of the account
       QString securityId = (*accForeignList_it).currencyId();
       QString tradingCurrencyId = security(securityId).tradingCurrency();
       pricePair = qMakePair(securityId, tradingCurrencyId);
       reversePricePair = qMakePair(tradingCurrencyId, securityId);
     } else {
       //if it is a regular account we search for a price from the currency of the account to the base currency
       QString currency = (*accForeignList_it).currencyId();
       QString baseCurrencyId = baseCurrency().id();
       pricePair = qMakePair(currency, baseCurrencyId);
       reversePricePair = qMakePair(baseCurrencyId, currency);
     }
 
     //compare the first price with the opening date of the account
     if ((!securityPriceDate.contains(pricePair) || securityPriceDate.value(pricePair) > (*accForeignList_it).openingDate())
         && (!securityPriceDate.contains(reversePricePair) || securityPriceDate.value(reversePricePair) > (*accForeignList_it).openingDate())) {
       if (firstInvProblem) {
         firstInvProblem = false;
         rc << i18n("* Potential problem with investments/currencies");
       }
       QDate openingDate = (*accForeignList_it).openingDate();
       MyMoneySecurity secError = security((*accForeignList_it).currencyId());
       if (!(*accForeignList_it).isInvest()) {
         rc << i18n("  * The account '%1' in currency '%2' has no price set for the opening date '%3'.", (*accForeignList_it).name(), secError.name(), openingDate.toString(Qt::ISODate));
         rc << i18n("    Please enter a price for the currency on or before the opening date.");
       } else {
         rc << i18n("  * The investment '%1' has no price set for the opening date '%2'.", (*accForeignList_it).name(), openingDate.toString(Qt::ISODate));
         rc << i18n("    Please enter a price for the investment on or before the opening date.");
       }
       ++unfixedCount;
     }
   }
 
   // Fix the budgets that somehow still reference invalid accounts
   QString problemBudget;
   QList<MyMoneyBudget> bList = budgetList();
   for (QList<MyMoneyBudget>::const_iterator it_b = bList.constBegin(); it_b != bList.constEnd(); ++it_b) {
     MyMoneyBudget b = *it_b;
     QList<MyMoneyBudget::AccountGroup> baccounts = b.getaccounts();
     bool bChanged = false;
     for (QList<MyMoneyBudget::AccountGroup>::const_iterator it_bacc = baccounts.constBegin(); it_bacc != baccounts.constEnd(); ++it_bacc) {
       try {
         account((*it_bacc).id());
       } catch (const MyMoneyException &) {
         problemCount++;
         if (problemBudget != b.name()) {
           problemBudget = b.name();
           rc << i18n("* Problem with budget '%1'", problemBudget);
         }
         rc << i18n("  * The account with id %1 referenced by the budget does not exist anymore.", (*it_bacc).id());
         rc << i18n("    The account reference will be removed.");
         // remove the reference to the account
         b.removeReference((*it_bacc).id());
         bChanged = true;
       }
     }
     if (bChanged) {
       d->m_storage->modifyBudget(b);
     }
   }
 
   // add more checks here
 
   if (problemCount == 0 && unfixedCount == 0) {
     rc << i18n("Finished: data is consistent.");
   } else {
     const QString problemsCorrected = i18np("%1 problem corrected.", "%1 problems corrected.", problemCount);
     const QString problemsRemaining = i18np("%1 problem still present.", "%1 problems still present.", unfixedCount);
 
     rc << QString();
     rc << i18nc("%1 is a string, e.g. 7 problems corrected; %2 is a string, e.g. 3 problems still present", "Finished: %1 %2", problemsCorrected, problemsRemaining);
   }
   return rc;
 }
 
 QString MyMoneyFile::createCategory(const MyMoneyAccount& base, const QString& name)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   MyMoneyAccount parent = base;
   QString categoryText;
 
   if (base.id() != expense().id() && base.id() != income().id())
-    throw MYMONEYEXCEPTION("Invalid base category");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid base category");
 
   QStringList subAccounts = name.split(AccountSeparator);
   QStringList::Iterator it;
   for (it = subAccounts.begin(); it != subAccounts.end(); ++it) {
     MyMoneyAccount categoryAccount;
 
     categoryAccount.setName(*it);
     categoryAccount.setAccountType(base.accountType());
 
     if (it == subAccounts.begin())
       categoryText += *it;
     else
       categoryText += (AccountSeparator + *it);
 
     // Only create the account if it doesn't exist
     try {
       QString categoryId = categoryToAccount(categoryText);
       if (categoryId.isEmpty())
         addAccount(categoryAccount, parent);
       else {
         categoryAccount = account(categoryId);
       }
     } catch (const MyMoneyException &e) {
       qDebug("Unable to add account %s, %s, %s: %s",
              qPrintable(categoryAccount.name()),
              qPrintable(parent.name()),
              qPrintable(categoryText),
-             qPrintable(e.what()));
+             e.what());
     }
 
     parent = categoryAccount;
   }
 
   return categoryToAccount(name);
 }
 
 QString MyMoneyFile::checkCategory(const QString& name, const MyMoneyMoney& value, const MyMoneyMoney& value2)
 {
   QString accountId;
   MyMoneyAccount newAccount;
   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
 
     newAccount.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 = categoryToAccount(parent);
       if (accountId.isEmpty()) {
         found = false;
         // prepare next step
         if (!accName.isEmpty())
           accName.prepend(':');
         accName.prepend(parent.section(':', -1));
         newAccount.setName(accName);
         parent = parent.section(':', 0, -2);
       } else if (!accName.isEmpty()) {
         newAccount.setParentAccountId(accountId);
       }
     } while (!parent.isEmpty() && accountId.isEmpty());
 
     // if we did not find the category, we create it
     if (!found) {
         MyMoneyAccount parentAccount;
       if (newAccount.parentAccountId().isEmpty()) {
         if (!value.isNegative() && value2.isNegative())
           parentAccount = income();
         else
           parentAccount = expense();
       } else {
         parentAccount = account(newAccount.parentAccountId());
       }
       newAccount.setAccountType((!value.isNegative() && value2.isNegative()) ? Account::Type::Income : Account::Type::Expense);
       MyMoneyAccount brokerage;
       // clear out the parent id, because createAccount() does not like that
       newAccount.setParentAccountId(QString());
       createAccount(newAccount, parentAccount, brokerage, MyMoneyMoney());
       accountId = newAccount.id();
     }
   }
 
   return accountId;
 }
 
 void MyMoneyFile::addSecurity(MyMoneySecurity& security)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addSecurity(security);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, security);
 }
 
 void MyMoneyFile::modifySecurity(const MyMoneySecurity& security)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifySecurity(security);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, security);
 }
 
 void MyMoneyFile::removeSecurity(const MyMoneySecurity& security)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // FIXME check that security is not referenced by other object
 
   d->m_storage->removeSecurity(security);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, security);
 }
 
 MyMoneySecurity MyMoneyFile::security(const QString& id) const
 {
   if (Q_UNLIKELY(id.isEmpty()))
     return baseCurrency();
 
   return d->m_storage->security(id);
 }
 
 QList<MyMoneySecurity> MyMoneyFile::securityList() const
 {
   d->checkStorage();
 
   return d->m_storage->securityList();
 }
 
 void MyMoneyFile::addCurrency(const MyMoneySecurity& currency)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addCurrency(currency);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, currency);
 }
 
 void MyMoneyFile::modifyCurrency(const MyMoneySecurity& currency)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // force reload of base currency object
   if (currency.id() == d->m_baseCurrency.id())
     d->m_baseCurrency.clearId();
 
   d->m_storage->modifyCurrency(currency);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, currency);
 }
 
 void MyMoneyFile::removeCurrency(const MyMoneySecurity& currency)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   if (currency.id() == d->m_baseCurrency.id())
-    throw MYMONEYEXCEPTION("Cannot delete base currency.");
+    throw MYMONEYEXCEPTION_CSTRING("Cannot delete base currency.");
 
   // FIXME check that security is not referenced by other object
 
   d->m_storage->removeCurrency(currency);
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, currency);
 }
 
 MyMoneySecurity MyMoneyFile::currency(const QString& id) const
 {
   if (id.isEmpty())
     return baseCurrency();
 
   try {
     const auto currency = d->m_storage->currency(id);
     if (currency.id().isEmpty())
       throw MYMONEYEXCEPTION(QString::fromLatin1("Currency '%1' not found.").arg(id));
 
     return currency;
 
-  } catch(const MyMoneyException&) {
+  } catch (const MyMoneyException &) {
     const auto security = d->m_storage->security(id);
     if (security.id().isEmpty()) {
       throw MYMONEYEXCEPTION(QString::fromLatin1("Security '%1' not found.").arg(id));
     }
     return security;
   }
 }
 
 QMap<MyMoneySecurity, MyMoneyPrice> MyMoneyFile::ancientCurrencies() const
 {
   QMap<MyMoneySecurity, MyMoneyPrice> ancientCurrencies;
 
   ancientCurrencies.insert(MyMoneySecurity("ATS", i18n("Austrian Schilling"), QString::fromUtf8("ÖS")),     MyMoneyPrice("ATS", "EUR", QDate(1998, 12, 31), MyMoneyMoney(10000, 137603), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("DEM", i18n("German Mark"), "DM"),            MyMoneyPrice("ATS", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100000, 195583), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("FRF", i18n("French Franc"), "FF"),           MyMoneyPrice("FRF", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100000, 655957), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("ITL", i18n("Italian Lira"), QChar(0x20A4)),  MyMoneyPrice("ITL", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100, 193627), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("ESP", i18n("Spanish Peseta"), QString()),    MyMoneyPrice("ESP", "EUR", QDate(1998, 12, 31), MyMoneyMoney(1000, 166386), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("NLG", i18n("Dutch Guilder"), QString()),     MyMoneyPrice("NLG", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100000, 220371), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("BEF", i18n("Belgian Franc"), "Fr"),          MyMoneyPrice("BEF", "EUR", QDate(1998, 12, 31), MyMoneyMoney(10000, 403399), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("LUF", i18n("Luxembourg Franc"), "Fr"),       MyMoneyPrice("LUF", "EUR", QDate(1998, 12, 31), MyMoneyMoney(10000, 403399), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("PTE", i18n("Portuguese Escudo"), QString()), MyMoneyPrice("PTE", "EUR", QDate(1998, 12, 31), MyMoneyMoney(1000, 200482), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("IEP", i18n("Irish Pound"), QChar(0x00A3)),   MyMoneyPrice("IEP", "EUR", QDate(1998, 12, 31), MyMoneyMoney(1000000, 787564), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("FIM", i18n("Finnish Markka"), QString()),    MyMoneyPrice("FIM", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100000, 594573), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("GRD", i18n("Greek Drachma"), QChar(0x20AF)), MyMoneyPrice("GRD", "EUR", QDate(1998, 12, 31), MyMoneyMoney(100, 34075), QLatin1Literal("KMyMoney")));
 
     // http://en.wikipedia.org/wiki/Bulgarian_lev
   ancientCurrencies.insert(MyMoneySecurity("BGL", i18n("Bulgarian Lev"), "BGL"), MyMoneyPrice("BGL", "BGN", QDate(1999, 7, 5), MyMoneyMoney(1, 1000), QLatin1Literal("KMyMoney")));
 
   ancientCurrencies.insert(MyMoneySecurity("ROL", i18n("Romanian Leu"), "ROL"), MyMoneyPrice("ROL", "RON", QDate(2005, 6, 30), MyMoneyMoney(1, 10000), QLatin1Literal("KMyMoney")));
 
   ancientCurrencies.insert(MyMoneySecurity("RUR", i18n("Russian Ruble (old)"), "RUR"), MyMoneyPrice("RUR", "RUB", QDate(1998, 1, 1), MyMoneyMoney(1, 1000), QLatin1Literal("KMyMoney")));
 
   ancientCurrencies.insert(MyMoneySecurity("SIT", i18n("Slovenian Tolar"), "SIT"), MyMoneyPrice("SIT", "EUR", QDate(2006, 12, 31), MyMoneyMoney(1, 23964), QLatin1Literal("KMyMoney")));
 
     // Source: http://www.tf-portfoliosolutions.net/products/turkishlira.aspx
   ancientCurrencies.insert(MyMoneySecurity("TRL", i18n("Turkish Lira (old)"), "TL"), MyMoneyPrice("TRL", "TRY", QDate(2004, 12, 31), MyMoneyMoney(1, 1000000), QLatin1Literal("KMyMoney")));
 
     // Source: http://www.focus.de/finanzen/news/malta-und-zypern_aid_66058.html
   ancientCurrencies.insert(MyMoneySecurity("MTL", i18n("Maltese Lira"), "MTL"), MyMoneyPrice("MTL", "EUR", QDate(2008, 1, 1), MyMoneyMoney(429300, 1000000), QLatin1Literal("KMyMoney")));
   ancientCurrencies.insert(MyMoneySecurity("CYP", i18n("Cyprus Pound"), QString("C%1").arg(QChar(0x00A3))), MyMoneyPrice("CYP", "EUR", QDate(2008, 1, 1), MyMoneyMoney(585274, 1000000), QLatin1Literal("KMyMoney")));
 
     // Source: http://www.focus.de/finanzen/news/waehrungszone-slowakei-ist-neuer-euro-staat_aid_359025.html
   ancientCurrencies.insert(MyMoneySecurity("SKK", i18n("Slovak Koruna"), "SKK"), MyMoneyPrice("SKK", "EUR", QDate(2008, 12, 31), MyMoneyMoney(1000, 30126), QLatin1Literal("KMyMoney")));
 
     // Source: http://en.wikipedia.org/wiki/Mozambican_metical
   ancientCurrencies.insert(MyMoneySecurity("MZM", i18n("Mozambique Metical"), "MT"), MyMoneyPrice("MZM", "MZN", QDate(2006, 7, 1), MyMoneyMoney(1, 1000), QLatin1Literal("KMyMoney")));
 
     // Source https://en.wikipedia.org/wiki/Azerbaijani_manat
   ancientCurrencies.insert(MyMoneySecurity("AZM", i18n("Azerbaijani Manat"), "m."), MyMoneyPrice("AZM", "AZN", QDate(2006, 1, 1), MyMoneyMoney(1, 5000), QLatin1Literal("KMyMoney")));
 
     // Source: https://en.wikipedia.org/wiki/Litas
   ancientCurrencies.insert(MyMoneySecurity("LTL", i18n("Lithuanian Litas"), "Lt"), MyMoneyPrice("LTL", "EUR", QDate(2015, 1, 1), MyMoneyMoney(100000, 345280), QLatin1Literal("KMyMoney")));
 
     // Source: https://en.wikipedia.org/wiki/Belarusian_ruble
   ancientCurrencies.insert(MyMoneySecurity("BYR", i18n("Belarusian Ruble (old)"), "BYR"), MyMoneyPrice("BYR", "BYN", QDate(2016, 7, 1), MyMoneyMoney(1, 10000), QLatin1Literal("KMyMoney")));
   return ancientCurrencies;
 }
 
 QList<MyMoneySecurity> MyMoneyFile::availableCurrencyList() const
 {
   QList<MyMoneySecurity> currencyList;
   currencyList.append(MyMoneySecurity("AFA", i18n("Afghanistan Afghani")));
   currencyList.append(MyMoneySecurity("ALL", i18n("Albanian Lek")));
   currencyList.append(MyMoneySecurity("ANG", i18n("Netherland Antillian Guilder")));
   currencyList.append(MyMoneySecurity("DZD", i18n("Algerian Dinar")));
   currencyList.append(MyMoneySecurity("ADF", i18n("Andorran Franc")));
   currencyList.append(MyMoneySecurity("ADP", i18n("Andorran Peseta")));
   currencyList.append(MyMoneySecurity("AON", i18n("Angolan New Kwanza")));
   currencyList.append(MyMoneySecurity("ARS", i18n("Argentine Peso"),         "$"));
   currencyList.append(MyMoneySecurity("AWG", i18n("Aruban Florin")));
   currencyList.append(MyMoneySecurity("AUD", i18n("Australian Dollar"),      "$"));
   currencyList.append(MyMoneySecurity("AZN", i18n("Azerbaijani Manat"),      "m."));
   currencyList.append(MyMoneySecurity("BSD", i18n("Bahamian Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("BHD", i18n("Bahraini Dinar"),         "BHD", 1000));
   currencyList.append(MyMoneySecurity("BDT", i18n("Bangladeshi Taka")));
   currencyList.append(MyMoneySecurity("BBD", i18n("Barbados Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("BTC", i18n("Bitcoin"),                "BTC"));
   currencyList.append(MyMoneySecurity("BYN", i18n("Belarusian Ruble"),       "Br"));
   currencyList.append(MyMoneySecurity("BZD", i18n("Belize Dollar"),          "$"));
   currencyList.append(MyMoneySecurity("BMD", i18n("Bermudian Dollar"),       "$"));
   currencyList.append(MyMoneySecurity("BTN", i18n("Bhutan Ngultrum")));
   currencyList.append(MyMoneySecurity("BOB", i18n("Bolivian Boliviano")));
   currencyList.append(MyMoneySecurity("BAM", i18n("Bosnian Convertible Mark")));
   currencyList.append(MyMoneySecurity("BWP", i18n("Botswana Pula")));
   currencyList.append(MyMoneySecurity("BRL", i18n("Brazilian Real"),         "R$"));
   currencyList.append(MyMoneySecurity("GBP", i18n("British Pound"),          QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("BND", i18n("Brunei Dollar"),          "$"));
   currencyList.append(MyMoneySecurity("BGN", i18n("Bulgarian Lev (new)")));
   currencyList.append(MyMoneySecurity("BIF", i18n("Burundi Franc")));
   currencyList.append(MyMoneySecurity("XAF", i18n("CFA Franc BEAC")));
   currencyList.append(MyMoneySecurity("XOF", i18n("CFA Franc BCEAO")));
   currencyList.append(MyMoneySecurity("XPF", i18n("CFP Franc Pacifique"), "F", 1, 100));
   currencyList.append(MyMoneySecurity("KHR", i18n("Cambodia Riel")));
   currencyList.append(MyMoneySecurity("CAD", i18n("Canadian Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("CVE", i18n("Cape Verde Escudo")));
   currencyList.append(MyMoneySecurity("KYD", i18n("Cayman Islands Dollar"),  "$"));
   currencyList.append(MyMoneySecurity("CLP", i18n("Chilean Peso")));
   currencyList.append(MyMoneySecurity("CNY", i18n("Chinese Yuan Renminbi")));
   currencyList.append(MyMoneySecurity("COP", i18n("Colombian Peso")));
   currencyList.append(MyMoneySecurity("KMF", i18n("Comoros Franc")));
   currencyList.append(MyMoneySecurity("CRC", i18n("Costa Rican Colon"),      QChar(0x20A1)));
   currencyList.append(MyMoneySecurity("HRK", i18n("Croatian Kuna")));
   currencyList.append(MyMoneySecurity("CUP", i18n("Cuban Peso")));
   currencyList.append(MyMoneySecurity("CZK", i18n("Czech Koruna")));
   currencyList.append(MyMoneySecurity("DKK", i18n("Danish Krone"),           "kr"));
   currencyList.append(MyMoneySecurity("DJF", i18n("Djibouti Franc")));
   currencyList.append(MyMoneySecurity("DOP", i18n("Dominican Peso")));
   currencyList.append(MyMoneySecurity("XCD", i18n("East Caribbean Dollar"),  "$"));
   currencyList.append(MyMoneySecurity("EGP", i18n("Egyptian Pound"),         QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("SVC", i18n("El Salvador Colon")));
   currencyList.append(MyMoneySecurity("ERN", i18n("Eritrean Nakfa")));
   currencyList.append(MyMoneySecurity("EEK", i18n("Estonian Kroon")));
   currencyList.append(MyMoneySecurity("ETB", i18n("Ethiopian Birr")));
   currencyList.append(MyMoneySecurity("EUR", i18n("Euro"),                   QChar(0x20ac)));
   currencyList.append(MyMoneySecurity("FKP", i18n("Falkland Islands Pound"), QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("FJD", i18n("Fiji Dollar"),            "$"));
   currencyList.append(MyMoneySecurity("GMD", i18n("Gambian Dalasi")));
   currencyList.append(MyMoneySecurity("GEL", i18n("Georgian Lari")));
   currencyList.append(MyMoneySecurity("GHC", i18n("Ghanaian Cedi")));
   currencyList.append(MyMoneySecurity("GIP", i18n("Gibraltar Pound"),        QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("GTQ", i18n("Guatemalan Quetzal")));
   currencyList.append(MyMoneySecurity("GWP", i18n("Guinea-Bissau Peso")));
   currencyList.append(MyMoneySecurity("GYD", i18n("Guyanan Dollar"),         "$"));
   currencyList.append(MyMoneySecurity("HTG", i18n("Haitian Gourde")));
   currencyList.append(MyMoneySecurity("HNL", i18n("Honduran Lempira")));
   currencyList.append(MyMoneySecurity("HKD", i18n("Hong Kong Dollar"),       "$"));
   currencyList.append(MyMoneySecurity("HUF", i18n("Hungarian Forint"),       "HUF", 1, 100));
   currencyList.append(MyMoneySecurity("ISK", i18n("Iceland Krona")));
   currencyList.append(MyMoneySecurity("INR", i18n("Indian Rupee"),           QChar(0x20A8)));
   currencyList.append(MyMoneySecurity("IDR", i18n("Indonesian Rupiah"),      "IDR", 1));
   currencyList.append(MyMoneySecurity("IRR", i18n("Iranian Rial"),           "IRR", 1));
   currencyList.append(MyMoneySecurity("IQD", i18n("Iraqi Dinar"),            "IQD", 1000));
   currencyList.append(MyMoneySecurity("ILS", i18n("Israeli New Shekel"),     QChar(0x20AA)));
   currencyList.append(MyMoneySecurity("JMD", i18n("Jamaican Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("JPY", i18n("Japanese Yen"),           QChar(0x00A5), 1));
   currencyList.append(MyMoneySecurity("JOD", i18n("Jordanian Dinar"),        "JOD", 1000));
   currencyList.append(MyMoneySecurity("KZT", i18n("Kazakhstan Tenge")));
   currencyList.append(MyMoneySecurity("KES", i18n("Kenyan Shilling")));
   currencyList.append(MyMoneySecurity("KWD", i18n("Kuwaiti Dinar"),          "KWD", 1000));
   currencyList.append(MyMoneySecurity("KGS", i18n("Kyrgyzstan Som")));
   currencyList.append(MyMoneySecurity("LAK", i18n("Laos Kip"),               QChar(0x20AD)));
   currencyList.append(MyMoneySecurity("LVL", i18n("Latvian Lats")));
   currencyList.append(MyMoneySecurity("LBP", i18n("Lebanese Pound"),         QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("LSL", i18n("Lesotho Loti")));
   currencyList.append(MyMoneySecurity("LRD", i18n("Liberian Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("LYD", i18n("Libyan Dinar"),           "LYD", 1000));
   currencyList.append(MyMoneySecurity("MOP", i18n("Macau Pataca")));
   currencyList.append(MyMoneySecurity("MKD", i18n("Macedonian Denar")));
   currencyList.append(MyMoneySecurity("MGF", i18n("Malagasy Franc"),         "MGF", 500));
   currencyList.append(MyMoneySecurity("MWK", i18n("Malawi Kwacha")));
   currencyList.append(MyMoneySecurity("MYR", i18n("Malaysian Ringgit")));
   currencyList.append(MyMoneySecurity("MVR", i18n("Maldive Rufiyaa")));
   currencyList.append(MyMoneySecurity("MLF", i18n("Mali Republic Franc")));
   currencyList.append(MyMoneySecurity("MRO", i18n("Mauritanian Ouguiya"),    "MRO", 5));
   currencyList.append(MyMoneySecurity("MUR", i18n("Mauritius Rupee")));
   currencyList.append(MyMoneySecurity("MXN", i18n("Mexican Peso"),           "$"));
   currencyList.append(MyMoneySecurity("MDL", i18n("Moldavian Leu")));
   currencyList.append(MyMoneySecurity("MNT", i18n("Mongolian Tugrik"),       QChar(0x20AE)));
   currencyList.append(MyMoneySecurity("MAD", i18n("Moroccan Dirham")));
   currencyList.append(MyMoneySecurity("MZN", i18n("Mozambique Metical"),     "MT"));
   currencyList.append(MyMoneySecurity("MMK", i18n("Myanmar Kyat")));
   currencyList.append(MyMoneySecurity("NAD", i18n("Namibian Dollar"),        "$"));
   currencyList.append(MyMoneySecurity("NPR", i18n("Nepalese Rupee")));
   currencyList.append(MyMoneySecurity("NZD", i18n("New Zealand Dollar"),     "$"));
   currencyList.append(MyMoneySecurity("NIC", i18n("Nicaraguan Cordoba Oro")));
   currencyList.append(MyMoneySecurity("NGN", i18n("Nigerian Naira"),         QChar(0x20A6)));
   currencyList.append(MyMoneySecurity("KPW", i18n("North Korean Won"),       QChar(0x20A9)));
   currencyList.append(MyMoneySecurity("NOK", i18n("Norwegian Kroner"),       "kr"));
   currencyList.append(MyMoneySecurity("OMR", i18n("Omani Rial"),             "OMR", 1000));
   currencyList.append(MyMoneySecurity("PKR", i18n("Pakistan Rupee")));
   currencyList.append(MyMoneySecurity("PAB", i18n("Panamanian Balboa")));
   currencyList.append(MyMoneySecurity("PGK", i18n("Papua New Guinea Kina")));
   currencyList.append(MyMoneySecurity("PYG", i18n("Paraguay Guarani")));
   currencyList.append(MyMoneySecurity("PEN", i18n("Peruvian Nuevo Sol")));
   currencyList.append(MyMoneySecurity("PHP", i18n("Philippine Peso"),        QChar(0x20B1)));
   currencyList.append(MyMoneySecurity("PLN", i18n("Polish Zloty")));
   currencyList.append(MyMoneySecurity("QAR", i18n("Qatari Rial")));
   currencyList.append(MyMoneySecurity("RON", i18n("Romanian Leu (new)")));
   currencyList.append(MyMoneySecurity("RUB", i18n("Russian Ruble")));
   currencyList.append(MyMoneySecurity("RWF", i18n("Rwanda Franc")));
   currencyList.append(MyMoneySecurity("WST", i18n("Samoan Tala")));
   currencyList.append(MyMoneySecurity("STD", i18n("Sao Tome and Principe Dobra")));
   currencyList.append(MyMoneySecurity("SAR", i18n("Saudi Riyal")));
   currencyList.append(MyMoneySecurity("RSD", i18n("Serbian Dinar")));
   currencyList.append(MyMoneySecurity("SCR", i18n("Seychelles Rupee")));
   currencyList.append(MyMoneySecurity("SLL", i18n("Sierra Leone Leone")));
   currencyList.append(MyMoneySecurity("SGD", i18n("Singapore Dollar"),       "$"));
   currencyList.append(MyMoneySecurity("SBD", i18n("Solomon Islands Dollar"), "$"));
   currencyList.append(MyMoneySecurity("SOS", i18n("Somali Shilling")));
   currencyList.append(MyMoneySecurity("ZAR", i18n("South African Rand")));
   currencyList.append(MyMoneySecurity("KRW", i18n("South Korean Won"),       QChar(0x20A9)));
   currencyList.append(MyMoneySecurity("LKR", i18n("Sri Lanka Rupee")));
   currencyList.append(MyMoneySecurity("SHP", i18n("St. Helena Pound"),       QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("SDD", i18n("Sudanese Dinar")));
   currencyList.append(MyMoneySecurity("SRG", i18n("Suriname Guilder")));
   currencyList.append(MyMoneySecurity("SZL", i18n("Swaziland Lilangeni")));
   currencyList.append(MyMoneySecurity("SEK", i18n("Swedish Krona")));
   currencyList.append(MyMoneySecurity("CHF", i18n("Swiss Franc"),            "SFr"));
   currencyList.append(MyMoneySecurity("SYP", i18n("Syrian Pound"),           QChar(0x00A3)));
   currencyList.append(MyMoneySecurity("TWD", i18n("Taiwan Dollar"),          "$"));
   currencyList.append(MyMoneySecurity("TJS", i18n("Tajikistan Somoni")));
   currencyList.append(MyMoneySecurity("TZS", i18n("Tanzanian Shilling")));
   currencyList.append(MyMoneySecurity("THB", i18n("Thai Baht"),              QChar(0x0E3F)));
   currencyList.append(MyMoneySecurity("TOP", i18n("Tongan Pa'anga")));
   currencyList.append(MyMoneySecurity("TTD", i18n("Trinidad and Tobago Dollar"), "$"));
   currencyList.append(MyMoneySecurity("TND", i18n("Tunisian Dinar"),         "TND", 1000));
   currencyList.append(MyMoneySecurity("TRY", i18n("Turkish Lira"), QChar(0x20BA)));
   currencyList.append(MyMoneySecurity("TMM", i18n("Turkmenistan Manat")));
   currencyList.append(MyMoneySecurity("USD", i18n("US Dollar"),              "$"));
   currencyList.append(MyMoneySecurity("UGX", i18n("Uganda Shilling")));
   currencyList.append(MyMoneySecurity("UAH", i18n("Ukraine Hryvnia")));
   currencyList.append(MyMoneySecurity("CLF", i18n("Unidad de Fometo")));
   currencyList.append(MyMoneySecurity("AED", i18n("United Arab Emirates Dirham")));
   currencyList.append(MyMoneySecurity("UYU", i18n("Uruguayan Peso")));
   currencyList.append(MyMoneySecurity("UZS", i18n("Uzbekistani Sum")));
   currencyList.append(MyMoneySecurity("VUV", i18n("Vanuatu Vatu")));
   currencyList.append(MyMoneySecurity("VEB", i18n("Venezuelan Bolivar")));
   currencyList.append(MyMoneySecurity("VND", i18n("Vietnamese Dong"),        QChar(0x20AB)));
   currencyList.append(MyMoneySecurity("ZMK", i18n("Zambian Kwacha")));
   currencyList.append(MyMoneySecurity("ZWD", i18n("Zimbabwe Dollar"),        "$"));
 
   currencyList.append(ancientCurrencies().keys());
 
   // sort the currencies ...
   qSort(currencyList.begin(), currencyList.end(),
         [] (const MyMoneySecurity& c1, const MyMoneySecurity& c2)
         {
           return c1.name().compare(c2.name()) < 0;
         });
 
   // ... and add a few precious metals at the ned
   currencyList.append(MyMoneySecurity("XAU", i18n("Gold"),       "XAU", 1000000));
   currencyList.append(MyMoneySecurity("XPD", i18n("Palladium"),  "XPD", 1000000));
   currencyList.append(MyMoneySecurity("XPT", i18n("Platinum"),   "XPT", 1000000));
   currencyList.append(MyMoneySecurity("XAG", i18n("Silver"),     "XAG", 1000000));
 
   return currencyList;
 }
 
 QList<MyMoneySecurity> MyMoneyFile::currencyList() const
 {
   d->checkStorage();
 
   return d->m_storage->currencyList();
 }
 
 QString MyMoneyFile::foreignCurrency(const QString& first, const QString& second) const
 {
   if (baseCurrency().id() == second)
     return first;
   return second;
 }
 
 MyMoneySecurity MyMoneyFile::baseCurrency() const
 {
   if (d->m_baseCurrency.id().isEmpty()) {
     QString id = QString(value("kmm-baseCurrency"));
     if (!id.isEmpty())
       d->m_baseCurrency = currency(id);
   }
 
   return d->m_baseCurrency;
 }
 
 void MyMoneyFile::setBaseCurrency(const MyMoneySecurity& curr)
 {
   // make sure the currency exists
   MyMoneySecurity c = currency(curr.id());
 
   if (c.id() != d->m_baseCurrency.id()) {
     setValue("kmm-baseCurrency", curr.id());
     // force reload of base currency cache
     d->m_baseCurrency = MyMoneySecurity();
   }
 }
 
 void MyMoneyFile::addPrice(const MyMoneyPrice& price)
 {
   if (price.rate(QString()).isZero())
     return;
 
   d->checkTransaction(Q_FUNC_INFO);
 
   // store the account's which are affected by this price regarding their value
   d->priceChanged(*this, price);
   d->m_storage->addPrice(price);
 }
 
 void MyMoneyFile::removePrice(const MyMoneyPrice& price)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // store the account's which are affected by this price regarding their value
   d->priceChanged(*this, price);
   d->m_storage->removePrice(price);
 }
 
 MyMoneyPrice MyMoneyFile::price(const QString& fromId, const QString& toId, const QDate& date, const bool exactDate) const
 {
   d->checkStorage();
 
   QString to(toId);
   if (to.isEmpty())
     to = value("kmm-baseCurrency");
   // if some id is missing, we can return an empty price object
   if (fromId.isEmpty() || to.isEmpty())
     return MyMoneyPrice();
 
   // we don't search our tables if someone asks stupid stuff
   if (fromId == toId) {
     return MyMoneyPrice(fromId, toId, date, MyMoneyMoney::ONE, "KMyMoney");
   }
 
   // if not asking for exact date, try to find the exact date match first,
   // either the requested price or its reciprocal value. If unsuccessful, it will move
   // on and look for prices of previous dates
   MyMoneyPrice rc = d->m_storage->price(fromId, to, date, true);
   if (!rc.isValid()) {
     // not found, search 'to-from' rate and use reciprocal value
     rc = d->m_storage->price(to, fromId, date, true);
 
     // not found, search previous dates, if exact date is not needed
     if (!exactDate && !rc.isValid()) {
       // search 'from-to' and 'to-from', select the most recent one
       MyMoneyPrice fromPrice = d->m_storage->price(fromId, to, date, exactDate);
       MyMoneyPrice toPrice = d->m_storage->price(to, fromId, date, exactDate);
 
       // check first whether both prices are valid
       if (fromPrice.isValid() && toPrice.isValid()) {
         if (fromPrice.date() >= toPrice.date()) {
           // if 'from-to' is newer or the same date, prefer that one
           rc = fromPrice;
         } else {
           // otherwise, use the reciprocal price
           rc = toPrice;
         }
       } else if (fromPrice.isValid()) { // check if any of the prices is valid, return that one
         rc = fromPrice;
       } else if (toPrice.isValid()) {
         rc = toPrice;
       }
     }
   }
   return rc;
 }
 
 MyMoneyPrice MyMoneyFile::price(const QString& fromId, const QString& toId) const
 {
   return price(fromId, toId, QDate::currentDate(), false);
 }
 
 MyMoneyPrice MyMoneyFile::price(const QString& fromId) const
 {
   return price(fromId, QString(), QDate::currentDate(), false);
 }
 
 MyMoneyPriceList MyMoneyFile::priceList() const
 {
   d->checkStorage();
 
   return d->m_storage->priceList();
 }
 
 bool MyMoneyFile::hasAccount(const QString& id, const QString& name) const
 {
   const auto accounts = account(id).accountList();
   for (const auto& acc : accounts) {
     if (account(acc).name().compare(name) == 0)
       return true;
   }
   return false;
 }
 
 QList<MyMoneyReport> MyMoneyFile::reportList() const
 {
   d->checkStorage();
 
   return d->m_storage->reportList();
 }
 
 void MyMoneyFile::addReport(MyMoneyReport& report)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addReport(report);
 }
 
 void MyMoneyFile::modifyReport(const MyMoneyReport& report)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifyReport(report);
 }
 
 unsigned MyMoneyFile::countReports() const
 {
   d->checkStorage();
 
   return d->m_storage->countReports();
 }
 
 MyMoneyReport MyMoneyFile::report(const QString& id) const
 {
   d->checkStorage();
 
   return d->m_storage->report(id);
 }
 
 void MyMoneyFile::removeReport(const MyMoneyReport& report)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->removeReport(report);
 }
 
 
 QList<MyMoneyBudget> MyMoneyFile::budgetList() const
 {
   d->checkStorage();
 
   return d->m_storage->budgetList();
 }
 
 void MyMoneyFile::addBudget(MyMoneyBudget &budget)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addBudget(budget);
 }
 
 MyMoneyBudget MyMoneyFile::budgetByName(const QString& name) const
 {
   d->checkStorage();
 
   return d->m_storage->budgetByName(name);
 }
 
 void MyMoneyFile::modifyBudget(const MyMoneyBudget& budget)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->modifyBudget(budget);
 }
 
 unsigned MyMoneyFile::countBudgets() const
 {
   d->checkStorage();
 
   return d->m_storage->countBudgets();
 }
 
 MyMoneyBudget MyMoneyFile::budget(const QString& id) const
 {
   d->checkStorage();
 
   return d->m_storage->budget(id);
 }
 
 void MyMoneyFile::removeBudget(const MyMoneyBudget& budget)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->removeBudget(budget);
 }
 
 void MyMoneyFile::addOnlineJob(onlineJob& job)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   d->m_storage->addOnlineJob(job);
   d->m_changeSet += MyMoneyNotification(File::Mode::Add, job);
 }
 
 void MyMoneyFile::modifyOnlineJob(const onlineJob job)
 {
   d->checkTransaction(Q_FUNC_INFO);
   d->m_storage->modifyOnlineJob(job);
   d->m_changeSet += MyMoneyNotification(File::Mode::Modify, job);
 }
 
 onlineJob MyMoneyFile::getOnlineJob(const QString &jobId) const
 {
   d->checkStorage();
   return d->m_storage->getOnlineJob(jobId);
 }
 
 QList<onlineJob> MyMoneyFile::onlineJobList() const
 {
   d->checkStorage();
   return d->m_storage->onlineJobList();
 }
 
 /** @todo improve speed by passing count job to m_storage */
 int MyMoneyFile::countOnlineJobs() const
 {
   return onlineJobList().count();
 }
 
 /**
  * @brief Remove onlineJob
  * @param job onlineJob to remove
  */
 void MyMoneyFile::removeOnlineJob(const onlineJob& job)
 {
   d->checkTransaction(Q_FUNC_INFO);
 
   // clear all changed objects from cache
   if (job.isLocked()) {
     return;
   }
   d->m_changeSet += MyMoneyNotification(File::Mode::Remove, job);
   d->m_storage->removeOnlineJob(job);
 }
 
 void MyMoneyFile::removeOnlineJob(const QStringList onlineJobIds)
 {
   foreach (QString jobId, onlineJobIds) {
     removeOnlineJob(getOnlineJob(jobId));
   }
 }
 
 void MyMoneyFile::costCenterList(QList< MyMoneyCostCenter >& list) const
 {
   d->checkStorage();
   list = d->m_storage->costCenterList();
 }
 
 bool MyMoneyFile::addVATSplit(MyMoneyTransaction& transaction, const MyMoneyAccount& account, const MyMoneyAccount& category, const MyMoneyMoney& amount)
 {
   bool rc = false;
 
   try {
     MyMoneySplit cat;  // category
     MyMoneySplit tax;  // tax
 
     if (category.value("VatAccount").isEmpty())
       return false;
     MyMoneyAccount vatAcc = this->account(category.value("VatAccount").toLatin1());
     const MyMoneySecurity& asec = security(account.currencyId());
     const MyMoneySecurity& csec = security(category.currencyId());
     const MyMoneySecurity& vsec = security(vatAcc.currencyId());
     if (asec.id() != csec.id() || asec.id() != vsec.id()) {
       qDebug("Auto VAT assignment only works if all three accounts use the same currency.");
       return false;
     }
 
     MyMoneyMoney vatRate(vatAcc.value("VatRate"));
     MyMoneyMoney gv, nv;    // gross value, net value
     int fract = account.fraction();
 
     if (!vatRate.isZero()) {
 
       tax.setAccountId(vatAcc.id());
 
       // qDebug("vat amount is '%s'", category.value("VatAmount").toLatin1());
       if (category.value("VatAmount").toLower() != QString("net")) {
         // split value is the gross value
         gv = amount;
         nv = (gv / (MyMoneyMoney::ONE + vatRate)).convert(fract);
         MyMoneySplit catSplit = transaction.splitByAccount(account.id(), false);
         catSplit.setShares(-nv);
         catSplit.setValue(catSplit.shares());
         transaction.modifySplit(catSplit);
 
       } else {
         // split value is the net value
         nv = amount;
         gv = (nv * (MyMoneyMoney::ONE + vatRate)).convert(fract);
         MyMoneySplit accSplit = transaction.splitByAccount(account.id());
         accSplit.setValue(gv.convert(fract));
         accSplit.setShares(accSplit.value());
         transaction.modifySplit(accSplit);
       }
 
       tax.setValue(-(gv - nv).convert(fract));
       tax.setShares(tax.value());
       transaction.addSplit(tax);
       rc = true;
     }
   } catch (const MyMoneyException &) {
   }
   return rc;
 }
 
 bool MyMoneyFile::isReferenced(const MyMoneyObject& obj, const QBitArray& skipChecks) const
 {
   d->checkStorage();
   return d->m_storage->isReferenced(obj, skipChecks);
 }
 
 bool MyMoneyFile::isReferenced(const MyMoneyObject& obj) const
 {
   return isReferenced(obj, QBitArray((int)eStorage::Reference::Count));
 }
 
 bool MyMoneyFile::checkNoUsed(const QString& accId, const QString& no) const
 {
   // by definition, an empty string or a non-numeric string is not used
   QRegExp exp(QString("(.*\\D)?(\\d+)(\\D.*)?"));
   if (no.isEmpty() || exp.indexIn(no) == -1)
     return false;
 
   MyMoneyTransactionFilter filter;
   filter.addAccount(accId);
   QList<MyMoneyTransaction> transactions = transactionList(filter);
   QList<MyMoneyTransaction>::ConstIterator it_t = transactions.constBegin();
   while (it_t != transactions.constEnd()) {
     try {
       MyMoneySplit split;
       // Test whether the transaction also includes a split into
       // this account
       split = (*it_t).splitByAccount(accId, true /*match*/);
       if (!split.number().isEmpty() && split.number() == no)
         return true;
     } catch (const MyMoneyException &) {
     }
     ++it_t;
   }
   return false;
 }
 
 QString MyMoneyFile::highestCheckNo(const QString& accId) const
 {
   unsigned64 lno = 0;
   unsigned64 cno;
   QString no;
   MyMoneyTransactionFilter filter;
   filter.addAccount(accId);
   QList<MyMoneyTransaction> transactions = transactionList(filter);
   QList<MyMoneyTransaction>::ConstIterator it_t = transactions.constBegin();
   while (it_t != transactions.constEnd()) {
     try {
       // Test whether the transaction also includes a split into
       // this account
       MyMoneySplit split = (*it_t).splitByAccount(accId, true /*match*/);
       if (!split.number().isEmpty()) {
         // non-numerical values stored in number will return 0 in the next line
         cno = split.number().toULongLong();
         if (cno > lno) {
           lno = cno;
           no = split.number();
         }
       }
     } catch (const MyMoneyException &) {
     }
     ++it_t;
   }
   return no;
 }
 
 bool MyMoneyFile::hasNewerTransaction(const QString& accId, const QDate& date) const
 {
   MyMoneyTransactionFilter filter;
   filter.addAccount(accId);
   filter.setDateFilter(date.addDays(+1), QDate());
   return !transactionList(filter).isEmpty();
 }
 
 void MyMoneyFile::clearCache()
 {
   d->checkStorage();
   d->m_balanceCache.clear();
 }
 
 void MyMoneyFile::forceDataChanged()
 {
   emit dataChanged();
 }
 
 bool MyMoneyFile::isTransfer(const MyMoneyTransaction& t) const
 {
   auto rc = false;
   if (t.splitCount() == 2) {
     foreach (const auto split, t.splits()) {
       auto acc = account(split.accountId());
       if (acc.isIncomeExpense()) {
         rc = true;
         break;
       }
     }
   }
   return rc;
 }
 
 bool MyMoneyFile::referencesClosedAccount(const MyMoneyTransaction& t) const
 {
   auto ret = false;
   foreach (const auto split, t.splits()) {
     if (referencesClosedAccount(split)) {
       ret = true;
       break;
     }
   }
   return ret;
 }
 
 bool MyMoneyFile::referencesClosedAccount(const MyMoneySplit& s) const
 {
   if (s.accountId().isEmpty())
     return false;
 
   try {
     return account(s.accountId()).isClosed();
   } catch (const MyMoneyException &) {
   }
   return false;
 }
 
 QString MyMoneyFile::storageId()
 {
   QString id = value("kmm-id");
   if (id.isEmpty()) {
     MyMoneyFileTransaction ft;
     try {
       QUuid uid = QUuid::createUuid();
       setValue("kmm-id", uid.toString());
       ft.commit();
       id = uid.toString();
     } catch (const MyMoneyException &) {
       qDebug("Unable to setup UID for new storage object");
     }
   }
   return id;
 }
 
 QString MyMoneyFile::openingBalancesPrefix()
 {
     return i18n("Opening Balances");
 }
 
 bool MyMoneyFile::hasMatchingOnlineBalance(const MyMoneyAccount& _acc) const
 {
   // get current values
   auto acc = account(_acc.id());
 
   // if there's no last transaction import data we are done
   if (acc.value("lastImportedTransactionDate").isEmpty()
       || acc.value("lastStatementBalance").isEmpty())
     return false;
 
   // otherwise, we compare the balances
   MyMoneyMoney balance(acc.value("lastStatementBalance"));
   MyMoneyMoney accBalance = this->balance(acc.id(), QDate::fromString(acc.value("lastImportedTransactionDate"), Qt::ISODate));
 
   return balance == accBalance;
 }
 
 int MyMoneyFile::countTransactionsWithSpecificReconciliationState(const QString& accId, TransactionFilter::State state) const
 {
   MyMoneyTransactionFilter filter;
   filter.addAccount(accId);
   filter.addState((int)state);
   return transactionList(filter).count();
 }
 
   /**
    * Make sure that the splits value has the precision of the corresponding account
    */
 void MyMoneyFile::fixSplitPrecision(MyMoneyTransaction& t) const
 {
   auto transactionSecurity = security(t.commodity());
   auto transactionFraction = transactionSecurity.smallestAccountFraction();
 
   for (auto& split : t.splits()) {
     auto acc = account(split.accountId());
     auto fraction = acc.fraction();
     if(fraction == -1) {
       auto sec = security(acc.currencyId());
       fraction = acc.fraction(sec);
     }
     split.setShares(static_cast<const MyMoneyMoney>(split.shares().convertDenominator(fraction).canonicalize()));
     split.setValue(static_cast<const MyMoneyMoney>(split.value().convertDenominator(transactionFraction).canonicalize()));
   }
 }
 
 class MyMoneyFileTransactionPrivate
 {
   Q_DISABLE_COPY(MyMoneyFileTransactionPrivate)
 
 public:
   MyMoneyFileTransactionPrivate() :
     m_isNested(MyMoneyFile::instance()->hasTransaction()),
     m_needRollback(!m_isNested)
   {
   }
 
 public:
   bool m_isNested;
   bool m_needRollback;
 
 };
 
 
 MyMoneyFileTransaction::MyMoneyFileTransaction() :
   d_ptr(new MyMoneyFileTransactionPrivate)
 {
   Q_D(MyMoneyFileTransaction);
   if (!d->m_isNested)
     MyMoneyFile::instance()->startTransaction();
 }
 
 MyMoneyFileTransaction::~MyMoneyFileTransaction()
 {
   try {
     rollback();
-  } catch (const MyMoneyException & e) {
+  } catch (const MyMoneyException &e) {
     qDebug() << e.what();
   }
   Q_D(MyMoneyFileTransaction);
   delete d;
 }
 
 void MyMoneyFileTransaction::restart()
 {
   rollback();
 
   Q_D(MyMoneyFileTransaction);
   d->m_needRollback = !d->m_isNested;
   if (!d->m_isNested)
     MyMoneyFile::instance()->startTransaction();
 }
 
 void MyMoneyFileTransaction::commit()
 {
   Q_D(MyMoneyFileTransaction);
   if (!d->m_isNested)
     MyMoneyFile::instance()->commitTransaction();
   d->m_needRollback = false;
 }
 
 void MyMoneyFileTransaction::rollback()
 {
   Q_D(MyMoneyFileTransaction);
   if (d->m_needRollback)
     MyMoneyFile::instance()->rollbackTransaction();
   d->m_needRollback = false;
 }
diff --git a/kmymoney/mymoney/mymoneyfinancialcalculator.cpp b/kmymoney/mymoney/mymoneyfinancialcalculator.cpp
index 878e92643..da8f8006c 100644
--- a/kmymoney/mymoney/mymoneyfinancialcalculator.cpp
+++ b/kmymoney/mymoney/mymoneyfinancialcalculator.cpp
@@ -1,317 +1,317 @@
 /***************************************************************************
                           mymoneyfinancialcalculator.cpp  -  description
                              -------------------
     begin                : Tue Oct 21 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyfinancialcalculator.h"
 #include "mymoneyfinancialcalculator_p.h"
 
 #include <qglobal.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 
 static inline double dabs(const double x)
 {
   return (x >= 0.0) ? x : -x;
 }
 
 MyMoneyFinancialCalculator::MyMoneyFinancialCalculator() :
   d_ptr(new MyMoneyFinancialCalculatorPrivate)
 {
   Q_D(MyMoneyFinancialCalculator);
   setPrec();
   setPF();
   setCF();
   setBep();
   setDisc();
 
   setNpp(0.0);
   setIr(0.0);
   setPv(0.0);
   setPmt(0.0);
   setFv(0.0);
 
   // clear the mask
   d->m_mask = 0;
 }
 
 MyMoneyFinancialCalculator::~MyMoneyFinancialCalculator()
 {
   Q_D(MyMoneyFinancialCalculator);
   delete d;
 }
 
 void MyMoneyFinancialCalculator::setPrec(const unsigned short prec)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_prec = prec;
 }
 
 void MyMoneyFinancialCalculator::setPF(const unsigned short PF)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_PF = PF;
 }
 
 void MyMoneyFinancialCalculator::setCF(const unsigned short CF)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_CF = CF;
 }
 
 void MyMoneyFinancialCalculator::setBep(const bool bep)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_bep = bep;
 }
 
 void MyMoneyFinancialCalculator::setDisc(const bool disc)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_disc = disc;
 }
 
 void MyMoneyFinancialCalculator::setIr(const double ir)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_ir = ir;
   d->m_mask |= IR_SET;
 }
 
 double MyMoneyFinancialCalculator::ir() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   return d->m_ir;
 }
 
 void MyMoneyFinancialCalculator::setPv(const double pv)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_pv = pv;
   d->m_mask |= PV_SET;
 }
 
 double MyMoneyFinancialCalculator::pv() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   return d->m_pv;
 }
 
 void MyMoneyFinancialCalculator::setPmt(const double pmt)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_pmt = pmt;
   d->m_mask |= PMT_SET;
 }
 
 double MyMoneyFinancialCalculator::pmt() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   return d->m_pmt;
 }
 
 void MyMoneyFinancialCalculator::setNpp(const double npp)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_npp = npp;
   d->m_mask |= NPP_SET;
 }
 
 double MyMoneyFinancialCalculator::npp() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   return d->m_npp;
 }
 
 void MyMoneyFinancialCalculator::setFv(const double fv)
 {
   Q_D(MyMoneyFinancialCalculator);
   d->m_fv = fv;
   d->m_mask |= FV_SET;
 }
 
 double MyMoneyFinancialCalculator::fv() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   return d->m_fv;
 }
 
 double MyMoneyFinancialCalculator::numPayments()
 {
   Q_D(MyMoneyFinancialCalculator);
   const unsigned short mask = PV_SET | IR_SET | PMT_SET | FV_SET;
 
   if ((d->m_mask & mask) != mask)
-    throw MYMONEYEXCEPTION("Not all parameters set for calculation of numPayments");
+    throw MYMONEYEXCEPTION_CSTRING("Not all parameters set for calculation of numPayments");
 
   double eint = d->eff_int();
 
   //add exception for zero interest
   if (eint == 0.0) {
     d->m_npp = -(d->m_pv / d->m_pmt);
 
   } else {
     double CC = d->_Cx(eint);
 
     CC = (CC - d->m_fv) / (CC + d->m_pv);
     d->m_npp = (CC > 0.0) ? log(CC) / log(eint + 1.0) : 0.0;
 
     d->m_mask |= NPP_SET;
   }
   return d->m_npp;
 }
 
 double MyMoneyFinancialCalculator::payment()
 {
   Q_D(MyMoneyFinancialCalculator);
   const unsigned short mask = PV_SET | IR_SET | NPP_SET | FV_SET;
 
   if ((d->m_mask & mask) != mask)
-    throw MYMONEYEXCEPTION("Not all parameters set for calculation of payment");
+    throw MYMONEYEXCEPTION_CSTRING("Not all parameters set for calculation of payment");
 
   double eint = d->eff_int();
 
   //add exception for zero interest
   if (eint == 0.0) {
     d->m_pmt = -(d->m_pv / d->m_npp);
   } else {
     double AA = d->_Ax(eint);
     double BB = d->_Bx(eint);
 
     d->m_pmt = -d->rnd((d->m_fv + d->m_pv * (AA + 1.0)) / (AA * BB));
   }
 
   d->m_mask |= PMT_SET;
   return d->m_pmt;
 }
 
 double MyMoneyFinancialCalculator::presentValue()
 {
   Q_D(MyMoneyFinancialCalculator);
   const unsigned short mask = PMT_SET | IR_SET | NPP_SET | FV_SET;
 
   if ((d->m_mask & mask) != mask)
-    throw MYMONEYEXCEPTION("Not all parameters set for calculation of payment");
+    throw MYMONEYEXCEPTION_CSTRING("Not all parameters set for calculation of payment");
 
   double eint = d->eff_int();
 
   //add exception for zero interest
   if (eint == 0.0) {
     d->m_pv = -(d->m_fv + (d->m_npp * d->m_pmt));
   } else {
     double AA = d->_Ax(eint);
     double CC = d->_Cx(eint);
 
     d->m_pv = d->rnd(-(d->m_fv + (AA * CC)) / (AA + 1.0));
 
   }
 
   d->m_mask |= PV_SET;
   return d->m_pv;
 }
 
 double MyMoneyFinancialCalculator::futureValue()
 {
   Q_D(MyMoneyFinancialCalculator);
   const unsigned short mask = PMT_SET | IR_SET | NPP_SET | PV_SET;
 
   if ((d->m_mask & mask) != mask)
-    throw MYMONEYEXCEPTION("Not all parameters set for calculation of payment");
+    throw MYMONEYEXCEPTION_CSTRING("Not all parameters set for calculation of payment");
 
   double eint = d->eff_int();
 
   //add exception for zero interest
   if (eint == 0.0) {
     d->m_fv = d->rnd(-(d->m_pv + (d->m_npp * d->m_pmt)));
   } else {
     double AA = d->_Ax(eint);
     double CC = d->_Cx(eint);
     d->m_fv = d->rnd(-(d->m_pv + AA * (d->m_pv + CC)));
   }
 
   d->m_mask |= FV_SET;
   return d->m_fv;
 }
 
 double MyMoneyFinancialCalculator::interestRate()
 {
   Q_D(MyMoneyFinancialCalculator);
   double eint = 0.0;
   double a = 0.0;
   double dik = 0.0;
 
   const double ratio = 1e4;
   int ri;
 
   if (d->m_pmt == 0.0) {
     eint = pow((dabs(d->m_fv) / dabs(d->m_pv)), (1.0 / d->m_npp)) - 1.0;
   } else {
     if ((d->m_pmt * d->m_fv) < 0.0) {
       if (d->m_pv)
         a = -1.0;
       else
         a = 1.0;
       eint =
         dabs((d->m_fv + a * d->m_npp * d->m_pmt) /
              (3.0 *
               ((d->m_npp - 1.0) * (d->m_npp - 1.0) * d->m_pmt + d->m_pv -
                d->m_fv)));
     } else {
       if ((d->m_pv * d->m_pmt) < 0.0) {
         eint = dabs((d->m_npp * d->m_pmt + d->m_pv + d->m_fv) / (d->m_npp * d->m_pv));
       } else {
         a = dabs(d->m_pmt / (dabs(d->m_pv) + dabs(d->m_fv)));
         eint = a + 1.0 / (a * d->m_npp * d->m_npp * d->m_npp);
       }
     }
     do {
       try {
         dik = d->_fi(eint) / d->_fip(eint);
         eint -= dik;
       } catch (const MyMoneyException &) {
         eint = 0;
       }
       (void) modf(ratio *(dik / eint), &a);
       ri = static_cast<unsigned>(a);
     } while (ri);
   }
   d->m_mask |= IR_SET;
   d->m_ir = d->rnd(d->nom_int(eint) * 100.0);
   return d->m_ir;
 }
 
 double MyMoneyFinancialCalculator::interestDue() const
 {
   Q_D(const MyMoneyFinancialCalculator);
   double eint = d->eff_int();
 
   return (d->m_pv + (d->m_bep ? d->m_pmt : 0.0)) * eint;
 }
 
diff --git a/kmymoney/mymoney/mymoneyfinancialcalculator_p.h b/kmymoney/mymoney/mymoneyfinancialcalculator_p.h
index 55845a874..e2a0737a7 100644
--- a/kmymoney/mymoney/mymoneyfinancialcalculator_p.h
+++ b/kmymoney/mymoney/mymoneyfinancialcalculator_p.h
@@ -1,172 +1,172 @@
 /***************************************************************************
                           mymoneyfinancialcalculator_p.h  -  description
                              -------------------
     begin                : Tue Oct 21 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYFINANCIALCALCULATOR_P_H
 #define MYMONEYFINANCIALCALCULATOR_P_H
 
 #include "mymoneyfinancialcalculator.h"
 
 #include <qglobal.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 
 class MyMoneyFinancialCalculatorPrivate
 {
   Q_DISABLE_COPY(MyMoneyFinancialCalculatorPrivate)
 
 public:
 
   MyMoneyFinancialCalculatorPrivate() :
     m_ir(0.0),
     m_pv(0.0),
     m_pmt(0.0),
     m_fv(0.0),
     m_npp(0.0),
     m_CF(0),
     m_PF(0),
     m_prec(2),
     m_bep(false),
     m_disc(false),
     m_mask(0)
   {
   }
 
   double _fi(const double eint) const
   {
     return _Ax(eint) *(m_pv + _Cx(eint)) + m_pv + m_fv;
   }
 
   double _fip(const double eint) const
   {
     double AA = _Ax(eint);
     double CC = _Cx(eint);
     double D = (AA + 1.0) / (eint + 1.0);
 
     return m_npp *(m_pv + CC) * D - (AA * CC) / eint;
   }
 
   double _Ax(const double eint) const
   {
     return pow((eint + 1.0), m_npp) - 1.0;
   }
 
   double _Bx(const double eint) const
   {
     if (eint == 0.0)
-      throw MYMONEYEXCEPTION("Zero interest");
+      throw MYMONEYEXCEPTION_CSTRING("Zero interest");
 
     if (m_bep == false)
       return static_cast<double>(1.0) / eint;
 
     return (eint + 1.0) / eint;
   }
 
   double _Cx(const double eint) const
   {
     return m_pmt * _Bx(eint);
   }
 
   double eff_int() const
   {
     double nint = m_ir / 100.0;
     double eint;
 
     if (m_disc) {             // periodically compound?
       if (m_CF == m_PF) {     // same frequency?
         eint = nint / static_cast<double>(m_CF);
 
       } else {
         eint = pow((static_cast<double>(1.0) + (nint / static_cast<double>(m_CF))),
                    (static_cast<double>(m_CF) / static_cast<double>(m_PF))) - 1.0;
 
       }
 
     } else {
       eint = exp(nint / static_cast<double>(m_PF)) - 1.0;
     }
 
     return eint;
   }
 
   double nom_int(const double eint) const
   {
     double nint;
 
     if (m_disc) {
       if (m_CF == m_PF) {
         nint = m_CF * eint;
 
       } else {
         nint = m_CF * (pow((eint + 1.0), (static_cast<double>(m_PF) / static_cast<double>(m_CF))) - 1.0);
       }
     } else
       nint = log(pow(eint + 1.0, m_PF));
 
     return nint;
   }
 
   double rnd(const double x) const
   {
     double r, f;
 
     if (m_prec > 0) {
       f = pow(10.0, m_prec);
       r = qRound64(x * f) / f;
     } else {
       r = qRound64(x);
     }
     return r;
   }
 
   double          m_ir;   // nominal interest rate
   double          m_pv;   // present value
   double          m_pmt;  // periodic payment
   double          m_fv;   // future value
   double          m_npp;  // number of payment periods
 
   unsigned short  m_CF;   // compounding frequency
   unsigned short  m_PF;   // payment frequency
 
   unsigned short  m_prec; // precision for roundoff for pv, pmt and fv
   // i is not rounded, n is integer
 
   bool            m_bep;  // beginning/end of period payment flag
   bool            m_disc; // discrete/continuous compounding flag
 
   unsigned short m_mask; // available value mask
 
 };
 
 #endif
 
diff --git a/kmymoney/mymoney/mymoneyforecast.cpp b/kmymoney/mymoney/mymoneyforecast.cpp
index c580212b8..4db9db2cb 100644
--- a/kmymoney/mymoney/mymoneyforecast.cpp
+++ b/kmymoney/mymoney/mymoneyforecast.cpp
@@ -1,1708 +1,1708 @@
 /***************************************************************************
                           mymoneyforecast.cpp
                              -------------------
     begin                : Wed May 30 2007
     copyright            : (C) 2007 by Alvaro Soliverez
     email                : asoliverez@gmail.com
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyforecast.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QList>
 #include <QDebug>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneysecurity.h"
 #include "mymoneybudget.h"
 #include "mymoneyschedule.h"
 #include "mymoneyprice.h"
 #include "mymoneymoney.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneyfinancialcalculator.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 enum class eForecastMethod {Scheduled = 0, Historic = 1 };
 
 /**
  * daily balances of an account
  */
 typedef QMap<QDate, MyMoneyMoney> dailyBalances;
 
 /**
  * map of trends of an account
  */
 typedef QMap<int, MyMoneyMoney> trendBalances;
 
 class MyMoneyForecastPrivate
 {
   Q_DECLARE_PUBLIC(MyMoneyForecast)
 
 public:
   explicit MyMoneyForecastPrivate(MyMoneyForecast *qq) :
     q_ptr(qq),
     m_accountsCycle(30),
     m_forecastCycles(3),
     m_forecastDays(90),
     m_beginForecastDay(0),
     m_forecastMethod(eForecastMethod::Scheduled),
     m_historyMethod(1),
     m_skipOpeningDate(true),
     m_includeUnusedAccounts(false),
     m_forecastDone(false),
     m_includeFutureTransactions(true),
     m_includeScheduledTransactions(true)
   {
   }
 
   eForecastMethod forecastMethod() const
   {
     return m_forecastMethod;
   }
 
   /**
    * Returns the list of accounts to create a budget. Only Income and Expenses are returned.
    */
   QList<MyMoneyAccount> budgetAccountList()
   {
     auto file = MyMoneyFile::instance();
 
     QList<MyMoneyAccount> accList;
     QStringList emptyStringList;
     //Get all accounts from the file and check if they are of the right type to calculate forecast
     file->accountList(accList, emptyStringList, false);
     QList<MyMoneyAccount>::iterator accList_t = accList.begin();
     for (; accList_t != accList.end();) {
       auto acc = *accList_t;
       if (acc.isClosed()            //check the account is not closed
           || (!acc.isIncomeExpense())) {
         //remove the account if it is not of the correct type
         accList_t = accList.erase(accList_t);
       } else {
         ++accList_t;
       }
     }
     return accList;
   }
 
   /**
    * calculate daily forecast balance based on historic transactions
    */
   void calculateHistoricDailyBalances()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     calculateAccountTrendList();
 
     //Calculate account daily balances
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.constBegin(); it_n != m_forecastAccounts.constEnd(); ++it_n) {
       auto acc = file->account(*it_n);
 
       //set the starting balance of the account
       setStartingBalance(acc);
 
       switch (q->historyMethod()) {
       case 0:
       case 1: {
         for (QDate f_day = q->forecastStartDate(); f_day <= q->forecastEndDate();) {
           for (int t_day = 1; t_day <= q->accountsCycle(); ++t_day) {
             MyMoneyMoney balanceDayBefore = m_accountList[acc.id()][(f_day.addDays(-1))];//balance of the day before
             MyMoneyMoney accountDailyTrend = m_accountTrendList[acc.id()][t_day]; //trend for that day
             //balance of the day is the balance of the day before multiplied by the trend for the day
             m_accountList[acc.id()][f_day] = balanceDayBefore;
             m_accountList[acc.id()][f_day] += accountDailyTrend; //movement trend for that particular day
             m_accountList[acc.id()][f_day] = m_accountList[acc.id()][f_day].convert(acc.fraction());
             //m_accountList[acc.id()][f_day] += m_accountListPast[acc.id()][f_day.addDays(-q->historyDays())];
             f_day = f_day.addDays(1);
           }
         }
       }
         break;
       case 2: {
         QDate baseDate = QDate::currentDate().addDays(-q->accountsCycle());
         for (int t_day = 1; t_day <= q->accountsCycle(); ++t_day) {
           int f_day = 1;
           QDate fDate = baseDate.addDays(q->accountsCycle() + 1);
           while (fDate <= q->forecastEndDate()) {
 
             //the calculation is based on the balance for the last month, that is then multiplied by the trend
             m_accountList[acc.id()][fDate] = m_accountListPast[acc.id()][baseDate] + (m_accountTrendList[acc.id()][t_day] * MyMoneyMoney(f_day, 1));
             m_accountList[acc.id()][fDate] = m_accountList[acc.id()][fDate].convert(acc.fraction());
             ++f_day;
             fDate = baseDate.addDays(q->accountsCycle() * f_day);
           }
           baseDate = baseDate.addDays(1);
         }
       }
       }
     }
   }
 
   /**
    * calculate monthly budget balance based on historic transactions
    */
   void calculateHistoricMonthlyBalances()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     //Calculate account monthly balances
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.constBegin(); it_n != m_forecastAccounts.constEnd(); ++it_n) {
       auto acc = file->account(*it_n);
 
       for (QDate f_date = q->forecastStartDate(); f_date <= q->forecastEndDate();) {
         for (int f_day = 1; f_day <= q->accountsCycle() && f_date <= q->forecastEndDate(); ++f_day) {
           MyMoneyMoney accountDailyTrend = m_accountTrendList[acc.id()][f_day]; //trend for that day
           //check for leap year
           if (f_date.month() == 2 && f_date.day() == 29)
             f_date = f_date.addDays(1); //skip 1 day
           m_accountList[acc.id()][QDate(f_date.year(), f_date.month(), 1)] += accountDailyTrend; //movement trend for that particular day
           f_date = f_date.addDays(1);
         }
       }
     }
   }
 
   /**
    * calculate monthly budget balance based on historic transactions
    */
   void calculateScheduledMonthlyBalances()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     //Calculate account monthly balances
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.constBegin(); it_n != m_forecastAccounts.constEnd(); ++it_n) {
       auto acc = file->account(*it_n);
 
       for (QDate f_date = q->forecastStartDate(); f_date <= q->forecastEndDate(); f_date = f_date.addDays(1)) {
         //get the trend for the day
         MyMoneyMoney accountDailyBalance = m_accountList[acc.id()][f_date];
 
         //do not add if it is the beginning of the month
         //otherwise we end up with duplicated values as reported by Marko Käning
         if (f_date != QDate(f_date.year(), f_date.month(), 1))
           m_accountList[acc.id()][QDate(f_date.year(), f_date.month(), 1)] += accountDailyBalance;
       }
     }
   }
 
   /**
    * calculate forecast based on future and scheduled transactions
    */
   void doFutureScheduledForecast()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     if (q->isIncludingFutureTransactions())
       addFutureTransactions();
 
     if (q->isIncludingScheduledTransactions())
       addScheduledTransactions();
 
     //do not show accounts with no transactions
     if (!q->isIncludingUnusedAccounts())
       purgeForecastAccountsList(m_accountList);
 
     //adjust value of investments to deep currency
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.constBegin(); it_n != m_forecastAccounts.constEnd(); ++it_n) {
       auto acc = file->account(*it_n);
 
       if (acc.isInvest()) {
         //get the id of the security for that account
         MyMoneySecurity undersecurity = file->security(acc.currencyId());
 
         //only do it if the security is not an actual currency
         if (! undersecurity.isCurrency()) {
           //set the default value
           MyMoneyMoney rate = MyMoneyMoney::ONE;
 
           for (QDate it_day = QDate::currentDate(); it_day <= q->forecastEndDate();) {
             //get the price for the tradingCurrency that day
             const MyMoneyPrice &price = file->price(undersecurity.id(), undersecurity.tradingCurrency(), it_day);
             if (price.isValid()) {
               rate = price.rate(undersecurity.tradingCurrency());
             }
             //value is the amount of shares multiplied by the rate of the deep currency
             m_accountList[acc.id()][it_day] = m_accountList[acc.id()][it_day] * rate;
             it_day = it_day.addDays(1);
           }
         }
       }
     }
   }
 
   /**
    * add future transactions to forecast
    */
   void addFutureTransactions()
   {
     Q_Q(MyMoneyForecast);
     MyMoneyTransactionFilter filter;
     auto file = MyMoneyFile::instance();
 
     // collect and process all transactions that have already been entered but
     // are located in the future.
     filter.setDateFilter(q->forecastStartDate(), q->forecastEndDate());
     filter.setReportAllSplits(false);
 
     foreach (const auto transaction, file->transactionList(filter)) {
       foreach (const auto split, transaction.splits()) {
         if (!split.shares().isZero()) {
           auto acc = file->account(split.accountId());
           if (q->isForecastAccount(acc)) {
             dailyBalances balance;
             balance = m_accountList[acc.id()];
             //if it is income, the balance is stored as negative number
             if (acc.accountType() == eMyMoney::Account::Type::Income) {
               balance[transaction.postDate()] += (split.shares() * MyMoneyMoney::MINUS_ONE);
             } else {
               balance[transaction.postDate()] += split.shares();
             }
             m_accountList[acc.id()] = balance;
           }
         }
       }
     }
 
 #if 0
     QFile trcFile("forecast.csv");
     trcFile.open(QIODevice::WriteOnly);
     QTextStream s(&trcFile);
 
     {
       s << "Already present transactions\n";
       QMap<QString, dailyBalances>::Iterator it_a;
       QSet<QString>::ConstIterator it_n;
       for (it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) {
         auto acc = file->account(*it_n);
         it_a = m_accountList.find(*it_n);
         s << "\"" << acc.name() << "\",";
         for (int i = 0; i < 90; ++i) {
           s << "\"" << (*it_a)[i].formatMoney("") << "\",";
         }
         s << "\n";
       }
     }
 #endif
 
   }
 
   /**
    * add scheduled transactions to forecast
    */
   void addScheduledTransactions()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     // now process all the schedules that may have an impact
     QList<MyMoneySchedule> schedule;
 
     schedule = file->scheduleList(QString(), eMyMoney::Schedule::Type::Any, eMyMoney::Schedule::Occurrence::Any, eMyMoney::Schedule::PaymentType::Any,
                                   QDate(), q->forecastEndDate(), false);
     if (schedule.count() > 0) {
       QList<MyMoneySchedule>::Iterator it;
       do {
         qSort(schedule);
         it = schedule.begin();
         if (it == schedule.end())
           break;
 
         if ((*it).isFinished()) {
           schedule.erase(it);
           continue;
         }
 
         QDate date = (*it).nextPayment((*it).lastPayment());
         if (!date.isValid()) {
           schedule.erase(it);
           continue;
         }
 
         QDate nextDate =
             (*it).adjustedNextPayment((*it).adjustedDate((*it).lastPayment(),
                                                          (*it).weekendOption()));
         if (nextDate > q->forecastEndDate()) {
           // We're done with this schedule, let's move on to the next
           schedule.erase(it);
           continue;
         }
 
         // found the next schedule. process it
 
         auto acc = (*it).account();
 
         if (!acc.id().isEmpty()) {
           try {
             if (acc.accountType() != eMyMoney::Account::Type::Investment) {
               auto t = (*it).transaction();
 
               // only process the entry, if it is still active
               if (!(*it).isFinished() && nextDate != QDate()) {
                 // make sure we have all 'starting balances' so that the autocalc works
                 QMap<QString, MyMoneyMoney> balanceMap;
 
                 foreach (const auto split, t.splits()) {
                   auto accountFromSplit = file->account(split.accountId());
                   if (q->isForecastAccount(accountFromSplit)) {
                     // collect all overdues on the first day
                     QDate forecastDate = nextDate;
                     if (QDate::currentDate() >= nextDate)
                       forecastDate = QDate::currentDate().addDays(1);
 
                     dailyBalances balance;
                     balance = m_accountList[accountFromSplit.id()];
                     for (QDate f_day = QDate::currentDate(); f_day < forecastDate;) {
                       balanceMap[accountFromSplit.id()] += m_accountList[accountFromSplit.id()][f_day];
                       f_day = f_day.addDays(1);
                     }
                   }
                 }
 
                 // take care of the autoCalc stuff
                 q->calculateAutoLoan(*it, t, balanceMap);
 
                 // now add the splits to the balances
                 foreach (const auto split, t.splits()) {
                   auto accountFromSplit = file->account(split.accountId());
                   if (q->isForecastAccount(accountFromSplit)) {
                     dailyBalances balance;
                     balance = m_accountList[accountFromSplit.id()];
                     //int offset = QDate::currentDate().daysTo(nextDate);
                     //if(offset <= 0) {  // collect all overdues on the first day
                     //  offset = 1;
                     //}
                     // collect all overdues on the first day
                     QDate forecastDate = nextDate;
                     if (QDate::currentDate() >= nextDate)
                       forecastDate = QDate::currentDate().addDays(1);
 
                     if (accountFromSplit.accountType() == eMyMoney::Account::Type::Income) {
                       balance[forecastDate] += (split.shares() * MyMoneyMoney::MINUS_ONE);
                     } else {
                       balance[forecastDate] += split.shares();
                     }
                     m_accountList[accountFromSplit.id()] = balance;
                   }
                 }
               }
             }
             (*it).setLastPayment(date);
 
           } catch (const MyMoneyException &e) {
             qDebug() << Q_FUNC_INFO << " Schedule " << (*it).id() << " (" << (*it).name() << "): " << e.what();
 
             schedule.erase(it);
           }
         } else {
           // remove schedule from list
           schedule.erase(it);
         }
       } while (1);
     }
 
 #if 0
     {
       s << "\n\nAdded scheduled transactions\n";
       QMap<QString, dailyBalances>::Iterator it_a;
       QSet<QString>::ConstIterator it_n;
       for (it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) {
         auto acc = file->account(*it_n);
         it_a = m_accountList.find(*it_n);
         s << "\"" << acc.name() << "\",";
         for (int i = 0; i < 90; ++i) {
           s << "\"" << (*it_a)[i].formatMoney("") << "\",";
         }
         s << "\n";
       }
     }
 #endif
   }
 
   /**
    * calculate daily forecast balance based on future and scheduled transactions
    */
   void calculateScheduledDailyBalances()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     //Calculate account daily balances
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.constBegin(); it_n != m_forecastAccounts.constEnd(); ++it_n) {
       auto acc = file->account(*it_n);
 
       //set the starting balance of the account
       setStartingBalance(acc);
 
       for (QDate f_day = q->forecastStartDate(); f_day <= q->forecastEndDate();) {
         MyMoneyMoney balanceDayBefore = m_accountList[acc.id()][(f_day.addDays(-1))];//balance of the day before
         m_accountList[acc.id()][f_day] += balanceDayBefore; //running sum
         f_day = f_day.addDays(1);
       }
     }
   }
 
   /**
    * set the starting balance for an accounts
    */
   void setStartingBalance(const MyMoneyAccount& acc)
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
 
     //Get current account balance
     if (acc.isInvest()) {   //investments require special treatment
       //get the security id of that account
       MyMoneySecurity undersecurity = file->security(acc.currencyId());
 
       //only do it if the security is not an actual currency
       if (! undersecurity.isCurrency()) {
         //set the default value
         MyMoneyMoney rate = MyMoneyMoney::ONE;
         //get te
         const MyMoneyPrice &price = file->price(undersecurity.id(), undersecurity.tradingCurrency(), QDate::currentDate());
         if (price.isValid()) {
           rate = price.rate(undersecurity.tradingCurrency());
         }
         m_accountList[acc.id()][QDate::currentDate()] = file->balance(acc.id(), QDate::currentDate()) * rate;
       }
     } else {
       m_accountList[acc.id()][QDate::currentDate()] = file->balance(acc.id(), QDate::currentDate());
     }
 
     //if the method is linear regression, we have to add the opening balance to m_accountListPast
     if (forecastMethod() == eForecastMethod::Historic && q->historyMethod() == 2) {
       //FIXME workaround for stock opening dates
       QDate openingDate;
       if (acc.accountType() == eMyMoney::Account::Type::Stock) {
         auto parentAccount = file->account(acc.parentAccountId());
         openingDate = parentAccount.openingDate();
       } else {
         openingDate = acc.openingDate();
       }
 
       //add opening balance only if it opened after the history start
       if (openingDate >= q->historyStartDate()) {
 
         MyMoneyMoney openingBalance;
 
         openingBalance = file->balance(acc.id(), openingDate);
 
         //calculate running sum
         for (QDate it_date = openingDate; it_date <= q->historyEndDate(); it_date = it_date.addDays(1)) {
           //investments require special treatment
           if (acc.isInvest()) {
             //get the security id of that account
             MyMoneySecurity undersecurity = file->security(acc.currencyId());
 
             //only do it if the security is not an actual currency
             if (! undersecurity.isCurrency()) {
               //set the default value
               MyMoneyMoney rate = MyMoneyMoney::ONE;
 
               //get the rate for that specific date
               const MyMoneyPrice &price = file->price(undersecurity.id(), undersecurity.tradingCurrency(), it_date);
               if (price.isValid()) {
                 rate = price.rate(undersecurity.tradingCurrency());
               }
               m_accountListPast[acc.id()][it_date] += openingBalance * rate;
             }
           } else {
             m_accountListPast[acc.id()][it_date] += openingBalance;
           }
         }
       }
     }
   }
 
   /**
    * Returns the day moving average for the account @a acc based on the daily balances of a given number of @p forecastTerms
    * It returns the moving average for a given @p trendDay of the forecastTerm
    * With a term of 1 month and 3 terms, it calculates the trend taking the transactions occurred
    * at that day and the day before,for the last 3 months
    */
   MyMoneyMoney accountMovingAverage(const MyMoneyAccount& acc, const int trendDay, const int forecastTerms)
   {
     Q_Q(MyMoneyForecast);
     //Calculate a daily trend for the account based on the accounts of a given number of terms
     //With a term of 1 month and 3 terms, it calculates the trend taking the transactions occurred at that day and the day before,
     //for the last 3 months
     MyMoneyMoney balanceVariation;
 
     for (int it_terms = 0; (trendDay + (q->accountsCycle()*it_terms)) <= q->historyDays(); ++it_terms) { //sum for each term
       MyMoneyMoney balanceBefore = m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-2)]; //get balance for the day before
       MyMoneyMoney balanceAfter = m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-1)];
       balanceVariation += (balanceAfter - balanceBefore); //add the balance variation between days
     }
     //calculate average of the variations
     return (balanceVariation / MyMoneyMoney(forecastTerms, 1)).convert(10000);
   }
 
   /**
    * Returns the weighted moving average for a given @p trendDay
    */
   MyMoneyMoney accountWeightedMovingAverage(const MyMoneyAccount& acc, const int trendDay, const int totalWeight)
   {
     Q_Q(MyMoneyForecast);
     MyMoneyMoney balanceVariation;
 
     for (int it_terms = 0, weight = 1; (trendDay + (q->accountsCycle()*it_terms)) <= q->historyDays(); ++it_terms, ++weight) { //sum for each term multiplied by weight
       MyMoneyMoney balanceBefore = m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-2)]; //get balance for the day before
       MyMoneyMoney balanceAfter = m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-1)];
       balanceVariation += ((balanceAfter - balanceBefore) * MyMoneyMoney(weight, 1));   //add the balance variation between days multiplied by its weight
     }
     //calculate average of the variations
     return (balanceVariation / MyMoneyMoney(totalWeight, 1)).convert(10000);
   }
 
   /**
    * Returns the linear regression for a given @p trendDay
    */
   MyMoneyMoney accountLinearRegression(const MyMoneyAccount &acc, const int trendDay, const int actualTerms, const MyMoneyMoney& meanTerms)
   {
     Q_Q(MyMoneyForecast);
     MyMoneyMoney meanBalance, totalBalance, totalTerms;
     totalTerms = MyMoneyMoney(actualTerms, 1);
 
     //calculate mean balance
     for (int it_terms = q->forecastCycles() - actualTerms; (trendDay + (q->accountsCycle()*it_terms)) <= q->historyDays(); ++it_terms) { //sum for each term
       totalBalance += m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-1)];
     }
     meanBalance = totalBalance / MyMoneyMoney(actualTerms, 1);
     meanBalance = meanBalance.convert(10000);
 
     //calculate b1
 
     //first calculate x - mean x multiplied by y - mean y
     MyMoneyMoney totalXY, totalSqX;
     for (int it_terms = q->forecastCycles() - actualTerms, term = 1; (trendDay + (q->accountsCycle()*it_terms)) <= q->historyDays(); ++it_terms, ++term) { //sum for each term
       MyMoneyMoney balance = m_accountListPast[acc.id()][q->historyStartDate().addDays(trendDay+(q->accountsCycle()*it_terms)-1)];
 
       MyMoneyMoney balMeanBal = balance - meanBalance;
       MyMoneyMoney termMeanTerm = (MyMoneyMoney(term, 1) - meanTerms);
 
       totalXY += (balMeanBal * termMeanTerm).convert(10000);
 
       totalSqX += (termMeanTerm * termMeanTerm).convert(10000);
     }
     totalXY = (totalXY / MyMoneyMoney(actualTerms, 1)).convert(10000);
     totalSqX = (totalSqX / MyMoneyMoney(actualTerms, 1)).convert(10000);
 
     //check zero
     if (totalSqX.isZero())
       return MyMoneyMoney();
 
     MyMoneyMoney linReg = (totalXY / totalSqX).convert(10000);
 
     return linReg;
   }
 
   /**
    * calculate daily forecast trend based on historic transactions
    */
   void calculateAccountTrendList()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
     int auxForecastTerms;
     int totalWeight = 0;
 
     //Calculate account trends
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.begin(); it_n != m_forecastAccounts.end(); ++it_n) {
       auto acc = file->account(*it_n);
       m_accountTrendList[acc.id()][0] = MyMoneyMoney(); // for today, the trend is 0
 
       auxForecastTerms = q->forecastCycles();
       if (q->skipOpeningDate()) {
 
         QDate openingDate;
         if (acc.accountType() == eMyMoney::Account::Type::Stock) {
           auto parentAccount = file->account(acc.parentAccountId());
           openingDate = parentAccount.openingDate();
         } else {
           openingDate = acc.openingDate();
         }
 
         if (openingDate > q->historyStartDate()) { //if acc opened after forecast period
           auxForecastTerms = 1 + ((openingDate.daysTo(q->historyEndDate()) + 1) / q->accountsCycle()); // set forecastTerms to a lower value, to calculate only based on how long this account was opened
         }
       }
 
       switch (q->historyMethod()) {
       //moving average
       case 0: {
         for (int t_day = 1; t_day <= q->accountsCycle(); t_day++)
           m_accountTrendList[acc.id()][t_day] = accountMovingAverage(acc, t_day, auxForecastTerms); //moving average
         break;
       }
         //weighted moving average
       case 1: {
         //calculate total weight for moving average
         if (auxForecastTerms == q->forecastCycles()) {
           totalWeight = (auxForecastTerms * (auxForecastTerms + 1)) / 2; //totalWeight is the triangular number of auxForecastTerms
         } else {
           //if only taking a few periods, totalWeight is the sum of the weight for most recent periods
           for (int i = 1, w = q->forecastCycles(); i <= auxForecastTerms; ++i, --w)
             totalWeight += w;
         }
         for (int t_day = 1; t_day <= q->accountsCycle(); t_day++)
           m_accountTrendList[acc.id()][t_day] = accountWeightedMovingAverage(acc, t_day, totalWeight);
         break;
       }
       case 2: {
         //calculate mean term
         MyMoneyMoney meanTerms = MyMoneyMoney((auxForecastTerms * (auxForecastTerms + 1)) / 2, 1) / MyMoneyMoney(auxForecastTerms, 1);
 
         for (int t_day = 1; t_day <= q->accountsCycle(); t_day++)
           m_accountTrendList[acc.id()][t_day] = accountLinearRegression(acc, t_day, auxForecastTerms, meanTerms);
         break;
       }
       default:
         break;
       }
     }
   }
 
   /**
    * set the internal list of accounts to be forecast
    */
   void setForecastAccountList()
   {
     Q_Q(MyMoneyForecast);
     //get forecast accounts
     QList<MyMoneyAccount> accList;
     accList = q->forecastAccountList();
 
     QList<MyMoneyAccount>::const_iterator accList_t = accList.constBegin();
     for (; accList_t != accList.constEnd(); ++accList_t) {
       m_forecastAccounts.insert((*accList_t).id());
     }
   }
 
   /**
    * set the internal list of accounts to create a budget
    */
   void setBudgetAccountList()
   {
     //get budget accounts
     QList<MyMoneyAccount> accList;
     accList = budgetAccountList();
 
     QList<MyMoneyAccount>::const_iterator accList_t = accList.constBegin();
     for (; accList_t != accList.constEnd(); ++accList_t) {
       m_forecastAccounts.insert((*accList_t).id());
     }
   }
 
   /**
    * get past transactions for the accounts to be forecast
    */
   void pastTransactions()
   {
     Q_Q(MyMoneyForecast);
     auto file = MyMoneyFile::instance();
     MyMoneyTransactionFilter filter;
 
     filter.setDateFilter(q->historyStartDate(), q->historyEndDate());
     filter.setReportAllSplits(false);
 
     //Check past transactions
     foreach (const auto transaction, file->transactionList(filter)) {
       foreach (const auto split, transaction.splits()) {
         if (!split.shares().isZero()) {
           auto acc = file->account(split.accountId());
 
           //workaround for stock accounts which have faulty opening dates
           QDate openingDate;
           if (acc.accountType() == eMyMoney::Account::Type::Stock) {
             auto parentAccount = file->account(acc.parentAccountId());
             openingDate = parentAccount.openingDate();
           } else {
             openingDate = acc.openingDate();
           }
 
           if (q->isForecastAccount(acc) //If it is one of the accounts we are checking, add the amount of the transaction
               && ((openingDate < transaction.postDate() && q->skipOpeningDate())
                   || !q->skipOpeningDate())) {  //don't take the opening day of the account to calculate balance
             dailyBalances balance;
             //FIXME deal with leap years
             balance = m_accountListPast[acc.id()];
             if (acc.accountType() == eMyMoney::Account::Type::Income) {//if it is income, the balance is stored as negative number
               balance[transaction.postDate()] += (split.shares() * MyMoneyMoney::MINUS_ONE);
             } else {
               balance[transaction.postDate()] += split.shares();
             }
             // check if this is a new account for us
             m_accountListPast[acc.id()] = balance;
           }
         }
       }
     }
 
     //purge those accounts with no transactions on the period
     if (q->isIncludingUnusedAccounts() == false)
       purgeForecastAccountsList(m_accountListPast);
 
     //calculate running sum
     QSet<QString>::ConstIterator it_n;
     for (it_n = m_forecastAccounts.begin(); it_n != m_forecastAccounts.end(); ++it_n) {
       auto acc = file->account(*it_n);
       m_accountListPast[acc.id()][q->historyStartDate().addDays(-1)] = file->balance(acc.id(), q->historyStartDate().addDays(-1));
       for (QDate it_date = q->historyStartDate(); it_date <= q->historyEndDate();) {
         m_accountListPast[acc.id()][it_date] += m_accountListPast[acc.id()][it_date.addDays(-1)]; //Running sum
         it_date = it_date.addDays(1);
       }
     }
 
     //adjust value of investments to deep currency
     for (it_n = m_forecastAccounts.begin(); it_n != m_forecastAccounts.end(); ++it_n) {
       auto acc = file->account(*it_n);
 
       if (acc.isInvest()) {
         //get the id of the security for that account
         MyMoneySecurity undersecurity = file->security(acc.currencyId());
         if (! undersecurity.isCurrency()) { //only do it if the security is not an actual currency
           MyMoneyMoney rate = MyMoneyMoney::ONE;    //set the default value
 
           for (QDate it_date = q->historyStartDate().addDays(-1) ; it_date <= q->historyEndDate();) {
             //get the price for the tradingCurrency that day
             const MyMoneyPrice &price = file->price(undersecurity.id(), undersecurity.tradingCurrency(), it_date);
             if (price.isValid()) {
               rate = price.rate(undersecurity.tradingCurrency());
             }
             //value is the amount of shares multiplied by the rate of the deep currency
             m_accountListPast[acc.id()][it_date] = m_accountListPast[acc.id()][it_date] * rate;
             it_date = it_date.addDays(1);
           }
         }
       }
     }
   }
 
   /**
    * calculate the day to start forecast and sets the begin date
    * The quantity of forecast days will be counted from this date
    * Depends on the values of begin day and accounts cycle
    * The rules to calculate begin day are as follows:
    * - if beginDay is 0, begin date is current date
    * - if the day of the month set by beginDay has not passed, that will be used
    * - if adding an account cycle to beginDay, will not go past the beginDay of next month,
    *   that date will be used, otherwise it will add account cycle to beginDay until it is past current date
    * It returns the total amount of Forecast Days from current date.
    */
   int calculateBeginForecastDay()
   {
     Q_Q(MyMoneyForecast);
     int fDays = q->forecastDays();
     int beginDay = q->beginForecastDay();
     int accCycle = q->accountsCycle();
     QDate beginDate;
 
     //if 0, beginDate is current date and forecastDays remains unchanged
     if (beginDay == 0) {
       q->setBeginForecastDate(QDate::currentDate());
       return fDays;
     }
 
     //adjust if beginDay more than days of current month
     if (QDate::currentDate().daysInMonth() < beginDay)
       beginDay = QDate::currentDate().daysInMonth();
 
     //if beginDay still to come, calculate and return
     if (QDate::currentDate().day() <= beginDay) {
       beginDate = QDate(QDate::currentDate().year(), QDate::currentDate().month(), beginDay);
       fDays += QDate::currentDate().daysTo(beginDate);
       q->setBeginForecastDate(beginDate);
       return fDays;
     }
 
     //adjust beginDay for next month
     if (QDate::currentDate().addMonths(1).daysInMonth() < beginDay)
       beginDay = QDate::currentDate().addMonths(1).daysInMonth();
 
     //if beginDay of next month comes before 1 interval, use beginDay next month
     if (QDate::currentDate().addDays(accCycle) >=
         (QDate(QDate::currentDate().addMonths(1).year(), QDate::currentDate().addMonths(1).month(), 1).addDays(beginDay - 1))) {
       beginDate = QDate(QDate::currentDate().addMonths(1).year(), QDate::currentDate().addMonths(1).month(), 1).addDays(beginDay - 1);
       fDays += QDate::currentDate().daysTo(beginDate);
     } else { //add intervals to current beginDay and take the first after current date
       beginDay = ((((QDate::currentDate().day() - beginDay) / accCycle) + 1) * accCycle) + beginDay;
       beginDate = QDate::currentDate().addDays(beginDay - QDate::currentDate().day());
       fDays += QDate::currentDate().daysTo(beginDate);
     }
 
     q->setBeginForecastDate(beginDate);
     return fDays;
   }
 
   /**
    * remove accounts from the list if the accounts has no transactions in the forecast timeframe.
    * Used for scheduled-forecast method.
    */
   void purgeForecastAccountsList(QMap<QString, dailyBalances>& accountList)
   {
     m_forecastAccounts.intersect(accountList.keys().toSet());
   }
 
   MyMoneyForecast *q_ptr;
 
   /**
    * daily forecast balance of accounts
    */
   QMap<QString, dailyBalances> m_accountList;
 
   /**
    * daily past balance of accounts
    */
   QMap<QString, dailyBalances> m_accountListPast;
 
   /**
    * daily forecast trends of accounts
    */
   QMap<QString, trendBalances> m_accountTrendList;
 
   /**
    * list of forecast account ids.
    */
   QSet<QString> m_forecastAccounts;
 
   /**
    * cycle of accounts in days
    */
   int m_accountsCycle;
 
   /**
    * number of cycles to use in forecast
    */
   int m_forecastCycles;
 
   /**
    * number of days to forecast
    */
   int m_forecastDays;
 
   /**
    * date to start forecast
    */
   QDate m_beginForecastDate;
 
   /**
    * day to start forecast
    */
   int m_beginForecastDay;
 
   /**
    * forecast method
    */
   eForecastMethod m_forecastMethod;
 
   /**
    * history method
    */
   int m_historyMethod;
 
   /**
    * start date of history
    */
   QDate m_historyStartDate;
 
   /**
    * end date of history
    */
   QDate m_historyEndDate;
 
   /**
    * start date of forecast
    */
   QDate m_forecastStartDate;
 
   /**
    * end date of forecast
    */
   QDate m_forecastEndDate;
 
   /**
    * skip opening date when fetching transactions of an account
    */
   bool m_skipOpeningDate;
 
   /**
    * include accounts with no transactions in the forecast timeframe. default is false.
    */
   bool m_includeUnusedAccounts;
 
   /**
    * forecast already done
    */
   bool m_forecastDone;
 
   /**
    * include future transactions when doing a scheduled-based forecast
    */
   bool m_includeFutureTransactions;
 
   /**
    * include scheduled transactions when doing a scheduled-based forecast
    */
   bool m_includeScheduledTransactions;
 };
 
 MyMoneyForecast::MyMoneyForecast() :
   d_ptr(new MyMoneyForecastPrivate(this))
 {
   setHistoryStartDate(QDate::currentDate().addDays(-forecastCycles()*accountsCycle()));
   setHistoryEndDate(QDate::currentDate().addDays(-1));
 }
 
 MyMoneyForecast::MyMoneyForecast(const MyMoneyForecast& other) :
   d_ptr(new MyMoneyForecastPrivate(*other.d_func()))
 {
   this->d_ptr->q_ptr = this;
 }
 
 void swap(MyMoneyForecast& first, MyMoneyForecast& second)
 {
   using std::swap;
   swap(first.d_ptr, second.d_ptr);
   swap(first.d_ptr->q_ptr, second.d_ptr->q_ptr);
 }
 
 MyMoneyForecast::MyMoneyForecast(MyMoneyForecast && other) : MyMoneyForecast()
 {
   swap(*this, other);
 }
 
 MyMoneyForecast & MyMoneyForecast::operator=(MyMoneyForecast other)
 {
   swap(*this, other);
   return *this;
 }
 
 MyMoneyForecast::~MyMoneyForecast()
 {
   Q_D(MyMoneyForecast);
   delete d;
 }
 
 void MyMoneyForecast::doForecast()
 {
   Q_D(MyMoneyForecast);
   auto fDays = d->calculateBeginForecastDay();
   auto fMethod = d->forecastMethod();
   auto fAccCycle = accountsCycle();
   auto fCycles = forecastCycles();
 
   //validate settings
   if (fAccCycle < 1
       || fCycles < 1
       || fDays < 1) {
-    throw MYMONEYEXCEPTION("Illegal settings when calling doForecast. Settings must be higher than 0");
+    throw MYMONEYEXCEPTION_CSTRING("Illegal settings when calling doForecast. Settings must be higher than 0");
   }
 
   //initialize global variables
   setForecastDays(fDays);
   setForecastStartDate(QDate::currentDate().addDays(1));
   setForecastEndDate(QDate::currentDate().addDays(fDays));
   setAccountsCycle(fAccCycle);
   setForecastCycles(fCycles);
   setHistoryStartDate(forecastCycles() * accountsCycle());
   setHistoryEndDate(QDate::currentDate().addDays(-1)); //yesterday
 
   //clear all data before calculating
   d->m_accountListPast.clear();
   d->m_accountList.clear();
   d->m_accountTrendList.clear();
 
   //set forecast accounts
   d->setForecastAccountList();
 
   switch (fMethod) {
   case eForecastMethod::Scheduled:
     d->doFutureScheduledForecast();
     d->calculateScheduledDailyBalances();
     break;
   case eForecastMethod::Historic:
     d->pastTransactions();
     d->calculateHistoricDailyBalances();
     break;
   default:
     break;
   }
 
   //flag the forecast as done
   d->m_forecastDone = true;
 }
 
 bool MyMoneyForecast::isForecastAccount(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyForecast);
   if (d->m_forecastAccounts.isEmpty()) {
     d->setForecastAccountList();
   }
   return d->m_forecastAccounts.contains(acc.id());
 }
 
 QList<MyMoneyAccount> MyMoneyForecast::accountList()
 {
   auto file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accList;
   QStringList emptyStringList;
   //Get all accounts from the file and check if they are present
   file->accountList(accList, emptyStringList, false);
   QList<MyMoneyAccount>::iterator accList_t = accList.begin();
   for (; accList_t != accList.end();) {
     auto acc = *accList_t;
     if (!isForecastAccount(acc)) {
       accList_t = accList.erase(accList_t);    //remove the account
     } else {
       ++accList_t;
     }
   }
   return accList;
 }
 
 MyMoneyMoney MyMoneyForecast::calculateAccountTrend(const MyMoneyAccount& acc, int trendDays)
 {
   auto file = MyMoneyFile::instance();
   MyMoneyTransactionFilter filter;
   MyMoneyMoney netIncome;
   QDate startDate;
   QDate openingDate = acc.openingDate();
 
   //validate arguments
   if (trendDays < 1) {
-    throw MYMONEYEXCEPTION("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0");
+    throw MYMONEYEXCEPTION_CSTRING("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0");
   }
 
   //If it is a new account, we don't take into account the first day
   //because it is usually a weird one and it would mess up the trend
   if (openingDate.daysTo(QDate::currentDate()) < trendDays) {
     startDate = (acc.openingDate()).addDays(1);
   } else {
     startDate = QDate::currentDate().addDays(-trendDays);
   }
   //get all transactions for the period
   filter.setDateFilter(startDate, QDate::currentDate());
   if (acc.accountGroup() == eMyMoney::Account::Type::Income
       || acc.accountGroup() == eMyMoney::Account::Type::Expense) {
     filter.addCategory(acc.id());
   } else {
     filter.addAccount(acc.id());
   }
 
   filter.setReportAllSplits(false);
 
   //add all transactions for that account
   foreach (const auto transaction, file->transactionList(filter)) {
     foreach (const auto split, transaction.splits()) {
       if (!split.shares().isZero()) {
         if (acc.id() == split.accountId()) netIncome += split.value();
       }
     }
   }
 
   //calculate trend of the account in the past period
   MyMoneyMoney accTrend;
 
   //don't take into account the first day of the account
   if (openingDate.daysTo(QDate::currentDate()) < trendDays) {
     accTrend = netIncome / MyMoneyMoney(openingDate.daysTo(QDate::currentDate()) - 1, 1);
   } else {
     accTrend = netIncome / MyMoneyMoney(trendDays, 1);
   }
   return accTrend;
 }
 
 MyMoneyMoney MyMoneyForecast::forecastBalance(const MyMoneyAccount& acc, const QDate &forecastDate)
 {
   Q_D(MyMoneyForecast);
   dailyBalances balance;
   MyMoneyMoney MM_amount = MyMoneyMoney();
 
   //Check if acc is not a forecast account, return 0
   if (!isForecastAccount(acc)) {
     return MM_amount;
   }
 
   if (d->m_accountList.contains(acc.id())) {
     balance = d->m_accountList.value(acc.id());
   }
   if (balance.contains(forecastDate)) { //if the date is not in the forecast, it returns 0
     MM_amount = balance.value(forecastDate);
   }
   return MM_amount;
 }
 
 /**
  * Returns the forecast balance trend for account @a acc for offset @p int
  * offset is days from current date, inside forecast days.
  * Returns 0 if offset not in range of forecast days.
  */
 MyMoneyMoney MyMoneyForecast::forecastBalance(const MyMoneyAccount& acc, int offset)
 {
   QDate forecastDate = QDate::currentDate().addDays(offset);
   return forecastBalance(acc, forecastDate);
 }
 
 int MyMoneyForecast::daysToMinimumBalance(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyForecast);
   QString minimumBalance = acc.value("minBalanceAbsolute");
   MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
   dailyBalances balance;
 
   //Check if acc is not a forecast account, return -1
   if (!isForecastAccount(acc)) {
     return -1;
   }
 
   balance = d->m_accountList[acc.id()];
 
   for (QDate it_day = QDate::currentDate() ; it_day <= forecastEndDate();) {
     if (minBalance > balance[it_day]) {
       return QDate::currentDate().daysTo(it_day);
     }
     it_day = it_day.addDays(1);
   }
   return -1;
 }
 
 int MyMoneyForecast::daysToZeroBalance(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyForecast);
   dailyBalances balance;
 
   //Check if acc is not a forecast account, return -1
   if (!isForecastAccount(acc)) {
     return -2;
   }
 
   balance = d->m_accountList[acc.id()];
 
   if (acc.accountGroup() == eMyMoney::Account::Type::Asset) {
     for (QDate it_day = QDate::currentDate() ; it_day <= forecastEndDate();) {
       if (balance[it_day] < MyMoneyMoney()) {
         return QDate::currentDate().daysTo(it_day);
       }
       it_day = it_day.addDays(1);
     }
   } else if (acc.accountGroup() == eMyMoney::Account::Type::Liability) {
     for (QDate it_day = QDate::currentDate() ; it_day <= forecastEndDate();) {
       if (balance[it_day] > MyMoneyMoney()) {
         return QDate::currentDate().daysTo(it_day);
       }
       it_day = it_day.addDays(1);
     }
   }
   return -1;
 }
 
 
 MyMoneyMoney MyMoneyForecast::accountCycleVariation(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyForecast);
   MyMoneyMoney cycleVariation;
 
   if (d->forecastMethod() == eForecastMethod::Historic) {
     switch (historyMethod()) {
     case 0:
     case 1: {
       for (int t_day = 1; t_day <= accountsCycle() ; ++t_day) {
         cycleVariation += d->m_accountTrendList[acc.id()][t_day];
       }
     }
       break;
     case 2: {
       cycleVariation = d->m_accountList[acc.id()][QDate::currentDate().addDays(accountsCycle())] - d->m_accountList[acc.id()][QDate::currentDate()];
       break;
     }
     }
   }
   return cycleVariation;
 }
 
 MyMoneyMoney MyMoneyForecast::accountTotalVariation(const MyMoneyAccount& acc)
 {
   MyMoneyMoney totalVariation;
 
   totalVariation = forecastBalance(acc, forecastEndDate()) - forecastBalance(acc, QDate::currentDate());
   return totalVariation;
 }
 
 QList<QDate> MyMoneyForecast::accountMinimumBalanceDateList(const MyMoneyAccount& acc)
 {
   QList<QDate> minBalanceList;
   int daysToBeginDay;
 
   daysToBeginDay = QDate::currentDate().daysTo(beginForecastDate());
 
   for (int t_cycle = 0; ((t_cycle * accountsCycle()) + daysToBeginDay) < forecastDays() ; ++t_cycle) {
     MyMoneyMoney minBalance = forecastBalance(acc, (t_cycle * accountsCycle() + daysToBeginDay));
     QDate minDate = QDate::currentDate().addDays(t_cycle * accountsCycle() + daysToBeginDay);
     for (int t_day = 1; t_day <= accountsCycle() ; ++t_day) {
       if (minBalance > forecastBalance(acc, (t_cycle * accountsCycle()) + daysToBeginDay + t_day)) {
         minBalance = forecastBalance(acc, (t_cycle * accountsCycle()) + daysToBeginDay + t_day);
         minDate = QDate::currentDate().addDays((t_cycle * accountsCycle()) + daysToBeginDay + t_day);
       }
     }
     minBalanceList.append(minDate);
   }
   return minBalanceList;
 }
 
 QList<QDate> MyMoneyForecast::accountMaximumBalanceDateList(const MyMoneyAccount& acc)
 {
   QList<QDate> maxBalanceList;
   int daysToBeginDay;
 
   daysToBeginDay = QDate::currentDate().daysTo(beginForecastDate());
 
   for (int t_cycle = 0; ((t_cycle * accountsCycle()) + daysToBeginDay) < forecastDays() ; ++t_cycle) {
     MyMoneyMoney maxBalance = forecastBalance(acc, ((t_cycle * accountsCycle()) + daysToBeginDay));
     QDate maxDate = QDate::currentDate().addDays((t_cycle * accountsCycle()) + daysToBeginDay);
 
     for (int t_day = 0; t_day < accountsCycle() ; ++t_day) {
       if (maxBalance < forecastBalance(acc, (t_cycle * accountsCycle()) + daysToBeginDay + t_day)) {
         maxBalance = forecastBalance(acc, (t_cycle * accountsCycle()) + daysToBeginDay + t_day);
         maxDate = QDate::currentDate().addDays((t_cycle * accountsCycle()) + daysToBeginDay + t_day);
       }
     }
     maxBalanceList.append(maxDate);
   }
   return maxBalanceList;
 }
 
 MyMoneyMoney MyMoneyForecast::accountAverageBalance(const MyMoneyAccount& acc)
 {
   MyMoneyMoney totalBalance;
   for (int f_day = 1; f_day <= forecastDays() ; ++f_day) {
     totalBalance += forecastBalance(acc, f_day);
   }
   return totalBalance / MyMoneyMoney(forecastDays(), 1);
 }
 
 void MyMoneyForecast::createBudget(MyMoneyBudget& budget, QDate historyStart, QDate historyEnd, QDate budgetStart, QDate budgetEnd, const bool returnBudget)
 {
   Q_D(MyMoneyForecast);
   // clear all data except the id and name
   QString name = budget.name();
   budget = MyMoneyBudget(budget.id(), MyMoneyBudget());
   budget.setName(name);
 
   //check parameters
   if (historyStart > historyEnd ||
       budgetStart > budgetEnd ||
       budgetStart <= historyEnd) {
-    throw MYMONEYEXCEPTION("Illegal parameters when trying to create budget");
+    throw MYMONEYEXCEPTION_CSTRING("Illegal parameters when trying to create budget");
   }
 
   //get forecast method
   auto fMethod = d->forecastMethod();
 
   //set start date to 1st of month and end dates to last day of month, since we deal with full months in budget
   historyStart = QDate(historyStart.year(), historyStart.month(), 1);
   historyEnd = QDate(historyEnd.year(), historyEnd.month(), historyEnd.daysInMonth());
   budgetStart = QDate(budgetStart.year(), budgetStart.month(), 1);
   budgetEnd = QDate(budgetEnd.year(), budgetEnd.month(), budgetEnd.daysInMonth());
 
   //set forecast parameters
   setHistoryStartDate(historyStart);
   setHistoryEndDate(historyEnd);
   setForecastStartDate(budgetStart);
   setForecastEndDate(budgetEnd);
   setForecastDays(budgetStart.daysTo(budgetEnd) + 1);
   if (budgetStart.daysTo(budgetEnd) > historyStart.daysTo(historyEnd)) {         //if history period is shorter than budget, use that one as the trend length
     setAccountsCycle(historyStart.daysTo(historyEnd));       //we set the accountsCycle to the base timeframe we will use to calculate the average (eg. 180 days, 365, etc)
   } else { //if one timeframe is larger than the other, but not enough to be 1 time larger, we take the lowest value
     setAccountsCycle(budgetStart.daysTo(budgetEnd));
   }
   setForecastCycles((historyStart.daysTo(historyEnd) / accountsCycle()));
   if (forecastCycles() == 0)   //the cycles must be at least 1
     setForecastCycles(1);
 
   //do not skip opening date
   setSkipOpeningDate(false);
 
   //clear and set accounts list we are going to use. Categories, in this case
   d->m_forecastAccounts.clear();
   d->setBudgetAccountList();
 
   //calculate budget according to forecast method
   switch (fMethod) {
   case eForecastMethod::Scheduled:
     d->doFutureScheduledForecast();
     d->calculateScheduledMonthlyBalances();
     break;
   case eForecastMethod::Historic:
     d->pastTransactions(); //get all transactions for history period
     d->calculateAccountTrendList();
     d->calculateHistoricMonthlyBalances(); //add all balances of each month and put at the 1st day of each month
     break;
   default:
     break;
   }
 
   //flag the forecast as done
   d->m_forecastDone = true;
 
   //only fill the budget if it is going to be used
   if (returnBudget) {
     //setup the budget itself
     auto file = MyMoneyFile::instance();
     budget.setBudgetStart(budgetStart);
 
     //go through all the accounts and add them to budget
     for (auto it_nc = d->m_forecastAccounts.constBegin(); it_nc != d->m_forecastAccounts.constEnd(); ++it_nc) {
       auto acc = file->account(*it_nc);
 
       MyMoneyBudget::AccountGroup budgetAcc;
       budgetAcc.setId(acc.id());
       budgetAcc.setBudgetLevel(MyMoneyBudget::AccountGroup::eMonthByMonth);
 
       for (QDate f_date = forecastStartDate(); f_date <= forecastEndDate();) {
         MyMoneyBudget::PeriodGroup period;
 
         //add period to budget account
         period.setStartDate(f_date);
         period.setAmount(forecastBalance(acc, f_date));
         budgetAcc.addPeriod(f_date, period);
 
         //next month
         f_date = f_date.addMonths(1);
       }
       //add budget account to budget
       budget.setAccount(budgetAcc, acc.id());
     }
   }
 }
 int MyMoneyForecast::historyDays() const
 {
   Q_D(const MyMoneyForecast);
   return (d->m_historyStartDate.daysTo(d->m_historyEndDate) + 1);
 }
 
 void MyMoneyForecast::setAccountsCycle(int accountsCycle)
 {
   Q_D(MyMoneyForecast);
   d->m_accountsCycle = accountsCycle;
 }
 
 void MyMoneyForecast::setForecastCycles(int forecastCycles)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastCycles = forecastCycles;
 }
 
 void MyMoneyForecast::setForecastDays(int forecastDays)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastDays = forecastDays;
 }
 
 void MyMoneyForecast::setBeginForecastDate(const QDate &beginForecastDate)
 {
   Q_D(MyMoneyForecast);
   d->m_beginForecastDate = beginForecastDate;
 }
 
 void MyMoneyForecast::setBeginForecastDay(int beginDay)
 {
   Q_D(MyMoneyForecast);
   d->m_beginForecastDay = beginDay;
 }
 
 void MyMoneyForecast::setForecastMethod(int forecastMethod)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastMethod = static_cast<eForecastMethod>(forecastMethod);
 }
 
 void MyMoneyForecast::setHistoryStartDate(const QDate &historyStartDate)
 {
   Q_D(MyMoneyForecast);
   d->m_historyStartDate = historyStartDate;
 }
 
 void MyMoneyForecast::setHistoryEndDate(const QDate &historyEndDate)
 {
   Q_D(MyMoneyForecast);
   d->m_historyEndDate = historyEndDate;
 }
 
 void MyMoneyForecast::setHistoryStartDate(int daysToStartDate)
 {
   setHistoryStartDate(QDate::currentDate().addDays(-daysToStartDate));
 }
 
 void MyMoneyForecast::setHistoryEndDate(int daysToEndDate)
 {
   setHistoryEndDate(QDate::currentDate().addDays(-daysToEndDate));
 }
 
 void MyMoneyForecast::setForecastStartDate(const QDate &_startDate)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastStartDate = _startDate;
 }
 
 void MyMoneyForecast::setForecastEndDate(const QDate &_endDate)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastEndDate = _endDate;
 }
 
 void MyMoneyForecast::setSkipOpeningDate(bool _skip)
 {
   Q_D(MyMoneyForecast);
   d->m_skipOpeningDate = _skip;
 }
 
 void MyMoneyForecast::setHistoryMethod(int historyMethod)
 {
   Q_D(MyMoneyForecast);
   d->m_historyMethod = historyMethod;
 }
 
 void MyMoneyForecast::setIncludeUnusedAccounts(bool _bool)
 {
   Q_D(MyMoneyForecast);
   d->m_includeUnusedAccounts = _bool;
 }
 
 void MyMoneyForecast::setForecastDone(bool _bool)
 {
   Q_D(MyMoneyForecast);
   d->m_forecastDone = _bool;
 }
 
 void MyMoneyForecast::setIncludeFutureTransactions(bool _bool)
 {
   Q_D(MyMoneyForecast);
   d->m_includeFutureTransactions = _bool;
 }
 
 void MyMoneyForecast::setIncludeScheduledTransactions(bool _bool)
 {
   Q_D(MyMoneyForecast);
   d->m_includeScheduledTransactions = _bool;
 }
 
 int MyMoneyForecast::accountsCycle() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_accountsCycle;
 }
 
 int MyMoneyForecast::forecastCycles() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_forecastCycles;
 }
 
 int MyMoneyForecast::forecastDays() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_forecastDays;
 }
 
 QDate MyMoneyForecast::beginForecastDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_beginForecastDate;
 }
 
 int MyMoneyForecast::beginForecastDay() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_beginForecastDay;
 }
 
 QDate MyMoneyForecast::historyStartDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_historyStartDate;
 }
 
 QDate MyMoneyForecast::historyEndDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_historyEndDate;
 }
 
 QDate MyMoneyForecast::forecastStartDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_forecastStartDate;
 }
 
 QDate MyMoneyForecast::forecastEndDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_forecastEndDate;
 }
 
 bool MyMoneyForecast::skipOpeningDate() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_skipOpeningDate;
 }
 
 int MyMoneyForecast::historyMethod() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_historyMethod;
 }
 
 bool MyMoneyForecast::isIncludingUnusedAccounts() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_includeUnusedAccounts;
 }
 
 bool MyMoneyForecast::isForecastDone() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_forecastDone;
 }
 
 bool MyMoneyForecast::isIncludingFutureTransactions() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_includeFutureTransactions;
 }
 
 bool MyMoneyForecast::isIncludingScheduledTransactions() const
 {
   Q_D(const MyMoneyForecast);
   return d->m_includeScheduledTransactions;
 }
 
 void MyMoneyForecast::calculateAutoLoan(const MyMoneySchedule& schedule, MyMoneyTransaction& transaction, const QMap<QString, MyMoneyMoney>& balances)
 {
   if (schedule.type() == eMyMoney::Schedule::Type::LoanPayment) {
 
     //get amortization and interest autoCalc splits
     MyMoneySplit amortizationSplit = transaction.amortizationSplit();
     MyMoneySplit interestSplit = transaction.interestSplit();
     const bool interestSplitValid = !interestSplit.id().isEmpty();
 
     if (!amortizationSplit.id().isEmpty()) {
       MyMoneyAccountLoan acc(MyMoneyFile::instance()->account(amortizationSplit.accountId()));
       MyMoneyFinancialCalculator calc;
       QDate dueDate;
 
       // FIXME: setup dueDate according to when the interest should be calculated
       // current implementation: take the date of the next payment according to
       // the schedule. If the calculation is based on the payment reception, and
       // the payment is overdue then take the current date
       dueDate = schedule.nextDueDate();
       if (acc.interestCalculation() == MyMoneyAccountLoan::paymentReceived) {
         if (dueDate < QDate::currentDate())
           dueDate = QDate::currentDate();
       }
 
       // we need to calculate the balance at the time the payment is due
 
       MyMoneyMoney balance;
       if (balances.count() == 0)
         balance = MyMoneyFile::instance()->balance(acc.id(), dueDate.addDays(-1));
       else
         balance = balances[acc.id()];
 
       // FIXME: for now, we only support interest calculation at the end of the period
       calc.setBep();
       // FIXME: for now, we only support periodic compounding
       calc.setDisc();
 
       calc.setPF(MyMoneySchedule::eventsPerYear(schedule.occurrence()));
       eMyMoney::Schedule::Occurrence compoundingOccurrence = static_cast<eMyMoney::Schedule::Occurrence>(acc.interestCompounding());
       if (compoundingOccurrence == eMyMoney::Schedule::Occurrence::Any)
         compoundingOccurrence = schedule.occurrence();
 
       calc.setCF(MyMoneySchedule::eventsPerYear(compoundingOccurrence));
 
       calc.setPv(balance.toDouble());
       calc.setIr(acc.interestRate(dueDate).abs().toDouble());
       calc.setPmt(acc.periodicPayment().toDouble());
 
       MyMoneyMoney interest(calc.interestDue(), 100), amortization;
       interest = interest.abs();    // make sure it's positive for now
       amortization = acc.periodicPayment() - interest;
 
       if (acc.accountType() == eMyMoney::Account::Type::AssetLoan) {
         interest = -interest;
         amortization = -amortization;
       }
 
       amortizationSplit.setShares(amortization);
       if (interestSplitValid)
         interestSplit.setShares(interest);
 
       // FIXME: for now we only assume loans to be in the currency of the transaction
       amortizationSplit.setValue(amortization);
       if (interestSplitValid)
         interestSplit.setValue(interest);
 
       transaction.modifySplit(amortizationSplit);
       if (interestSplitValid)
         transaction.modifySplit(interestSplit);
     }
   }
 }
 
 QList<MyMoneyAccount> MyMoneyForecast::forecastAccountList()
 {
   auto file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accList;
   //Get all accounts from the file and check if they are of the right type to calculate forecast
   file->accountList(accList);
   QList<MyMoneyAccount>::iterator accList_t = accList.begin();
   for (; accList_t != accList.end();) {
     auto acc = *accList_t;
     if (acc.isClosed()            //check the account is not closed
         || (!acc.isAssetLiability())) {
       //|| (acc.accountType() == eMyMoney::Account::Type::Investment) ) {//check that it is not an Investment account and only include Stock accounts
       //remove the account if it is not of the correct type
       accList_t = accList.erase(accList_t);
     } else {
       ++accList_t;
     }
   }
   return accList;
 }
diff --git a/kmymoney/mymoney/mymoneyinstitution.cpp b/kmymoney/mymoney/mymoneyinstitution.cpp
index c86f1bb81..15c79f3df 100644
--- a/kmymoney/mymoney/mymoneyinstitution.cpp
+++ b/kmymoney/mymoney/mymoneyinstitution.cpp
@@ -1,325 +1,323 @@
 /***************************************************************************
                           mymoneyinstitution.cpp
                           -------------------
     copyright            : (C) 2001 by Michael Edwardes <mte@users.sourceforge.net>
                                2002-2005 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyinstitution.h"
 #include "mymoneyinstitution_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPixmap>
 #include <QPixmapCache>
 #include <QIcon>
 #include <QDomDocument>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "icons.h"
 #include <mymoneyexception.h>
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 using namespace Icons;
 
 MyMoneyInstitution::MyMoneyInstitution() :
   MyMoneyObject(*new MyMoneyInstitutionPrivate),
   MyMoneyKeyValueContainer()
 {
 }
 
 MyMoneyInstitution::MyMoneyInstitution(const QString& name,
                                        const QString& town,
                                        const QString& street,
                                        const QString& postcode,
                                        const QString& telephone,
                                        const QString& manager,
                                        const QString& sortcode) :
   MyMoneyObject(*new MyMoneyInstitutionPrivate),
   MyMoneyKeyValueContainer()
 {
   Q_D(MyMoneyInstitution);
   clearId();
   d->m_name = name;
   d->m_town = town;
   d->m_street = street;
   d->m_postcode = postcode;
   d->m_telephone = telephone;
   d->m_manager = manager;
   d->m_sortcode = sortcode;
 }
 
 MyMoneyInstitution::MyMoneyInstitution(const QDomElement& node) :
   MyMoneyObject(*new MyMoneyInstitutionPrivate, node),
   MyMoneyKeyValueContainer(node.elementsByTagName(nodeNames[nnKeyValuePairs]).item(0).toElement())
 {
   if (nodeNames[nnInstitution] != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not INSTITUTION");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not INSTITUTION");
 
   Q_D(MyMoneyInstitution);
   d->m_sortcode = node.attribute(d->getAttrName(Institution::Attribute::SortCode));
   d->m_name = node.attribute(d->getAttrName(Institution::Attribute::Name));
   d->m_manager = node.attribute(d->getAttrName(Institution::Attribute::Manager));
 
   QDomNodeList nodeList = node.elementsByTagName(d->getElName(Institution::Element::Address));
-  if (nodeList.count() == 0) {
-    QString msg = QString("No ADDRESS in institution %1").arg(d->m_name);
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (nodeList.isEmpty())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("No ADDRESS in institution %1").arg(d->m_name));
 
   QDomElement addrNode = nodeList.item(0).toElement();
   d->m_street = addrNode.attribute(d->getAttrName(Institution::Attribute::Street));
   d->m_town = addrNode.attribute(d->getAttrName(Institution::Attribute::City));
   d->m_postcode = addrNode.attribute(d->getAttrName(Institution::Attribute::Zip));
   d->m_telephone = addrNode.attribute(d->getAttrName(Institution::Attribute::Telephone));
 
   d->m_accountList.clear();
 
   nodeList = node.elementsByTagName(d->getElName(Institution::Element::AccountIDS));
   if (nodeList.count() > 0) {
     nodeList = nodeList.item(0).toElement().elementsByTagName(d->getElName(Institution::Element::AccountID));
     for (int i = 0; i < nodeList.count(); ++i) {
       d->m_accountList << nodeList.item(i).toElement().attribute(d->getAttrName(Institution::Attribute::ID));
     }
   }
 }
 
 MyMoneyInstitution::MyMoneyInstitution(const MyMoneyInstitution& other) :
   MyMoneyObject(*new MyMoneyInstitutionPrivate(*other.d_func()), other.id()),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneyInstitution::MyMoneyInstitution(const QString& id, const MyMoneyInstitution& other) :
     MyMoneyObject(*new MyMoneyInstitutionPrivate(*other.d_func()), id),
     MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneyInstitution::~MyMoneyInstitution()
 {
 }
 
 QString MyMoneyInstitution::manager() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_manager;
 }
 
 void MyMoneyInstitution::setManager(const QString& manager)
 {
   Q_D(MyMoneyInstitution);
   d->m_manager = manager;
 }
 
 QString MyMoneyInstitution::name() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_name;
 }
 
 void MyMoneyInstitution::setName(const QString& name)
 {
   Q_D(MyMoneyInstitution);
   d->m_name = name;
 }
 
 QString MyMoneyInstitution::postcode() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_postcode;
 }
 
 void MyMoneyInstitution::setPostcode(const QString& code)
 {
   Q_D(MyMoneyInstitution);
   d->m_postcode = code;
 }
 
 QString MyMoneyInstitution::street() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_street;
 }
 
 void MyMoneyInstitution::setStreet(const QString& street)
 {
   Q_D(MyMoneyInstitution);
   d->m_street = street;
 }
 
 QString MyMoneyInstitution::telephone() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_telephone;
 }
 
 void MyMoneyInstitution::setTelephone(const QString& tel)
 {
   Q_D(MyMoneyInstitution);
   d->m_telephone = tel;
 }
 
 QString MyMoneyInstitution::town() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_town;
 }
 
 void MyMoneyInstitution::setTown(const QString& town)
 {
   Q_D(MyMoneyInstitution);
   d->m_town = town;
 }
 
 QString MyMoneyInstitution::city() const
 {
   return town();
 }
 
 void MyMoneyInstitution::setCity(const QString& town)
 {
   setTown(town);
 }
 
 QString MyMoneyInstitution::sortcode() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_sortcode;
 }
 
 void MyMoneyInstitution::setSortcode(const QString& code)
 {
   Q_D(MyMoneyInstitution);
   d->m_sortcode = code;
 }
 
 void MyMoneyInstitution::addAccountId(const QString& account)
 {
   Q_D(MyMoneyInstitution);
   // only add this account if it is not yet presently in the list
   if (d->m_accountList.contains(account) == 0)
     d->m_accountList.append(account);
 }
 
 QString MyMoneyInstitution::removeAccountId(const QString& account)
 {
   Q_D(MyMoneyInstitution);
   QString rc;
 
   auto pos = d->m_accountList.indexOf(account);
   if (pos != -1) {
     d->m_accountList.removeAt(pos);
     rc = account;
   }
   return rc;
 }
 
 QStringList MyMoneyInstitution::accountList() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_accountList;
 }
 
 /**
   * This method returns the number of accounts known to
   * this institution
   * @return number of accounts
   */
 unsigned int MyMoneyInstitution::accountCount() const
 {
   Q_D(const MyMoneyInstitution);
   return d->m_accountList.count();
 }
 
 bool MyMoneyInstitution::operator < (const MyMoneyInstitution& right) const
 {
   Q_D(const MyMoneyInstitution);
   auto d2 = static_cast<const MyMoneyInstitutionPrivate *>(right.d_func());
   return d->m_name < d2->m_name;
 }
 
 bool MyMoneyInstitution::operator == (const MyMoneyInstitution& right) const
 {
   Q_D(const MyMoneyInstitution);
   auto d2 = static_cast<const MyMoneyInstitutionPrivate *>(right.d_func());
   if (MyMoneyObject::operator==(right) &&
       ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)) &&
       ((d->m_town.length() == 0 && d2->m_town.length() == 0) || (d->m_town == d2->m_town)) &&
       ((d->m_street.length() == 0 && d2->m_street.length() == 0) || (d->m_street == d2->m_street)) &&
       ((d->m_postcode.length() == 0 && d2->m_postcode.length() == 0) || (d->m_postcode == d2->m_postcode)) &&
       ((d->m_telephone.length() == 0 && d2->m_telephone.length() == 0) || (d->m_telephone == d2->m_telephone)) &&
       ((d->m_sortcode.length() == 0 && d2->m_sortcode.length() == 0) || (d->m_sortcode == d2->m_sortcode)) &&
       ((d->m_manager.length() == 0 && d2->m_manager.length() == 0) || (d->m_manager == d2->m_manager)) &&
       (d->m_accountList == d2->m_accountList)) {
     return true;
   } else
     return false;
 }
 
 void MyMoneyInstitution::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   Q_D(const MyMoneyInstitution);
   auto el = document.createElement(nodeNames[nnInstitution]);
 
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Institution::Attribute::Name), d->m_name);
   el.setAttribute(d->getAttrName(Institution::Attribute::Manager), d->m_manager);
   el.setAttribute(d->getAttrName(Institution::Attribute::SortCode), d->m_sortcode);
 
   auto address = document.createElement(d->getElName(Institution::Element::Address));
   address.setAttribute(d->getAttrName(Institution::Attribute::Street), d->m_street);
   address.setAttribute(d->getAttrName(Institution::Attribute::City), d->m_town);
   address.setAttribute(d->getAttrName(Institution::Attribute::Zip), d->m_postcode);
   address.setAttribute(d->getAttrName(Institution::Attribute::Telephone), d->m_telephone);
   el.appendChild(address);
 
   auto accounts = document.createElement(d->getElName(Institution::Element::AccountIDS));
   foreach (const auto accountID, accountList()) {
     auto temp = document.createElement(d->getElName(Institution::Element::AccountID));
     temp.setAttribute(d->getAttrName(Institution::Attribute::ID), accountID);
     accounts.appendChild(temp);
   }
   el.appendChild(accounts);
 
   //Add in Key-Value Pairs for institutions.
   MyMoneyKeyValueContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneyInstitution::hasReferenceTo(const QString& /* id */) const
 {
   return false;
 }
 
 QPixmap MyMoneyInstitution::pixmap(const int size)
 {
   QPixmap pxIcon;
   auto kyIcon = QString::fromLatin1("view_institution%1").arg(QString::number(size));
   if (!QPixmapCache::find(kyIcon, pxIcon)) {
     pxIcon = Icons::get(Icon::ViewInstitutions).pixmap(size);
     QPixmapCache::insert(kyIcon, pxIcon);
   }
   return pxIcon;
 }
diff --git a/kmymoney/mymoney/mymoneykeyvaluecontainer.cpp b/kmymoney/mymoney/mymoneykeyvaluecontainer.cpp
index edd35ec99..6f99417cb 100644
--- a/kmymoney/mymoney/mymoneykeyvaluecontainer.cpp
+++ b/kmymoney/mymoney/mymoneykeyvaluecontainer.cpp
@@ -1,168 +1,168 @@
 /***************************************************************************
                           mymoneykeyvaluecontainer.cpp
                              -------------------
     begin                : Sun Nov 10 2002
     copyright            : (C) 2002-2005 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneykeyvaluecontainer.h"
 #include "mymoneykeyvaluecontainer_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDomDocument>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 
 Q_GLOBAL_STATIC(QString, nullString)
 
 MyMoneyKeyValueContainer::MyMoneyKeyValueContainer() :
   d_ptr(new MyMoneyKeyValueContainerPrivate)
 {
 }
 
 MyMoneyKeyValueContainer::MyMoneyKeyValueContainer(const QDomElement& node) :
   d_ptr(new MyMoneyKeyValueContainerPrivate)
 {
   Q_D(MyMoneyKeyValueContainer);
   if (!node.isNull()) {
     if (nodeNames[nnKeyValuePairs] != node.tagName())
-      throw MYMONEYEXCEPTION("Node was not KEYVALUEPAIRS");
+      throw MYMONEYEXCEPTION_CSTRING("Node was not KEYVALUEPAIRS");
 
     d->m_kvp.clear();
 
     QDomNodeList nodeList = node.elementsByTagName(d->getElName(Element::Pair));
     for (int i = 0; i < nodeList.count(); ++i) {
       const QDomElement& el(nodeList.item(i).toElement());
       d->m_kvp[el.attribute(d->getAttrName(Attribute::Key))] = el.attribute(d->getAttrName(Attribute::Value));
     }
   }
 }
 
 MyMoneyKeyValueContainer::MyMoneyKeyValueContainer(const MyMoneyKeyValueContainer& other) :
   d_ptr(new MyMoneyKeyValueContainerPrivate(*other.d_func()))
 {
 }
 
 MyMoneyKeyValueContainer::~MyMoneyKeyValueContainer()
 {
   Q_D(MyMoneyKeyValueContainer);
   delete d;
 }
 
 QString MyMoneyKeyValueContainer::value(const QString& key) const
 {
   Q_D(const MyMoneyKeyValueContainer);
   QMap<QString, QString>::ConstIterator it;
 
   it = d->m_kvp.find(key);
   if (it != d->m_kvp.end())
     return (*it);
   return *nullString;
 }
 
 void MyMoneyKeyValueContainer::setValue(const QString& key, const QString& value)
 {
   Q_D(MyMoneyKeyValueContainer);
   d->m_kvp[key] = value;
 }
 
 QMap<QString, QString> MyMoneyKeyValueContainer::pairs() const
 {
   Q_D(const MyMoneyKeyValueContainer);
   return d->m_kvp;
 }
 
 void MyMoneyKeyValueContainer::setPairs(const QMap<QString, QString>& list)
 {
   Q_D(MyMoneyKeyValueContainer);
   d->m_kvp = list;
 }
 
 void MyMoneyKeyValueContainer::deletePair(const QString& key)
 {
   Q_D(MyMoneyKeyValueContainer);
   QMap<QString, QString>::Iterator it;
 
   it = d->m_kvp.find(key);
   if (it != d->m_kvp.end())
     d->m_kvp.erase(it);
 }
 
 void MyMoneyKeyValueContainer::clear()
 {
   Q_D(MyMoneyKeyValueContainer);
   d->m_kvp.clear();
 }
 
 bool MyMoneyKeyValueContainer::operator == (const MyMoneyKeyValueContainer& right) const
 {
   Q_D(const MyMoneyKeyValueContainer);
   QMap<QString, QString>::ConstIterator it_a, it_b;
 
   auto d2 = static_cast<const MyMoneyKeyValueContainerPrivate *>(right.d_func());
   it_a = d->m_kvp.begin();
   it_b = d2->m_kvp.begin();
 
   while (it_a != d->m_kvp.end() && it_b != d2->m_kvp.end()) {
     if (it_a.key() != it_b.key()
         || (((*it_a).length() != 0 || (*it_b).length() != 0) && *it_a != *it_b))
       return false;
     ++it_a;
     ++it_b;
   }
 
   return (it_a == d->m_kvp.end() && it_b == d2->m_kvp.end());
 }
 
 
 QString MyMoneyKeyValueContainer::operator[](const QString& k) const
 {
   return value(k);
 }
 
 QString& MyMoneyKeyValueContainer::operator[](const QString& k)
 {
   Q_D(MyMoneyKeyValueContainer);
   return d->m_kvp[k];
 }
 
 void MyMoneyKeyValueContainer::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   Q_D(const MyMoneyKeyValueContainer);
   if (d->m_kvp.count() != 0) {
     QDomElement el = document.createElement(nodeNames[nnKeyValuePairs]);
 
     QMap<QString, QString>::ConstIterator it;
     for (it = d->m_kvp.begin(); it != d->m_kvp.end(); ++it) {
       QDomElement pair = document.createElement(d->getElName(Element::Pair));
       pair.setAttribute(d->getAttrName(Attribute::Key), it.key());
       pair.setAttribute(d->getAttrName(Attribute::Value), it.value());
       el.appendChild(pair);
     }
 
     parent.appendChild(el);
   }
 }
diff --git a/kmymoney/mymoney/mymoneymoney.cpp b/kmymoney/mymoney/mymoneymoney.cpp
index 90dc7c8ef..a2ac1df08 100644
--- a/kmymoney/mymoney/mymoneymoney.cpp
+++ b/kmymoney/mymoney/mymoneymoney.cpp
@@ -1,421 +1,421 @@
 /***************************************************************************
                           mymoneymymoney.cpp  -  description
                              -------------------
     begin      : Thu Feb 21 2002
     copyright  : (C) 2000-2002 by Michael Edwardes <mte@users.sourceforge.net>
                  (C) 2011 by Carlos Eduardo da Silva <kaduardo@gmail.com>
                  (C) 2001-2017 by Thomas Baumgart <tbaumgart@kde.org>
                  (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 // make sure, that this is defined before we even include any other header file
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS         // force definition of min and max values
 #endif
 
 #include "mymoneymoney.h"
 
 #include <stdint.h>
 #include <gmpxx.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 const MyMoneyMoney MyMoneyMoney::ONE = MyMoneyMoney(1, 1);
 const MyMoneyMoney MyMoneyMoney::MINUS_ONE = MyMoneyMoney(-1, 1);
 namespace eMyMoney
 {
   namespace Money {
 
     enum fileVersionE : int {
       FILE_4_BYTE_VALUE = 0,
       FILE_8_BYTE_VALUE
     };
 
     QChar _thousandSeparator = QLatin1Char(',');
     QChar _decimalSeparator = QLatin1Char('.');
     eMyMoney::Money::signPosition _negativeMonetarySignPosition = BeforeQuantityMoney;
     eMyMoney::Money::signPosition _positiveMonetarySignPosition = BeforeQuantityMoney;
     bool _negativePrefixCurrencySymbol = false;
     bool _positivePrefixCurrencySymbol = false;
     eMyMoney::Money::fileVersionE _fileVersion = fileVersionE::FILE_4_BYTE_VALUE;
   }
 }
 
 //eMyMoney::Money::_thousandSeparator = QLatin1Char(',');
 //eMyMoney::Money::_decimalSeparator = QLatin1Char('.');
 //eMyMoney::Money::signPosition eMyMoney::Money::_negativeMonetarySignPosition = BeforeQuantityMoney;
 //eMyMoney::Money::signPosition eMyMoney::Money::_positiveMonetarySignPosition = BeforeQuantityMoney;
 //bool eMyMoney::Money::_negativePrefixCurrencySymbol = false;
 //bool eMyMoney::Money::_positivePrefixCurrencySymbol = false;
 
 //MyMoneyMoney::fileVersionE eMyMoney::Money::_fileVersion = MyMoneyMoney::FILE_4_BYTE_VALUE;
 
 MyMoneyMoney MyMoneyMoney::maxValue = MyMoneyMoney(INT64_MAX, 100);
 MyMoneyMoney MyMoneyMoney::minValue = MyMoneyMoney(INT64_MIN, 100);
 MyMoneyMoney MyMoneyMoney::autoCalc = MyMoneyMoney(INT64_MIN + 1, 100);
 
 void MyMoneyMoney::setNegativePrefixCurrencySymbol(const bool flag)
 {
   eMyMoney::Money::_negativePrefixCurrencySymbol = flag;
 }
 
 void MyMoneyMoney::setPositivePrefixCurrencySymbol(const bool flag)
 {
   eMyMoney::Money::_positivePrefixCurrencySymbol = flag;
 }
 
 void MyMoneyMoney::setNegativeMonetarySignPosition(const eMyMoney::Money::signPosition pos)
 {
   eMyMoney::Money::_negativeMonetarySignPosition = pos;
 }
 
 eMyMoney::Money::signPosition MyMoneyMoney::negativeMonetarySignPosition()
 {
   return eMyMoney::Money::_negativeMonetarySignPosition;
 }
 
 void MyMoneyMoney::setPositiveMonetarySignPosition(const eMyMoney::Money::signPosition pos)
 {
   eMyMoney::Money::_positiveMonetarySignPosition = pos;
 }
 
 eMyMoney::Money::signPosition MyMoneyMoney::positiveMonetarySignPosition()
 {
   return eMyMoney::Money::_positiveMonetarySignPosition;
 }
 
 void MyMoneyMoney::setThousandSeparator(const QChar &separator)
 {
   if (separator != QLatin1Char(' '))
     eMyMoney::Money::_thousandSeparator = separator;
   else
     eMyMoney::Money::_thousandSeparator = 0;
 }
 
 const QChar MyMoneyMoney::thousandSeparator()
 {
   return eMyMoney::Money::_thousandSeparator;
 }
 
 void MyMoneyMoney::setDecimalSeparator(const QChar &separator)
 {
   if (separator != QLatin1Char(' '))
     eMyMoney::Money::_decimalSeparator = separator;
   else
     eMyMoney::Money::_decimalSeparator = 0;
 }
 
 const QChar MyMoneyMoney::decimalSeparator()
 {
   return eMyMoney::Money::_decimalSeparator;
 }
 
 MyMoneyMoney::MyMoneyMoney(const QString& pszAmount)
     : AlkValue(pszAmount, eMyMoney::Money::_decimalSeparator)
 {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: MyMoneyMoney
 //   Purpose: Constructor - constructs object from an amount in a signed64 value
 //   Returns: None
 //    Throws: Nothing.
 // Arguments: Amount - signed 64 object containing amount
 //            denom  - denominator of the object
 //
 ////////////////////////////////////////////////////////////////////////////////
 MyMoneyMoney::MyMoneyMoney(signed64 Amount, const signed64 denom)
 {
   if (!denom)
-    throw MYMONEYEXCEPTION("Denominator 0 not allowed!");
+    throw MYMONEYEXCEPTION_CSTRING("Denominator 0 not allowed!");
 
   *this = AlkValue(QString::fromLatin1("%1/%2").arg(Amount).arg(denom), eMyMoney::Money::_decimalSeparator);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: MyMoneyMoney
 //   Purpose: Constructor - constructs object from an amount in a integer value
 //   Returns: None
 //    Throws: Nothing.
 // Arguments: iAmount - integer object containing amount
 //            denom   - denominator of the object
 //
 ////////////////////////////////////////////////////////////////////////////////
 MyMoneyMoney::MyMoneyMoney(const int iAmount, const signed64 denom)
 {
   if (!denom)
-    throw MYMONEYEXCEPTION("Denominator 0 not allowed!");
+    throw MYMONEYEXCEPTION_CSTRING("Denominator 0 not allowed!");
   *this = AlkValue(iAmount, denom);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: MyMoneyMoney
 //   Purpose: Constructor - constructs object from an amount in a long integer value
 //   Returns: None
 //    Throws: Nothing.
 // Arguments: iAmount - integer object containing amount
 //            denom   - denominator of the object
 //
 ////////////////////////////////////////////////////////////////////////////////
 MyMoneyMoney::MyMoneyMoney(const long int iAmount, const signed64 denom)
 {
   if (!denom)
-    throw MYMONEYEXCEPTION("Denominator 0 not allowed!");
+    throw MYMONEYEXCEPTION_CSTRING("Denominator 0 not allowed!");
   *this = AlkValue(QString::fromLatin1("%1/%2").arg(iAmount).arg(denom), eMyMoney::Money::_decimalSeparator);
 }
 
 
 MyMoneyMoney::~MyMoneyMoney()
 {
 }
 
 MyMoneyMoney MyMoneyMoney::abs() const
 {
   return static_cast<const MyMoneyMoney>(AlkValue::abs());
 }
 
 QString MyMoneyMoney::formatMoney(int denom, bool showThousandSeparator) const
 {
   return formatMoney(QString(), denomToPrec(denom), showThousandSeparator);
 }
 
 QString MyMoneyMoney::formatMoney(const QString& currency, const int prec, bool showThousandSeparator) const
 {
   QString res;
   QString tmpCurrency = currency;
   int tmpPrec = prec;
   mpz_class denom = 1;
   mpz_class value;
 
   // if prec == -1 we want the maximum possible but w/o trailing zeroes
   if (tmpPrec > -1) {
     while (tmpPrec--) {
       denom *= 10;
     }
   } else {
     // fix it to a max of 9 digits on the right side for now
     denom = 1000000000;
   }
 
   // as long as AlkValue::convertDenominator() does not take an
   // mpz_class as the denominator, we need to use a signed int
   // and limit the precision to 9 digits (the max we can
   // present with 31 bits
 #if 1
   signed int denominator;
   if (mpz_fits_sint_p(denom.get_mpz_t())) {
     denominator = mpz_get_si(denom.get_mpz_t());
   } else {
     denominator = 1000000000;
   }
   value = static_cast<const MyMoneyMoney>(convertDenominator(denominator)).valueRef().get_num();
 #else
   value = static_cast<const MyMoneyMoney>(convertDenominator(denom)).valueRef().get_num();
 #endif
 
   // Once we really support multiple currencies then this method will
   // be much better than using KLocale::global()->formatMoney.
   bool bNegative = false;
   mpz_class left = value / static_cast<MyMoneyMoney>(convertDenominator(denominator)).valueRef().get_den();
   mpz_class right = mpz_class((valueRef() - mpq_class(left)) * denom);
 
   if (right < 0) {
     right = -right;
     bNegative = true;
   }
   if (left < 0) {
     left = -left;
     bNegative = true;
   }
 
   // convert the integer (left) part to a string
   res.append(left.get_str().c_str());
 
   // if requested, insert thousand separators every three digits
   if (showThousandSeparator) {
     int pos = res.length();
     while ((0 < (pos -= 3)) && thousandSeparator() != 0)
       res.insert(pos, thousandSeparator());
   }
 
   // take care of the fractional part
   if (prec > 0 || (prec == -1 && right != 0)) {
     if (decimalSeparator() != 0)
       res += decimalSeparator();
 
     auto rs  = QString::fromLatin1("%1").arg(right.get_str().c_str());
     if (prec != -1)
       rs = rs.rightJustified(prec, QLatin1Char('0'), true);
     else {
       rs = rs.rightJustified(9, QLatin1Char('0'), true);
       // no trailing zeroes or decimal separators
       while (rs.endsWith(QLatin1Char('0')))
         rs.truncate(rs.length() - 1);
       while (rs.endsWith(decimalSeparator()))
         rs.truncate(rs.length() - 1);
     }
     res += rs;
   }
 
   eMyMoney::Money::signPosition signpos = bNegative ? eMyMoney::Money::_negativeMonetarySignPosition : eMyMoney::Money::_positiveMonetarySignPosition;
   auto sign = bNegative ? QString::fromLatin1("-") : QString();
 
   switch (signpos) {
     case eMyMoney::Money::ParensAround:
       res.prepend(QLatin1Char('('));
       res.append(QLatin1Char(')'));
       break;
     case eMyMoney::Money::BeforeQuantityMoney:
       res.prepend(sign);
       break;
     case eMyMoney::Money::AfterQuantityMoney:
       res.append(sign);
       break;
     case eMyMoney::Money::BeforeMoney:
       tmpCurrency.prepend(sign);
       break;
     case eMyMoney::Money::AfterMoney:
       tmpCurrency.append(sign);
       break;
   }
   if (!tmpCurrency.isEmpty()) {
     if (bNegative ? eMyMoney::Money::_negativePrefixCurrencySymbol : eMyMoney::Money::_positivePrefixCurrencySymbol) {
       res.prepend(QLatin1Char(' '));
       res.prepend(tmpCurrency);
     } else {
       res.append(QLatin1Char(' '));
       res.append(tmpCurrency);
     }
   }
 
   return res;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: operator+
 //   Purpose: Addition operator - adds the input amount to the object
 //   Returns: The current object
 //    Throws: Nothing.
 // Arguments: b - MyMoneyMoney object to be added
 //
 ////////////////////////////////////////////////////////////////////////////////
 const MyMoneyMoney MyMoneyMoney::operator+(const MyMoneyMoney& _b) const
 {
   return static_cast<const MyMoneyMoney>(AlkValue::operator+(_b));
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: operator-
 //   Purpose: Addition operator - subtracts the input amount from the object
 //   Returns: The current object
 //    Throws: Nothing.
 // Arguments: AmountInPence - MyMoneyMoney object to be subtracted
 //
 ////////////////////////////////////////////////////////////////////////////////
 const MyMoneyMoney MyMoneyMoney::operator-(const MyMoneyMoney& _b) const
 {
   return static_cast<const MyMoneyMoney>(AlkValue::operator-(_b));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: operator*
 //   Purpose: Multiplication operator - multiplies the input amount to the object
 //   Returns: The current object
 //    Throws: Nothing.
 // Arguments: b - MyMoneyMoney object to be multiplied
 //
 ////////////////////////////////////////////////////////////////////////////////
 const MyMoneyMoney MyMoneyMoney::operator*(const MyMoneyMoney& _b) const
 {
   return static_cast<const MyMoneyMoney>(AlkValue::operator*(_b));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //      Name: operator/
 //   Purpose: Division operator - divides the object by the input amount
 //   Returns: The current object
 //    Throws: Nothing.
 // Arguments: b - MyMoneyMoney object to be used as dividend
 //
 ////////////////////////////////////////////////////////////////////////////////
 const MyMoneyMoney MyMoneyMoney::operator/(const MyMoneyMoney& _b) const
 {
   return static_cast<const MyMoneyMoney>(AlkValue::operator/(_b));
 }
 
 bool MyMoneyMoney::isNegative() const
 {
   return (valueRef() < 0) ? true : false;
 }
 
 bool MyMoneyMoney::isPositive() const
 {
   return (valueRef() > 0) ? true : false;
 }
 
 bool MyMoneyMoney::isZero() const
 {
   return valueRef() == 0;
 }
 
 bool MyMoneyMoney::isAutoCalc() const
 {
   return (*this == autoCalc);
 }
 
 MyMoneyMoney MyMoneyMoney::convert(const signed64 _denom, const AlkValue::RoundingMethod how) const
 {
   return static_cast<const MyMoneyMoney>(convertDenominator(_denom, how));
 }
 
 MyMoneyMoney MyMoneyMoney::reduce() const
 {
   MyMoneyMoney out(*this);
   out.canonicalize();
   return out;
 }
 
 signed64 MyMoneyMoney::precToDenom(int prec)
 {
   signed64 denom = 1;
 
   while (prec--)
     denom *= 10;
 
   return denom;
 }
 
 double MyMoneyMoney::toDouble() const
 {
   return valueRef().get_d();
 }
 
 int MyMoneyMoney::denomToPrec(signed64 fract)
 {
   int rc = 0;
   while (fract > 1) {
     rc++;
     fract /= 10;
   }
   return rc;
 }
 
diff --git a/kmymoney/mymoney/mymoneyobject.cpp b/kmymoney/mymoney/mymoneyobject.cpp
index 1ed671e6c..c9d4d4126 100644
--- a/kmymoney/mymoney/mymoneyobject.cpp
+++ b/kmymoney/mymoney/mymoneyobject.cpp
@@ -1,75 +1,75 @@
 /***************************************************************************
                           mymoneyobject.cpp
                           -------------------
     copyright            : (C) 2005 by Thomas Baumagrt
     email                : ipwizard@users.sourceforge.net
                            (C) 2017, 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyobject.h"
 #include "mymoneyobject_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 
 MyMoneyObject::MyMoneyObject(MyMoneyObjectPrivate &dd) :
   d_ptr(&dd)
 {
 }
 
 MyMoneyObject::MyMoneyObject(MyMoneyObjectPrivate &dd,
                              const QString& id) :
   d_ptr(&dd)
 {
   Q_D(MyMoneyObject);
   d->m_id = id;
 }
 
 MyMoneyObject::MyMoneyObject(MyMoneyObjectPrivate &dd,
                              const QDomElement& node,
                              bool forceId) :
   d_ptr(&dd)
 {
   Q_D(MyMoneyObject);
   d->m_id = node.attribute(QStringLiteral("id"));
   if (d->m_id.length() == 0 && forceId)
-    throw MYMONEYEXCEPTION("Node has no ID");
+    throw MYMONEYEXCEPTION_CSTRING("Node has no ID");
 }
 
 MyMoneyObject::~MyMoneyObject()
 {
   Q_D(MyMoneyObject);
   delete d;
 }
 
 QString MyMoneyObject::id() const
 {
   Q_D(const MyMoneyObject);
   return d->m_id;
 }
 
 bool MyMoneyObject::operator == (const MyMoneyObject& right) const
 {
   Q_D(const MyMoneyObject);
   return d->m_id == right.d_func()->m_id;
 }
 
 void MyMoneyObject::clearId()
 {
   Q_D(MyMoneyObject);
   d->m_id.clear();
 }
diff --git a/kmymoney/mymoney/mymoneypayee.cpp b/kmymoney/mymoney/mymoneypayee.cpp
index 678c3f44a..0252cf565 100644
--- a/kmymoney/mymoney/mymoneypayee.cpp
+++ b/kmymoney/mymoney/mymoneypayee.cpp
@@ -1,395 +1,393 @@
 /***************************************************************************
                           mymoneypayee.cpp
                              -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                            (C) 2008 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneypayee.h"
 #include "mymoneypayee_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QStringList>
 #include <QDomElement>
 #include <QMap>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <mymoneyexception.h>
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 
 MyMoneyPayee MyMoneyPayee::null;
 
 MyMoneyPayee::MyMoneyPayee() :
   MyMoneyObject(*new MyMoneyPayeePrivate)
 {
 }
 
 MyMoneyPayee::MyMoneyPayee(const QString& name,
                            const QString& address,
                            const QString& city,
                            const QString& state,
                            const QString& postcode,
                            const QString& telephone,
                            const QString& email) :
   MyMoneyObject(*new MyMoneyPayeePrivate)
 {
   Q_D(MyMoneyPayee);
   d->m_name      = name;
   d->m_address   = address;
   d->m_city      = city;
   d->m_state     = state;
   d->m_postcode  = postcode;
   d->m_telephone = telephone;
   d->m_email     = email;
   d->m_matchingEnabled = false;
   d->m_usingMatchKey = false;
   d->m_matchKeyIgnoreCase = true;
 }
 
 MyMoneyPayee::MyMoneyPayee(const QDomElement& node) :
     MyMoneyObject(*new MyMoneyPayeePrivate, node)
 {
   if (nodeNames[nnPayee] != node.tagName()) {
-    throw MYMONEYEXCEPTION("Node was not PAYEE");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not PAYEE");
   }
 
   Q_D(MyMoneyPayee);
   d->m_name = node.attribute(d->getAttrName(Payee::Attribute::Name));
   d->m_reference = node.attribute(d->getAttrName(Payee::Attribute::Reference));
   d->m_email = node.attribute(d->getAttrName(Payee::Attribute::Email));
 
   d->m_matchingEnabled = node.attribute(d->getAttrName(Payee::Attribute::MatchingEnabled), "0").toUInt();
   if (d->m_matchingEnabled) {
     setMatchData((node.attribute(d->getAttrName(Payee::Attribute::UsingMatchKey), "0").toUInt() != 0) ? matchKey : matchName,
                  node.attribute(d->getAttrName(Payee::Attribute::MatchIgnoreCase), "0").toUInt(),
                  node.attribute(d->getAttrName(Payee::Attribute::MatchKey)));
   }
 
   if (node.hasAttribute(d->getAttrName(Payee::Attribute::Notes))) {
     d->m_notes = node.attribute(d->getAttrName(Payee::Attribute::Notes));
   }
 
   if (node.hasAttribute(d->getAttrName(Payee::Attribute::DefaultAccountID))) {
     d->m_defaultAccountId = node.attribute(d->getAttrName(Payee::Attribute::DefaultAccountID));
   }
 
   // Load Address
   QDomNodeList nodeList = node.elementsByTagName(d->getElName(Payee::Element::Address));
-  if (nodeList.count() == 0) {
-    QString msg = QString("No ADDRESS in payee %1").arg(d->m_name);
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (nodeList.isEmpty())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("No ADDRESS in payee %1").arg(d->m_name));
 
   QDomElement addrNode = nodeList.item(0).toElement();
   d->m_address = addrNode.attribute(d->getAttrName(Payee::Attribute::Street));
   d->m_city = addrNode.attribute(d->getAttrName(Payee::Attribute::City));
   d->m_postcode = addrNode.attribute(d->getAttrName(Payee::Attribute::PostCode));
   d->m_state = addrNode.attribute(d->getAttrName(Payee::Attribute::State));
   d->m_telephone = addrNode.attribute(d->getAttrName(Payee::Attribute::Telephone));
 
   MyMoneyPayeeIdentifierContainer::loadXML(node);
 }
 
 MyMoneyPayee::MyMoneyPayee(const MyMoneyPayee& other) :
   MyMoneyObject(*new MyMoneyPayeePrivate(*other.d_func()), other.id()),
   MyMoneyPayeeIdentifierContainer(other)
 {
 }
 
 MyMoneyPayee::MyMoneyPayee(const QString& id, const MyMoneyPayee& other) :
   MyMoneyObject(*new MyMoneyPayeePrivate(*other.d_func()), id),
   MyMoneyPayeeIdentifierContainer(other)
 {
 }
 
 MyMoneyPayee::~MyMoneyPayee()
 {
 }
 
 bool MyMoneyPayee::operator == (const MyMoneyPayee& right) const
 {
   Q_D(const MyMoneyPayee);
   auto d2 = static_cast<const MyMoneyPayeePrivate *>(right.d_func());
   return (MyMoneyObject::operator==(right) &&
           ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)) &&
           ((d->m_address.length() == 0 && d2->m_address.length() == 0) || (d->m_address == d2->m_address)) &&
           ((d->m_city.length() == 0 && d2->m_city.length() == 0) || (d->m_city == d2->m_city)) &&
           ((d->m_state.length() == 0 && d2->m_state.length() == 0) || (d->m_state == d2->m_state)) &&
           ((d->m_postcode.length() == 0 && d2->m_postcode.length() == 0) || (d->m_postcode == d2->m_postcode)) &&
           ((d->m_telephone.length() == 0 && d2->m_telephone.length() == 0) || (d->m_telephone == d2->m_telephone)) &&
           ((d->m_email.length() == 0 && d2->m_email.length() == 0) || (d->m_email == d2->m_email)) &&
           (d->m_matchingEnabled == d2->m_matchingEnabled) &&
           (d->m_usingMatchKey == d2->m_usingMatchKey) &&
           (d->m_matchKeyIgnoreCase == d2->m_matchKeyIgnoreCase) &&
           ((d->m_matchKey.length() == 0 && d2->m_matchKey.length() == 0) || d->m_matchKey == d2->m_matchKey) &&
           ((d->m_reference.length() == 0 && d2->m_reference.length() == 0) || (d->m_reference == d2->m_reference)) &&
           ((d->m_defaultAccountId.length() == 0 && d2->m_defaultAccountId.length() == 0) || d->m_defaultAccountId == d2->m_defaultAccountId));
 }
 
 //bool MyMoneyPayee::operator == (const MyMoneyPayee& lhs, const QString& rhs) const
 //{
 //  Q_D(const MyMoneyPayee);
 //  return lhs.id() == rhs;
 //}
 
 bool MyMoneyPayee::operator < (const MyMoneyPayee& right) const
 {
   Q_D(const MyMoneyPayee);
   auto d2 = static_cast<const MyMoneyPayeePrivate *>(right.d_func());
   return d->m_name < d2->m_name;
 }
 
 void MyMoneyPayee::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   auto el = document.createElement(nodeNames[nnPayee]);
 
   Q_D(const MyMoneyPayee);
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Payee::Attribute::Name), d->m_name);
   el.setAttribute(d->getAttrName(Payee::Attribute::Reference), d->m_reference);
   el.setAttribute(d->getAttrName(Payee::Attribute::Email), d->m_email);
   if (!d->m_notes.isEmpty())
     el.setAttribute(d->getAttrName(Payee::Attribute::Notes), d->m_notes);
 
   el.setAttribute(d->getAttrName(Payee::Attribute::MatchingEnabled), d->m_matchingEnabled);
   if (d->m_matchingEnabled) {
     el.setAttribute(d->getAttrName(Payee::Attribute::UsingMatchKey), d->m_usingMatchKey);
     el.setAttribute(d->getAttrName(Payee::Attribute::MatchIgnoreCase), d->m_matchKeyIgnoreCase);
     el.setAttribute(d->getAttrName(Payee::Attribute::MatchKey), d->m_matchKey);
   }
 
   if (!d->m_defaultAccountId.isEmpty()) {
     el.setAttribute(d->getAttrName(Payee::Attribute::DefaultAccountID), d->m_defaultAccountId);
   }
 
   // Save address
   QDomElement address = document.createElement(d->getElName(Payee::Element::Address));
   address.setAttribute(d->getAttrName(Payee::Attribute::Street), d->m_address);
   address.setAttribute(d->getAttrName(Payee::Attribute::City), d->m_city);
   address.setAttribute(d->getAttrName(Payee::Attribute::PostCode), d->m_postcode);
   address.setAttribute(d->getAttrName(Payee::Attribute::State), d->m_state);
   address.setAttribute(d->getAttrName(Payee::Attribute::Telephone), d->m_telephone);
 
   el.appendChild(address);
 
   // Save payeeIdentifiers (account numbers)
   MyMoneyPayeeIdentifierContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneyPayee::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneyPayee);
   return id == d->m_defaultAccountId;
 }
 
 QString MyMoneyPayee::name() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_name;
 }
 
 void MyMoneyPayee::setName(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_name = val;
 }
 
 QString MyMoneyPayee::address() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_address;
 }
 
 void MyMoneyPayee::setAddress(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_address = val;
 }
 
 QString MyMoneyPayee::city() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_city;
 }
 
 void MyMoneyPayee::setCity(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_city = val;
 }
 
 QString MyMoneyPayee::state() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_state;
 }
 
 void MyMoneyPayee::setState(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_state = val;
 }
 
 QString MyMoneyPayee::postcode() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_postcode;
 }
 
 void MyMoneyPayee::setPostcode(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_postcode = val;
 }
 
 QString MyMoneyPayee::telephone() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_telephone;
 }
 
 void MyMoneyPayee::setTelephone(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_telephone = val;
 }
 
 QString MyMoneyPayee::email() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_email;
 }
 
 void MyMoneyPayee::setEmail(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_email = val;
 }
 
 QString MyMoneyPayee::notes() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_notes;
 }
 
 void MyMoneyPayee::setNotes(const QString& val)
 {
   Q_D(MyMoneyPayee);
   d->m_notes = val;
 }
 
 QString MyMoneyPayee::reference() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_reference;
 }
 
 void MyMoneyPayee::setReference(const QString& ref)
 {
   Q_D(MyMoneyPayee);
   d->m_reference = ref;
 }
 
 MyMoneyPayee::payeeMatchType MyMoneyPayee::matchData(bool& ignorecase, QStringList& keys) const
 {
   payeeMatchType type = matchDisabled;
   keys.clear();
 
   Q_D(const MyMoneyPayee);
   ignorecase = d->m_matchKeyIgnoreCase;
 
   if (d->m_matchingEnabled) {
     type = d->m_usingMatchKey ? matchKey : matchName;
     if (type == matchKey) {
       if (d->m_matchKey.contains(QLatin1Char('\n')))
         keys = d->m_matchKey.split(QLatin1Char('\n'));
       else
         keys = d->m_matchKey.split(QLatin1Char(';'));  // for compatibility with 4.8.0
     } else if (d->m_matchKey.compare(QLatin1String("^$")) == 0) {
       type = matchNameExact;
     }
   }
 
   return type;
 }
 
 MyMoneyPayee::payeeMatchType MyMoneyPayee::matchData(bool& ignorecase, QString& keyString) const
 {
   QStringList keys;
   payeeMatchType type = matchData(ignorecase, keys);
   keyString = keys.join(QLatin1Char('\n'));
   return type;
 }
 
 void MyMoneyPayee::setMatchData(payeeMatchType type, bool ignorecase, const QStringList& keys)
 {
   Q_D(MyMoneyPayee);
   d->m_matchingEnabled = (type != matchDisabled);
   d->m_matchKeyIgnoreCase = ignorecase;
   d->m_matchKey.clear();
 
   if (d->m_matchingEnabled) {
     d->m_usingMatchKey = (type == matchKey);
     if (d->m_usingMatchKey) {
       QRegExp validKeyRegExp("[^ ]");
       QStringList filteredKeys = keys.filter(validKeyRegExp);
       d->m_matchKey = filteredKeys.join(QLatin1Char('\n'));
     } else if(type == matchNameExact) {
       d->m_matchKey = QLatin1String("^$");
     }
   }
 }
 
 void MyMoneyPayee::setMatchData(payeeMatchType type, bool ignorecase, const QString& keys)
 {
   if (keys.contains(QLatin1Char('\n')))
     setMatchData(type, ignorecase, keys.split(QLatin1Char('\n')));
   else
     setMatchData(type, ignorecase, keys.split(QLatin1Char(';'))); // for compatibility with 4.8.0
 }
 
 bool MyMoneyPayee::defaultAccountEnabled() const
 {
   Q_D(const MyMoneyPayee);
   return !d->m_defaultAccountId.isEmpty();
 }
 
 QString MyMoneyPayee::defaultAccountId() const
 {
   Q_D(const MyMoneyPayee);
   return d->m_defaultAccountId;
 }
 
 void MyMoneyPayee::setDefaultAccountId(const QString& id)
 {
   Q_D(MyMoneyPayee);
   d->m_defaultAccountId = id;
 }
 
 void MyMoneyPayee::setDefaultAccountId()
 {
   setDefaultAccountId(QString());
 }
 
 // vim:cin:si:ai:et:ts=2:sw=2:
diff --git a/kmymoney/mymoney/mymoneyprice.cpp b/kmymoney/mymoney/mymoneyprice.cpp
index c835461c0..f9a97977e 100644
--- a/kmymoney/mymoney/mymoneyprice.cpp
+++ b/kmymoney/mymoney/mymoneyprice.cpp
@@ -1,180 +1,179 @@
 /***************************************************************************
                           mymoneyprice  -  description
                              -------------------
     begin                : Sun Nov 21 2004
     copyright            : (C) 2000-2004 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /**
   * @author Thomas Baumgart
   */
 
 #include "mymoneyprice.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDate>
 #include <QString>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 
 class MyMoneyPricePrivate
 {
 public:
   QString       m_fromSecurity;
   QString       m_toSecurity;
   QDate         m_date;
   MyMoneyMoney  m_rate;
   MyMoneyMoney  m_invRate;
   QString       m_source;
 };
 
 MyMoneyPrice::MyMoneyPrice() :
   d_ptr(new MyMoneyPricePrivate)
 {
 }
 
 MyMoneyPrice::MyMoneyPrice(const QString& from,
                            const QString& to,
                            const QDomElement& node) :
   d_ptr(new MyMoneyPricePrivate)
 {
   if ("PRICE" != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not PRICE");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not PRICE");
 
   Q_D(MyMoneyPrice);
   d->m_fromSecurity = from;
   d->m_toSecurity = to;
 
   d->m_date = QDate::fromString(node.attribute("date"), Qt::ISODate);
   d->m_rate = MyMoneyMoney(node.attribute("price"));
   d->m_source = node.attribute("source");
 
   if (!d->m_rate.isZero())
     d->m_invRate = MyMoneyMoney::ONE / d->m_rate;
   else
     qDebug("Price with zero value loaded");
 }
 
 MyMoneyPrice::MyMoneyPrice(const QString& from, const QString& to, const QDate& date, const MyMoneyMoney& rate, const QString& source) :
   d_ptr(new MyMoneyPricePrivate)
 {
   Q_D(MyMoneyPrice);
   d->m_fromSecurity =from;
   d->m_toSecurity = to;
   d->m_date = date;
   d->m_rate = rate;
   d->m_source = source;
 
   if (!d->m_rate.isZero())
     d->m_invRate = MyMoneyMoney::ONE / d->m_rate;
   else
     qDebug("Price with zero value created for '%s' to '%s'",
            qPrintable(from), qPrintable(to));
 }
 
 MyMoneyPrice::MyMoneyPrice(const MyMoneyPrice& other) :
   d_ptr(new MyMoneyPricePrivate(*other.d_func()))
 {
 }
 
 MyMoneyPrice::~MyMoneyPrice()
 {
   Q_D(MyMoneyPrice);
   delete d;
 }
 
 MyMoneyMoney MyMoneyPrice::rate(const QString& id) const
 {
   Q_D(const MyMoneyPrice);
   static MyMoneyMoney dummyPrice(1, 1);
 
   if (!isValid())
     return dummyPrice;
 
   if (id.isEmpty() || id == d->m_toSecurity)
     return d->m_rate;
   if (id == d->m_fromSecurity)
     return d->m_invRate;
 
-  QString msg = QString("Unknown security id %1 for price info %2/%3.").arg(id).arg(d->m_fromSecurity).arg(d->m_toSecurity);
-  throw MYMONEYEXCEPTION(msg);
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown security id %1 for price info %2/%3.").arg(id, d->m_fromSecurity, d->m_toSecurity));
 }
 
 QDate MyMoneyPrice::date() const
 {
   Q_D(const MyMoneyPrice);
   return d->m_date;
 }
 
 QString MyMoneyPrice::source() const
 {
   Q_D(const MyMoneyPrice);
   return d->m_source;
 }
 
 QString MyMoneyPrice::from() const
 {
   Q_D(const MyMoneyPrice);
   return d->m_fromSecurity;
 }
 
 QString MyMoneyPrice::to() const
 {
   Q_D(const MyMoneyPrice);
   return d->m_toSecurity;
 }
 
 bool MyMoneyPrice::isValid() const
 {
   Q_D(const MyMoneyPrice);
   return (d->m_date.isValid() && !d->m_fromSecurity.isEmpty() && !d->m_toSecurity.isEmpty());
 }
 
 // Equality operator
 bool MyMoneyPrice::operator == (const MyMoneyPrice &right) const
 {
   Q_D(const MyMoneyPrice);
   auto d2 = static_cast<const MyMoneyPricePrivate *>(right.d_func());
   return ((d->m_date == d2->m_date) &&
           (d->m_rate == d2->m_rate) &&
           ((d->m_fromSecurity.length() == 0 && d2->m_fromSecurity.length() == 0) || (d->m_fromSecurity == d2->m_fromSecurity)) &&
           ((d->m_toSecurity.length() == 0 && d2->m_toSecurity.length() == 0) || (d->m_toSecurity == d2->m_toSecurity)) &&
           ((d->m_source.length() == 0 && d2->m_source.length() == 0) || (d->m_source == d2->m_source)));
 }
 
 bool MyMoneyPrice::operator != (const MyMoneyPrice &right) const
 {
   return !(operator == (right));
 }
 
 bool MyMoneyPrice::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneyPrice);
   return (id == d->m_fromSecurity) || (id == d->m_toSecurity);
 }
diff --git a/kmymoney/mymoney/mymoneyreport.cpp b/kmymoney/mymoney/mymoneyreport.cpp
index 480b12f8a..19489c507 100644
--- a/kmymoney/mymoney/mymoneyreport.cpp
+++ b/kmymoney/mymoney/mymoneyreport.cpp
@@ -1,1633 +1,1633 @@
 /***************************************************************************
                           mymoneyreport.cpp
                              -------------------
     begin                : Sun July 4 2004
     copyright            : (C) 2004-2005 by Ace Jones
     email                : acejones@users.sourceforge.net
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyreport_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDomElement>
 #include <QDomDocument>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneystoragenames.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneyexception.h"
 
 using namespace MyMoneyStorageNodes;
 
 // define this to debug reports
 // #define DEBUG_REPORTS
 
 const QStringList MyMoneyReport::kRowTypeText = QString("none,assetliability,expenseincome,category,topcategory,account,tag,payee,month,week,topaccount,topaccount-account,equitytype,accounttype,institution,budget,budgetactual,schedule,accountinfo,accountloaninfo,accountreconcile,cashflow").split(',');
 const QStringList MyMoneyReport::kColumnTypeText = QString("none,months,bimonths,quarters,4,5,6,weeks,8,9,10,11,years").split(',');
 
 // if you add names here, don't forget to update the bitmap for EQueryColumns
 // and shift the bit for eQCend one position to the left
 const QStringList MyMoneyReport::kQueryColumnsText = QString("none,number,payee,category,tag,memo,account,reconcileflag,action,shares,price,performance,loan,balance,capitalgain").split(',');
 
 const MyMoneyReport::EReportType MyMoneyReport::kTypeArray[] = { eNoReport, ePivotTable, ePivotTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, ePivotTable, ePivotTable, eInfoTable, eInfoTable, eInfoTable, eQueryTable, eQueryTable, eNoReport };
 const QStringList MyMoneyReport::kDetailLevelText = QString("none,all,top,group,total,invalid").split(',');
 const QStringList MyMoneyReport::kChartTypeText = QString("none,line,bar,pie,ring,stackedbar").split(',');
 
 // This should live in mymoney/mymoneytransactionfilter.h
 const QStringList kTypeText = QString("all,payments,deposits,transfers,none").split(',');
 const QStringList kStateText = QString("all,notreconciled,cleared,reconciled,frozen,none").split(',');
 const QStringList kDateLockText = QString("alldates,untiltoday,currentmonth,currentyear,monthtodate,yeartodate,yeartomonth,lastmonth,lastyear,last7days,last30days,last3months,last6months,last12months,next7days,next30days,next3months,next6months,next12months,userdefined,last3tonext3months,last11Months,currentQuarter,lastQuarter,nextQuarter,currentFiscalYear,lastFiscalYear,today,next18months").split(',');
 const QStringList kDataLockText = QString("automatic,userdefined").split(',');
 const QStringList kAccountTypeText = QString("unknown,checkings,savings,cash,creditcard,loan,certificatedep,investment,moneymarket,asset,liability,currency,income,expense,assetloan,stock,equity,invalid").split(',');
 
 MyMoneyReport::MyMoneyReport() :
   MyMoneyObject(*new MyMoneyReportPrivate)
 {
   Q_D(MyMoneyReport);
   d->m_name = "Unconfigured Pivot Table Report";
   d->m_detailLevel = eDetailNone;
   d->m_investmentSum = eSumSold;
   d->m_hideTransactions = false;
   d->m_convertCurrency = true;
   d->m_favorite = false;
   d->m_tax = false;
   d->m_investments = false;
   d->m_loans = false;
   d->m_reportType = kTypeArray[eExpenseIncome];
   d->m_rowType = eExpenseIncome;
   d->m_columnType = eMonths;
   d->m_columnsAreDays = false;
   d->m_queryColumns = eQCnone;
   d->m_dateLock = TransactionFilter::Date::UserDefined;
   d->m_accountGroupFilter = false;
   d->m_chartType = eChartLine;
   d->m_chartDataLabels = true;
   d->m_chartCHGridLines = true;
   d->m_chartSVGridLines = true;
   d->m_chartByDefault = false;
   d->m_logYaxis = false;
   d->m_dataRangeStart = '0';
   d->m_dataRangeEnd = '0';
   d->m_dataMajorTick = '0';
   d->m_dataMinorTick = '0';
   d->m_yLabelsPrecision = 2;
   d->m_dataLock = MyMoneyReport::automatic;
   d->m_includeSchedules = false;
   d->m_includeTransfers = false;
   d->m_includeBudgetActuals = false;
   d->m_includeUnusedAccounts = false;
   d->m_showRowTotals = false;
   d->m_showColumnTotals = true;
   d->m_includeForecast = false;
   d->m_includeMovingAverage = false;
   d->m_movingAverageDays = 0;
   d->m_includePrice = false;
   d->m_includeAveragePrice = false;
   d->m_mixedTime = false;
   d->m_currentDateColumn = 0;
   d->m_settlementPeriod = 3;
   d->m_showSTLTCapitalGains = false;
   d->m_tseparator = QDate::currentDate().addYears(-1);
   d->m_skipZero = false;
   d->m_chartLineWidth = m_lineWidth;
 }
 
 MyMoneyReport::MyMoneyReport(ERowType rt,
                              unsigned ct,
                              TransactionFilter::Date dl,
                              EDetailLevel ss,
                              const QString& name,
                              const QString& comment) :
   MyMoneyObject(*new MyMoneyReportPrivate)
 {
   Q_D(MyMoneyReport);
   d->m_name = name;
   d->m_comment = comment;
   d->m_detailLevel = ss;
   d->m_investmentSum = ct & eQCcapitalgain ? eSumSold : eSumPeriod;
   d->m_hideTransactions = false;
   d->m_convertCurrency = true;
   d->m_favorite = false;
   d->m_tax = false;
   d->m_investments = false;
   d->m_loans = false;
   d->m_reportType = kTypeArray[rt];
   d->m_rowType = rt;
   d->m_columnType = eMonths;
   d->m_columnsAreDays = false;
   d->m_queryColumns = eQCnone;
   d->m_dateLock = dl;
   d->m_accountGroupFilter = false;
   d->m_chartType = eChartLine;
   d->m_chartDataLabels = true;
   d->m_chartCHGridLines = true;
   d->m_chartSVGridLines = true;
   d->m_chartByDefault = false;
   d->m_logYaxis = false;
   d->m_dataRangeStart = '0';
   d->m_dataRangeEnd = '0';
   d->m_dataMajorTick = '0';
   d->m_dataMinorTick = '0';
   d->m_yLabelsPrecision = 2;
   d->m_dataLock = MyMoneyReport::automatic;
   d->m_includeSchedules = false;
   d->m_includeTransfers = false;
   d->m_includeBudgetActuals = false;
   d->m_includeUnusedAccounts = false;
   d->m_showRowTotals = false;
   d->m_showColumnTotals = true;
   d->m_includeForecast = false;
   d->m_includeMovingAverage = false;
   d->m_movingAverageDays = 0;
   d->m_includePrice = false;
   d->m_includeAveragePrice = false;
   d->m_mixedTime = false;
   d->m_currentDateColumn = 0;
   d->m_settlementPeriod = 3;
   d->m_showSTLTCapitalGains = false;
   d->m_tseparator = QDate::currentDate().addYears(-1);
   d->m_skipZero = false;
 
   //set initial values
   d->m_chartLineWidth = m_lineWidth;
 
   //set report type
   if (d->m_reportType == ePivotTable)
     d->m_columnType = static_cast<EColumnType>(ct);
   if (d->m_reportType == eQueryTable)
     d->m_queryColumns = static_cast<EQueryColumns>(ct);
   setDateFilter(dl);
 
   //throw exception if the type is inconsistent
   if ((rt > static_cast<ERowType>(sizeof(kTypeArray) / sizeof(kTypeArray[0])))
       || (d->m_reportType == eNoReport))
-    throw MYMONEYEXCEPTION("Invalid report type");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid report type");
 
   //add the corresponding account groups
   if (rt == MyMoneyReport::eAssetLiability) {
     addAccountGroup(Account::Type::Asset);
     addAccountGroup(Account::Type::Liability);
     d->m_showRowTotals = true;
   }
   if (rt == MyMoneyReport::eAccount) {
     addAccountGroup(Account::Type::Asset);
     addAccountGroup(Account::Type::AssetLoan);
     addAccountGroup(Account::Type::Cash);
     addAccountGroup(Account::Type::Checkings);
     addAccountGroup(Account::Type::CreditCard);
     if (m_expertMode)
       addAccountGroup(Account::Type::Equity);
     addAccountGroup(Account::Type::Expense);
     addAccountGroup(Account::Type::Income);
     addAccountGroup(Account::Type::Liability);
     addAccountGroup(Account::Type::Loan);
     addAccountGroup(Account::Type::Savings);
     addAccountGroup(Account::Type::Stock);
     d->m_showRowTotals = true;
   }
   if (rt == MyMoneyReport::eExpenseIncome) {
     addAccountGroup(Account::Type::Expense);
     addAccountGroup(Account::Type::Income);
     d->m_showRowTotals = true;
   }
   //FIXME take this out once we have sorted out all issues regarding budget of assets and liabilities -- asoliverez@gmail.com
   if (rt == MyMoneyReport::eBudget || rt == MyMoneyReport::eBudgetActual) {
     addAccountGroup(Account::Type::Expense);
     addAccountGroup(Account::Type::Income);
   }
   if (rt == MyMoneyReport::eAccountInfo) {
     addAccountGroup(Account::Type::Asset);
     addAccountGroup(Account::Type::Liability);
   }
   //cash flow reports show splits for all account groups
   if (rt == MyMoneyReport::eCashFlow) {
     addAccountGroup(Account::Type::Expense);
     addAccountGroup(Account::Type::Income);
     addAccountGroup(Account::Type::Asset);
     addAccountGroup(Account::Type::Liability);
   }
 #ifdef DEBUG_REPORTS
   QDebug out = qDebug();
   out << _name << toString(_rt) << toString(m_reportType);
   foreach(const Account::Type accountType, m_accountGroups)
     out << MyMoneyAccount::accountTypeToString(accountType);
   if (m_accounts.size() > 0)
     out << m_accounts;
 #endif
 }
 
 MyMoneyReport::MyMoneyReport(const QDomElement& node) :
     MyMoneyObject(*new MyMoneyReportPrivate, node)
 {
   Q_D(MyMoneyReport);
   d->m_currentDateColumn = 0;
   // properly initialize the object before reading it
   *this = MyMoneyReport();
   if (!read(node))
     clearId();
 }
 
 MyMoneyReport::MyMoneyReport(const MyMoneyReport& other) :
   MyMoneyObject(*new MyMoneyReportPrivate(*other.d_func()), other.id()),
   MyMoneyTransactionFilter(other)
 {
 }
 
 MyMoneyReport::MyMoneyReport(const QString& id, const MyMoneyReport& other) :
   MyMoneyObject(*new MyMoneyReportPrivate(*other.d_func()), id),
   MyMoneyTransactionFilter(other)
 {
   Q_D(MyMoneyReport);
   d->m_movingAverageDays = 0;
   d->m_currentDateColumn = 0;
 }
 
 MyMoneyReport::~MyMoneyReport()
 {
 }
 
 MyMoneyReport::EReportType MyMoneyReport::reportType() const
 {
   Q_D(const MyMoneyReport);
   return d->m_reportType;
 }
 
 QString MyMoneyReport::name() const
 {
   Q_D(const MyMoneyReport);
   return d->m_name;
 }
 
 void MyMoneyReport::setName(const QString& s)
 {
   Q_D(MyMoneyReport);
   d->m_name = s;
 }
 
 bool MyMoneyReport::isShowingRowTotals() const
 {
   Q_D(const MyMoneyReport);
   return (d->m_showRowTotals);
 }
 
 void MyMoneyReport::setShowingRowTotals(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_showRowTotals = f;
 }
 
 bool MyMoneyReport::isShowingColumnTotals() const
 {
   Q_D(const MyMoneyReport);
   return d->m_showColumnTotals;
 }
 
 void MyMoneyReport::setShowingColumnTotals(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_showColumnTotals = f;
 }
 
 MyMoneyReport::ERowType MyMoneyReport::rowType() const
 {
   Q_D(const MyMoneyReport);
   return d->m_rowType;
 }
 
 void MyMoneyReport::setRowType(ERowType rt)
 {
   Q_D(MyMoneyReport);
   d->m_rowType = rt;
   d->m_reportType = kTypeArray[rt];
 
   d->m_accountGroupFilter = false;
   d->m_accountGroups.clear();
 
   if (rt == MyMoneyReport::eAssetLiability) {
     addAccountGroup(Account::Type::Asset);
     addAccountGroup(Account::Type::Liability);
   }
   if (rt == MyMoneyReport::eExpenseIncome) {
     addAccountGroup(Account::Type::Expense);
     addAccountGroup(Account::Type::Income);
   }
 }
 
 bool MyMoneyReport::isRunningSum() const
 {
   Q_D(const MyMoneyReport);
   return (d->m_rowType == eAssetLiability);
 }
 
 MyMoneyReport::EColumnType MyMoneyReport::columnType() const
 {
   Q_D(const MyMoneyReport);
   return d->m_columnType;
 }
 
 void MyMoneyReport::setColumnType(EColumnType ct)
 {
   Q_D(MyMoneyReport);
   d->m_columnType = ct;
 }
 
 bool MyMoneyReport::isConvertCurrency() const
 {
   Q_D(const MyMoneyReport);
   return d->m_convertCurrency;
 }
 
 void MyMoneyReport::setConvertCurrency(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_convertCurrency = f;
 }
 
 uint MyMoneyReport::columnPitch() const
 {
   Q_D(const MyMoneyReport);
   return static_cast<uint>(d->m_columnType);
 }
 
 QString MyMoneyReport::comment() const
 {
   Q_D(const MyMoneyReport);
   return d->m_comment;
 }
 
 void MyMoneyReport::setComment(const QString& comment)
 {
   Q_D(MyMoneyReport);
   d->m_comment = comment;
 }
 
 MyMoneyReport::EQueryColumns MyMoneyReport::queryColumns() const
 {
   Q_D(const MyMoneyReport);
   return d->m_queryColumns;
 }
 
 void MyMoneyReport::setQueryColumns(EQueryColumns qc)
 {
   Q_D(MyMoneyReport);
   d->m_queryColumns = qc;
 }
 
 QString MyMoneyReport::group() const
 {
   Q_D(const MyMoneyReport);
   return d->m_group;
 }
 
 void MyMoneyReport::setGroup(const QString& group)
 {
   Q_D(MyMoneyReport);
   d->m_group = group;
 }
 
 bool MyMoneyReport::isFavorite() const
 {
   Q_D(const MyMoneyReport);
   return d->m_favorite;
 }
 
 void MyMoneyReport::setFavorite(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_favorite = f;
 }
 
 bool MyMoneyReport::isTax() const
 {
   Q_D(const MyMoneyReport);
   return d->m_tax;
 }
 
 void MyMoneyReport::setTax(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_tax = f;
 }
 
 bool MyMoneyReport::isInvestmentsOnly() const
 {
   Q_D(const MyMoneyReport);
   return d->m_investments;
 }
 
 void MyMoneyReport::setInvestmentsOnly(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_investments = f; if (f) d->m_loans = false;
 }
 
 bool MyMoneyReport::isLoansOnly() const
 {
   Q_D(const MyMoneyReport);
   return d->m_loans;
 }
 
 void MyMoneyReport::setLoansOnly(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_loans = f; if (f) d->m_investments = false;
 }
 
 MyMoneyReport::EDetailLevel MyMoneyReport::detailLevel() const
 {
   Q_D(const MyMoneyReport);
   return d->m_detailLevel;
 }
 
 void MyMoneyReport::setDetailLevel(EDetailLevel detail)
 {
   Q_D(MyMoneyReport);
   d->m_detailLevel = detail;
 }
 
 MyMoneyReport::EInvestmentSum MyMoneyReport::investmentSum() const
 {
   Q_D(const MyMoneyReport);
   return d->m_investmentSum;
 }
 
 void MyMoneyReport::setInvestmentSum(EInvestmentSum sum)
 {
   Q_D(MyMoneyReport);
   d->m_investmentSum = sum;
 }
 
 bool MyMoneyReport::isHideTransactions() const
 {
   Q_D(const MyMoneyReport);
   return d->m_hideTransactions;
 }
 
 void MyMoneyReport::setHideTransactions(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_hideTransactions = f;
 }
 
 MyMoneyReport::EChartType MyMoneyReport::chartType() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartType;
 }
 
 void MyMoneyReport::setChartType(EChartType type)
 {
   Q_D(MyMoneyReport);
   d->m_chartType = type;
 }
 
 bool MyMoneyReport::isChartDataLabels() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartDataLabels;
 }
 
 void MyMoneyReport::setChartDataLabels(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_chartDataLabels = f;
 }
 
 bool MyMoneyReport::isChartCHGridLines() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartCHGridLines;
 }
 
 void MyMoneyReport::setChartCHGridLines(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_chartCHGridLines = f;
 }
 
 bool MyMoneyReport::isChartSVGridLines() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartSVGridLines;
 }
 
 void MyMoneyReport::setChartSVGridLines(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_chartSVGridLines = f;
 }
 
 bool MyMoneyReport::isChartByDefault() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartByDefault;
 }
 
 void MyMoneyReport::setChartByDefault(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_chartByDefault = f;
 }
 
 uint MyMoneyReport::chartLineWidth() const
 {
   Q_D(const MyMoneyReport);
   return d->m_chartLineWidth;
 }
 
 void MyMoneyReport::setChartLineWidth(uint f)
 {
   Q_D(MyMoneyReport);
   d->m_chartLineWidth = f;
 }
 
 bool MyMoneyReport::isLogYAxis() const
 {
   Q_D(const MyMoneyReport);
   return d->m_logYaxis;
 }
 
 void MyMoneyReport::setLogYAxis(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_logYaxis = f;
 }
 
 QString MyMoneyReport::dataRangeStart() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataRangeStart;
 }
 
 void MyMoneyReport::setDataRangeStart(const QString& f)
 {
   Q_D(MyMoneyReport);
   d->m_dataRangeStart = f;
 }
 
 QString MyMoneyReport::dataRangeEnd() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataRangeEnd;
 }
 
 void MyMoneyReport::setDataRangeEnd(const QString& f)
 {
   Q_D(MyMoneyReport);
   d->m_dataRangeEnd = f;
 }
 
 QString MyMoneyReport::dataMajorTick() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataMajorTick;
 }
 
 void MyMoneyReport::setDataMajorTick(const QString& f)
 {
   Q_D(MyMoneyReport);
   d->m_dataMajorTick = f;
 }
 
 QString MyMoneyReport::dataMinorTick() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataMinorTick;
 }
 
 void MyMoneyReport::setDataMinorTick(const QString& f)
 {
   Q_D(MyMoneyReport);
   d->m_dataMinorTick = f;
 }
 
 uint MyMoneyReport::yLabelsPrecision() const
 {
   Q_D(const MyMoneyReport);
   return d->m_yLabelsPrecision;
 }
 
 void MyMoneyReport::setYLabelsPrecision(int f)
 {
   Q_D(MyMoneyReport);
   d->m_yLabelsPrecision = f;
 }
 
 bool MyMoneyReport::isIncludingSchedules() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeSchedules;
 }
 
 void MyMoneyReport::setIncludingSchedules(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeSchedules = f;
 }
 
 bool MyMoneyReport::isColumnsAreDays() const
 {
   Q_D(const MyMoneyReport);
   return d->m_columnsAreDays;
 }
 
 void MyMoneyReport::setColumnsAreDays(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_columnsAreDays = f;
 }
 
 bool MyMoneyReport::isIncludingTransfers() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeTransfers;
 }
 
 void MyMoneyReport::setIncludingTransfers(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeTransfers = f;
 }
 
 bool MyMoneyReport::isIncludingUnusedAccounts() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeUnusedAccounts;
 }
 
 void MyMoneyReport::setIncludingUnusedAccounts(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeUnusedAccounts = f;
 }
 
 bool MyMoneyReport::hasBudget() const
 {
   Q_D(const MyMoneyReport);
   return !d->m_budgetId.isEmpty();
 }
 
 QString MyMoneyReport::budget() const
 {
   Q_D(const MyMoneyReport);
   return d->m_budgetId;
 }
 
 /**
   * Sets the budget used for this report
   *
   * @param budget The ID of the budget to use, or an empty string
   * to indicate a budget is NOT included
   * @param fa Whether to display actual data alongside the budget.
   * Setting to false means the report displays ONLY the budget itself.
   * @warning For now, the budget ID is ignored.  The budget id is
   * simply checked for any non-empty string, and if so, hasBudget()
   * will return true.
   */
 void MyMoneyReport::setBudget(const QString& budget, bool fa)
 {
   Q_D(MyMoneyReport);
   d->m_budgetId = budget; d->m_includeBudgetActuals = fa;
 }
 
 bool MyMoneyReport::isIncludingBudgetActuals() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeBudgetActuals;
 }
 
 void MyMoneyReport::setIncludingBudgetActuals(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeBudgetActuals = f;
 }
 
 bool MyMoneyReport::isIncludingForecast() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeForecast;
 }
 
 void MyMoneyReport::setIncludingForecast(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeForecast = f;
 }
 
 bool MyMoneyReport::isIncludingMovingAverage() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeMovingAverage;
 }
 
 void MyMoneyReport::setIncludingMovingAverage(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeMovingAverage = f;
 }
 
 int MyMoneyReport::movingAverageDays() const
 {
   Q_D(const MyMoneyReport);
   return d->m_movingAverageDays;
 }
 
 void MyMoneyReport::setMovingAverageDays(int days)
 {
   Q_D(MyMoneyReport);
   d->m_movingAverageDays = days;
 }
 
 bool MyMoneyReport::isIncludingPrice() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includePrice;
 }
 
 void MyMoneyReport::setIncludingPrice(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includePrice = f;
 }
 
 bool MyMoneyReport::isIncludingAveragePrice() const
 {
   Q_D(const MyMoneyReport);
   return d->m_includeAveragePrice;
 }
 
 void MyMoneyReport::setIncludingAveragePrice(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_includeAveragePrice = f;
 }
 
 MyMoneyReport::dataOptionE MyMoneyReport::dataFilter() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataLock;
 }
 
 bool MyMoneyReport::isDataUserDefined() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dataLock == MyMoneyReport::userDefined;
 }
 
 void MyMoneyReport::setDataFilter(dataOptionE u)
 {
   Q_D(MyMoneyReport);
   d->m_dataLock = u;
 }
 
 eMyMoney::TransactionFilter::Date MyMoneyReport::dateRange() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dateLock;
 }
 
 bool MyMoneyReport::isDateUserDefined() const
 {
   Q_D(const MyMoneyReport);
   return d->m_dateLock == TransactionFilter::Date::UserDefined;
 }
 
 /**
   * Set the underlying date filter and LOCK that filter to the specified
   * range.  For example, if @p _u is "CurrentMonth", this report should always
   * be updated to the current month no matter when the report is run.
   *
   * This updating is not entirely automatic, you should update it yourself by
   * calling updateDateFilter.
   *
   * @param _u The date range constant (MyMoneyTransactionFilter::dateRangeE)
   *          which this report should be locked to.
   */
 
 void MyMoneyReport::setDateFilter(TransactionFilter::Date u)
 {
   Q_D(MyMoneyReport);
   d->m_dateLock = u;
   if (u != TransactionFilter::Date::UserDefined)
     MyMoneyTransactionFilter::setDateFilter(u);
 }
 
 void MyMoneyReport::setDateFilter(const QDate& db, const QDate& de)
 {
   MyMoneyTransactionFilter::setDateFilter(db, de);
 }
 
 void MyMoneyReport::updateDateFilter()
 {
   Q_D(MyMoneyReport);
   if (d->m_dateLock != TransactionFilter::Date::UserDefined) MyMoneyTransactionFilter::setDateFilter(d->m_dateLock);
 }
 
 
 bool MyMoneyReport::isMixedTime() const
 {
   Q_D(const MyMoneyReport);
   return d->m_mixedTime;
 }
 
 void MyMoneyReport::setMixedTime(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_mixedTime = f;
 }
 
 int MyMoneyReport::currentDateColumn() const
 {
   Q_D(const MyMoneyReport);
   return d->m_currentDateColumn;
 }
 
 void MyMoneyReport::setCurrentDateColumn(int f)
 {
   Q_D(MyMoneyReport);
   d->m_currentDateColumn = f;
 }
 
 uint MyMoneyReport::settlementPeriod() const
 {
   Q_D(const MyMoneyReport);
   return d->m_settlementPeriod;
 }
 
 void MyMoneyReport::setSettlementPeriod(uint days)
 {
   Q_D(MyMoneyReport);
   d->m_settlementPeriod = days;
 }
 
 bool MyMoneyReport::isShowingSTLTCapitalGains() const
 {
   Q_D(const MyMoneyReport);
   return d->m_showSTLTCapitalGains;
 }
 
 void MyMoneyReport::setShowSTLTCapitalGains(bool f)
 {
   Q_D(MyMoneyReport);
   d->m_showSTLTCapitalGains = f;
 }
 
 QDate MyMoneyReport::termSeparator() const
 {
   Q_D(const MyMoneyReport);
   return d->m_tseparator;
 }
 
 void MyMoneyReport::setTermSeparator(const QDate& date)
 {
   Q_D(MyMoneyReport);
   d->m_tseparator = date;
 }
 
 bool MyMoneyReport::isSkippingZero() const
 {
   Q_D(const MyMoneyReport);
   return d->m_skipZero;
 }
 
 void MyMoneyReport::setSkipZero(int f)
 {
   Q_D(MyMoneyReport);
   d->m_skipZero = f;
 }
 
 void MyMoneyReport::clearTransactionFilter()
 {
   Q_D(MyMoneyReport);
   d->m_accountGroupFilter = false;
   d->m_accountGroups.clear();
 
   MyMoneyTransactionFilter::clear();
 }
 
 void MyMoneyReport::assignFilter(const MyMoneyTransactionFilter& filter)
 {
   MyMoneyTransactionFilter::operator=(filter);
 }
 
 void MyMoneyReport::validDateRange(QDate& db, QDate& de)
 {
   db = fromDate();
   de = toDate();
 
   // if either begin or end date are invalid we have one of the following
   // possible date filters:
   //
   // a) begin date not set - first transaction until given end date
   // b) end date not set   - from given date until last transaction
   // c) both not set       - first transaction until last transaction
   //
   // If there is no transaction in the engine at all, we use the current
   // year as the filter criteria.
 
   if (!db.isValid() || !de.isValid()) {
     QList<MyMoneyTransaction> list = MyMoneyFile::instance()->transactionList(*this);
     QDate tmpBegin, tmpEnd;
 
     if (!list.isEmpty()) {
       qSort(list);
       // try to use the post dates
       tmpBegin = list.front().postDate();
       tmpEnd = list.back().postDate();
       // if the post dates are not valid try the entry dates
       if (!tmpBegin.isValid())
         tmpBegin = list.front().entryDate();
       if (!tmpEnd.isValid())
         tmpEnd = list.back().entryDate();
     }
     // make sure that we leave this function with valid dates no mather what
     if (!tmpBegin.isValid() || !tmpEnd.isValid() || tmpBegin > tmpEnd) {
       tmpBegin = QDate(QDate::currentDate().year(), 1, 1);   // the first date in the file
       tmpEnd = QDate(QDate::currentDate().year(), 12, 31);   // the last date in the file
     }
     if (!db.isValid())
       db = tmpBegin;
     if (!de.isValid())
       de = tmpEnd;
   }
   if (db > de)
     db = de;
 }
 
 bool MyMoneyReport::accountGroups(QList<Account::Type>& list) const
 {
   Q_D(const MyMoneyReport);
   bool result = d->m_accountGroupFilter;
 
   if (result) {
     QList<Account::Type>::const_iterator it_group = d->m_accountGroups.begin();
     while (it_group != d->m_accountGroups.end()) {
       list += (*it_group);
       ++it_group;
     }
   }
   return result;
 }
 
 void MyMoneyReport::addAccountGroup(Account::Type type)
 {
   Q_D(MyMoneyReport);
   if (!d->m_accountGroups.isEmpty() && type != Account::Type::Unknown) {
     if (d->m_accountGroups.contains(type))
       return;
   }
   d->m_accountGroupFilter = true;
   if (type != Account::Type::Unknown)
     d->m_accountGroups.push_back(type);
 }
 
 bool MyMoneyReport::includesAccountGroup(Account::Type type) const
 {
   Q_D(const MyMoneyReport);
   bool result = (! d->m_accountGroupFilter)
                 || (isIncludingTransfers() && d->m_rowType == MyMoneyReport::eExpenseIncome)
                 || d->m_accountGroups.contains(type);
 
   return result;
 }
 
 bool MyMoneyReport::includes(const MyMoneyAccount& acc) const
 {
   Q_D(const MyMoneyReport);
   auto result = false;
 
   if (includesAccountGroup(acc.accountGroup())) {
     switch (acc.accountGroup()) {
       case Account::Type::Income:
       case Account::Type::Expense:
         if (isTax())
           result = (acc.value("Tax") == "Yes") && includesCategory(acc.id());
         else
           result = includesCategory(acc.id());
         break;
       case Account::Type::Asset:
       case Account::Type::Liability:
         if (isLoansOnly())
           result = acc.isLoan() && includesAccount(acc.id());
         else if (isInvestmentsOnly())
           result = acc.isInvest() && includesAccount(acc.id());
         else if (isIncludingTransfers() && d->m_rowType == MyMoneyReport::eExpenseIncome)
           // If transfers are included, ONLY include this account if it is NOT
           // included in the report itself!!
           result = ! includesAccount(acc.id());
         else
           result = includesAccount(acc.id());
         break;
       case Account::Type::Equity:
         if (isInvestmentsOnly())
           result = (isIncludingPrice() || isIncludingAveragePrice()) && acc.isInvest() && includesAccount(acc.id());
         break;
       default:
         result = includesAccount(acc.id());
     }
   }
   return result;
 }
 
 void MyMoneyReport::write(QDomElement& e, QDomDocument *doc, bool anonymous) const
 {
   Q_D(const MyMoneyReport);
   // No matter what changes, be sure to have a 'type' attribute.  Only change
   // the major type if it becomes impossible to maintain compatibility with
   // older versions of the program as new features are added to the reports.
   // Feel free to change the minor type every time a change is made here.
 
   // write report's internals
   if (d->m_reportType == ePivotTable)
     e.setAttribute(d->getAttrName(Report::Attribute::Type), "pivottable 1.15");
   else if (d->m_reportType == eQueryTable)
     e.setAttribute(d->getAttrName(Report::Attribute::Type), "querytable 1.14");
   else if (d->m_reportType == eInfoTable)
     e.setAttribute(d->getAttrName(Report::Attribute::Type), "infotable 1.0");
 
   e.setAttribute(d->getAttrName(Report::Attribute::Group), d->m_group);
   e.setAttribute(d->getAttrName(Report::Attribute::ID), d->m_id);
 
   // write general tab
   if (anonymous) {
     e.setAttribute(d->getAttrName(Report::Attribute::Name), d->m_id);
     e.setAttribute(d->getAttrName(Report::Attribute::Comment), QString(d->m_comment).fill('x'));
   } else {
     e.setAttribute(d->getAttrName(Report::Attribute::Name), d->m_name);
     e.setAttribute(d->getAttrName(Report::Attribute::Comment), d->m_comment);
   }
   e.setAttribute(d->getAttrName(Report::Attribute::ConvertCurrency), d->m_convertCurrency);
   e.setAttribute(d->getAttrName(Report::Attribute::Favorite), d->m_favorite);
   e.setAttribute(d->getAttrName(Report::Attribute::SkipZero), d->m_skipZero);
 
   e.setAttribute(d->getAttrName(Report::Attribute::DateLock), kDateLockText[(int)d->m_dateLock]);
 
   if (d->m_reportType == ePivotTable) {
     // write report's internals
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesActuals), d->m_includeBudgetActuals);
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesForecast), d->m_includeForecast);
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesPrice), d->m_includePrice);
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesAveragePrice), d->m_includeAveragePrice);
     e.setAttribute(d->getAttrName(Report::Attribute::MixedTime), d->m_mixedTime);
     e.setAttribute(d->getAttrName(Report::Attribute::Investments), d->m_investments); // it's setable in rows/columns tab of querytable, but here it is internal setting
 
     // write rows/columns tab
     if (!d->m_budgetId.isEmpty())
       e.setAttribute(d->getAttrName(Report::Attribute::Budget), d->m_budgetId);
 
     e.setAttribute(d->getAttrName(Report::Attribute::RowType), kRowTypeText[d->m_rowType]);
     e.setAttribute(d->getAttrName(Report::Attribute::ShowRowTotals), d->m_showRowTotals);
     e.setAttribute(d->getAttrName(Report::Attribute::ShowColumnTotals), d->m_showColumnTotals);
     e.setAttribute(d->getAttrName(Report::Attribute::Detail), kDetailLevelText[d->m_detailLevel]);
 
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesMovingAverage), d->m_includeMovingAverage);
     if (d->m_includeMovingAverage)
       e.setAttribute(d->getAttrName(Report::Attribute::MovingAverageDays), d->m_movingAverageDays);
 
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesSchedules), d->m_includeSchedules);
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesTransfers), d->m_includeTransfers);
     e.setAttribute(d->getAttrName(Report::Attribute::IncludesUnused), d->m_includeUnusedAccounts);
     e.setAttribute(d->getAttrName(Report::Attribute::ColumnsAreDays), d->m_columnsAreDays);
 
     // write chart tab
     if (d->m_chartType < 0 || d->m_chartType >= kChartTypeText.size()) {
       qDebug("m_chartType out of bounds with %d on report of type %d. Default to none.", d->m_chartType, d->m_reportType);
       e.setAttribute(d->getAttrName(Report::Attribute::ChartType), kChartTypeText[eChartNone]);
     } else
       e.setAttribute(d->getAttrName(Report::Attribute::ChartType), kChartTypeText[d->m_chartType]);
 
     e.setAttribute(d->getAttrName(Report::Attribute::ChartCHGridLines), d->m_chartCHGridLines);
     e.setAttribute(d->getAttrName(Report::Attribute::ChartSVGridLines), d->m_chartSVGridLines);
     e.setAttribute(d->getAttrName(Report::Attribute::ChartDataLabels), d->m_chartDataLabels);
     e.setAttribute(d->getAttrName(Report::Attribute::ChartByDefault), d->m_chartByDefault);
     e.setAttribute(d->getAttrName(Report::Attribute::LogYAxis), d->m_logYaxis);
     e.setAttribute(d->getAttrName(Report::Attribute::ChartLineWidth), d->m_chartLineWidth);
     e.setAttribute(d->getAttrName(Report::Attribute::ColumnType), kColumnTypeText[d->m_columnType]);
     e.setAttribute(d->getAttrName(Report::Attribute::DataLock), kDataLockText[d->m_dataLock]);
     e.setAttribute(d->getAttrName(Report::Attribute::DataRangeStart), d->m_dataRangeStart);
     e.setAttribute(d->getAttrName(Report::Attribute::DataRangeEnd), d->m_dataRangeEnd);
     e.setAttribute(d->getAttrName(Report::Attribute::DataMajorTick), d->m_dataMajorTick);
     e.setAttribute(d->getAttrName(Report::Attribute::DataMinorTick), d->m_dataMinorTick);
     e.setAttribute(d->getAttrName(Report::Attribute::YLabelsPrecision), d->m_yLabelsPrecision);
   } else if (d->m_reportType == eQueryTable) {
     // write rows/columns tab
     e.setAttribute(d->getAttrName(Report::Attribute::RowType), kRowTypeText[d->m_rowType]);
     QStringList columns;
     unsigned qc = d->m_queryColumns;
     unsigned it_qc = eQCbegin;
     unsigned index = 1;
     while (it_qc != eQCend) {
       if (qc & it_qc)
         columns += kQueryColumnsText[index];
       it_qc *= 2;
       index++;
     }
     e.setAttribute(d->getAttrName(Report::Attribute::QueryColumns), columns.join(","));
 
     e.setAttribute(d->getAttrName(Report::Attribute::Tax), d->m_tax);
     e.setAttribute(d->getAttrName(Report::Attribute::Investments), d->m_investments);
     e.setAttribute(d->getAttrName(Report::Attribute::Loans), d->m_loans);
     e.setAttribute(d->getAttrName(Report::Attribute::HideTransactions), d->m_hideTransactions);
     e.setAttribute(d->getAttrName(Report::Attribute::ShowColumnTotals), d->m_showColumnTotals);
     e.setAttribute(d->getAttrName(Report::Attribute::Detail), kDetailLevelText[d->m_detailLevel]);
 
     // write performance tab
     if (d->m_queryColumns & eQCperformance || d->m_queryColumns & eQCcapitalgain)
       e.setAttribute(d->getAttrName(Report::Attribute::InvestmentSum), d->m_investmentSum);
 
     // write capital gains tab
     if (d->m_queryColumns & eQCcapitalgain) {
       if (d->m_investmentSum == MyMoneyReport::eSumSold) {
         e.setAttribute(d->getAttrName(Report::Attribute::SettlementPeriod), d->m_settlementPeriod);
         e.setAttribute(d->getAttrName(Report::Attribute::ShowSTLTCapitalGains), d->m_showSTLTCapitalGains);
         e.setAttribute(d->getAttrName(Report::Attribute::TermsSeparator), d->m_tseparator.toString(Qt::ISODate));
       }
     }
   } else if (d->m_reportType == eInfoTable)
     e.setAttribute(d->getAttrName(Report::Attribute::ShowRowTotals), d->m_showRowTotals);
 
   //
   // Text Filter
   //
 
   QRegExp textfilter;
   if (textFilter(textfilter)) {
     QDomElement f = doc->createElement(d->getElName(Report::Element::Text));
     f.setAttribute(d->getAttrName(Report::Attribute::Pattern), textfilter.pattern());
     f.setAttribute(d->getAttrName(Report::Attribute::CaseSensitive), (textfilter.caseSensitivity() == Qt::CaseSensitive) ? 1 : 0);
     f.setAttribute(d->getAttrName(Report::Attribute::RegEx), (textfilter.patternSyntax() == QRegExp::Wildcard) ? 1 : 0);
     f.setAttribute(d->getAttrName(Report::Attribute::InvertText), MyMoneyTransactionFilter::isInvertingText());
     e.appendChild(f);
   }
 
   //
   // Type & State Filters
   //
   QList<int> typelist;
   if (types(typelist) && ! typelist.empty()) {
     // iterate over payees, and add each one
     QList<int>::const_iterator it_type = typelist.constBegin();
     while (it_type != typelist.constEnd()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::Type));
       p.setAttribute(d->getAttrName(Report::Attribute::Type), kTypeText[*it_type]);
       e.appendChild(p);
 
       ++it_type;
     }
   }
 
   QList<int> statelist;
   if (states(statelist) && ! statelist.empty()) {
     // iterate over payees, and add each one
     QList<int>::const_iterator it_state = statelist.constBegin();
     while (it_state != statelist.constEnd()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::State));
       p.setAttribute(d->getAttrName(Report::Attribute::State), kStateText[*it_state]);
       e.appendChild(p);
 
       ++it_state;
     }
   }
   //
   // Number Filter
   //
 
   QString nrFrom, nrTo;
   if (numberFilter(nrFrom, nrTo)) {
     QDomElement f = doc->createElement(d->getElName(Report::Element::Number));
     f.setAttribute(d->getAttrName(Report::Attribute::From), nrFrom);
     f.setAttribute(d->getAttrName(Report::Attribute::To), nrTo);
     e.appendChild(f);
   }
 
   //
   // Amount Filter
   //
 
   MyMoneyMoney from, to;
   if (amountFilter(from, to)) {    // bool getAmountFilter(MyMoneyMoney&,MyMoneyMoney&);
     QDomElement f = doc->createElement(d->getElName(Report::Element::Amount));
     f.setAttribute(d->getAttrName(Report::Attribute::From), from.toString());
     f.setAttribute(d->getAttrName(Report::Attribute::To), to.toString());
     e.appendChild(f);
   }
 
   //
   // Payees Filter
   //
 
   QStringList payeelist;
   if (payees(payeelist)) {
     if (payeelist.empty()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::Payee));
       e.appendChild(p);
     } else {
       // iterate over payees, and add each one
       QStringList::const_iterator it_payee = payeelist.constBegin();
       while (it_payee != payeelist.constEnd()) {
         QDomElement p = doc->createElement(d->getElName(Report::Element::Payee));
         p.setAttribute(d->getAttrName(Report::Attribute::ID), *it_payee);
         e.appendChild(p);
 
         ++it_payee;
       }
     }
   }
 
   //
   // Tags Filter
   //
 
   QStringList taglist;
   if (tags(taglist)) {
     if (taglist.empty()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::Tag));
       e.appendChild(p);
     } else {
       // iterate over tags, and add each one
       QStringList::const_iterator it_tag = taglist.constBegin();
       while (it_tag != taglist.constEnd()) {
         QDomElement p = doc->createElement(d->getElName(Report::Element::Tag));
         p.setAttribute(d->getAttrName(Report::Attribute::ID), *it_tag);
         e.appendChild(p);
 
         ++it_tag;
       }
     }
   }
 
   //
   // Account Groups Filter
   //
 
   QList<Account::Type> accountgrouplist;
   if (accountGroups(accountgrouplist)) {
     // iterate over accounts, and add each one
     QList<Account::Type>::const_iterator it_group = accountgrouplist.constBegin();
     while (it_group != accountgrouplist.constEnd()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::AccountGroup));
       p.setAttribute(d->getAttrName(Report::Attribute::Group), kAccountTypeText[(int)*it_group]);
       e.appendChild(p);
 
       ++it_group;
     }
   }
 
   //
   // Accounts Filter
   //
 
   QStringList accountlist;
   if (accounts(accountlist)) {
     // iterate over accounts, and add each one
     QStringList::const_iterator it_account = accountlist.constBegin();
     while (it_account != accountlist.constEnd()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::Account));
       p.setAttribute(d->getAttrName(Report::Attribute::ID), *it_account);
       e.appendChild(p);
 
       ++it_account;
     }
   }
 
   //
   // Categories Filter
   //
 
   accountlist.clear();
   if (categories(accountlist)) {
     // iterate over accounts, and add each one
     QStringList::const_iterator it_account = accountlist.constBegin();
     while (it_account != accountlist.constEnd()) {
       QDomElement p = doc->createElement(d->getElName(Report::Element::Category));
       p.setAttribute(d->getAttrName(Report::Attribute::ID), *it_account);
       e.appendChild(p);
 
       ++it_account;
     }
   }
 
   //
   // Date Filter
   //
 
   if (d->m_dateLock == TransactionFilter::Date::UserDefined) {
     QDate dateFrom, dateTo;
     if (dateFilter(dateFrom, dateTo)) {
       QDomElement f = doc->createElement(d->getElName(Report::Element::Dates));
       if (dateFrom.isValid())
         f.setAttribute(d->getAttrName(Report::Attribute::From), dateFrom.toString(Qt::ISODate));
       if (dateTo.isValid())
         f.setAttribute(d->getAttrName(Report::Attribute::To), dateTo.toString(Qt::ISODate));
       e.appendChild(f);
     }
   }
 }
 
 bool MyMoneyReport::read(const QDomElement& e)
 {
   Q_D(MyMoneyReport);
   // The goal of this reading method is 100% backward AND 100% forward
   // compatibility.  Any report ever created with any version of KMyMoney
   // should be able to be loaded by this method (as long as it's one of the
   // report types supported in this version, of course)
 
   if (e.tagName().compare(nodeNames[nnReport]) != 0)
     return false;
 
   // read report's internals
   QString type = e.attribute(d->getAttrName(Report::Attribute::Type));
   if (type.startsWith(QLatin1String("pivottable")))
     d->m_reportType = ePivotTable;
   else if (type.startsWith(QLatin1String("querytable")))
     d->m_reportType = eQueryTable;
   else if (type.startsWith(QLatin1String("infotable")))
     d->m_reportType = eInfoTable;
   else
     return false;
 
   d->m_group = e.attribute(d->getAttrName(Report::Attribute::Group));
   d->m_id = e.attribute(d->getAttrName(Report::Attribute::ID));
 
   clearTransactionFilter();
 
   // read date tab
   QString datelockstr = e.attribute(d->getAttrName(Report::Attribute::DateLock), "userdefined");
   // Handle the pivot 1.2/query 1.1 case where the values were saved as
   // numbers
   bool ok = false;
   int i = datelockstr.toUInt(&ok);
   if (!ok) {
     i = kDateLockText.indexOf(datelockstr);
     if (i == -1)
       i = (int)TransactionFilter::Date::UserDefined;
   }
   setDateFilter(static_cast<TransactionFilter::Date>(i));
 
   // read general tab
   d->m_name = e.attribute(d->getAttrName(Report::Attribute::Name));
   d->m_comment = e.attribute(d->getAttrName(Report::Attribute::Comment), "Extremely old report");
   d->m_convertCurrency = e.attribute(d->getAttrName(Report::Attribute::ConvertCurrency), "1").toUInt();
   d->m_favorite = e.attribute(d->getAttrName(Report::Attribute::Favorite), "0").toUInt();
   d->m_skipZero = e.attribute(d->getAttrName(Report::Attribute::SkipZero), "0").toUInt();
 
   if (d->m_reportType == ePivotTable) {
     // read report's internals
     d->m_includeBudgetActuals = e.attribute(d->getAttrName(Report::Attribute::IncludesActuals), "0").toUInt();
     d->m_includeForecast = e.attribute(d->getAttrName(Report::Attribute::IncludesForecast), "0").toUInt();
     d->m_includePrice = e.attribute(d->getAttrName(Report::Attribute::IncludesPrice), "0").toUInt();
     d->m_includeAveragePrice = e.attribute(d->getAttrName(Report::Attribute::IncludesAveragePrice), "0").toUInt();
     d->m_mixedTime = e.attribute(d->getAttrName(Report::Attribute::MixedTime), "0").toUInt();
     d->m_investments = e.attribute(d->getAttrName(Report::Attribute::Investments), "0").toUInt();
 
     // read rows/columns tab
     if (e.hasAttribute(d->getAttrName(Report::Attribute::Budget)))
       d->m_budgetId = e.attribute(d->getAttrName(Report::Attribute::Budget));
 
     i = kRowTypeText.indexOf(e.attribute(d->getAttrName(Report::Attribute::RowType)));
     if (i != -1)
       setRowType(static_cast<ERowType>(i));
     else
       setRowType(eExpenseIncome);
 
     if (e.hasAttribute(d->getAttrName(Report::Attribute::ShowRowTotals)))
       d->m_showRowTotals = e.attribute(d->getAttrName(Report::Attribute::ShowRowTotals)).toUInt();
     else if (rowType() == eExpenseIncome) // for backward compatibility
       d->m_showRowTotals = true;
     d->m_showColumnTotals = e.attribute(d->getAttrName(Report::Attribute::ShowColumnTotals), "1").toUInt();
 
     //check for reports with older settings which didn't have the detail attribute
     i = kDetailLevelText.indexOf(e.attribute(d->getAttrName(Report::Attribute::Detail)));
     if (i != -1)
       d->m_detailLevel = static_cast<EDetailLevel>(i);
     else
       d->m_detailLevel = eDetailAll;
 
     d->m_includeMovingAverage = e.attribute(d->getAttrName(Report::Attribute::IncludesMovingAverage), "0").toUInt();
     if (d->m_includeMovingAverage)
       d->m_movingAverageDays = e.attribute(d->getAttrName(Report::Attribute::MovingAverageDays), "1").toUInt();
     d->m_includeSchedules = e.attribute(d->getAttrName(Report::Attribute::IncludesSchedules), "0").toUInt();
     d->m_includeTransfers = e.attribute(d->getAttrName(Report::Attribute::IncludesTransfers), "0").toUInt();
     d->m_includeUnusedAccounts = e.attribute(d->getAttrName(Report::Attribute::IncludesUnused), "0").toUInt();
     d->m_columnsAreDays = e.attribute(d->getAttrName(Report::Attribute::ColumnsAreDays), "0").toUInt();
 
     // read chart tab
     i = kChartTypeText.indexOf(e.attribute(d->getAttrName(Report::Attribute::ChartType)));
     if (i != -1)
       d->m_chartType = static_cast<EChartType>(i);
     else
       d->m_chartType = eChartNone;
 
     d->m_chartCHGridLines = e.attribute(d->getAttrName(Report::Attribute::ChartCHGridLines), "1").toUInt();
     d->m_chartSVGridLines = e.attribute(d->getAttrName(Report::Attribute::ChartSVGridLines), "1").toUInt();
     d->m_chartDataLabels = e.attribute(d->getAttrName(Report::Attribute::ChartDataLabels), "1").toUInt();
     d->m_chartByDefault = e.attribute(d->getAttrName(Report::Attribute::ChartByDefault), "0").toUInt();
     d->m_logYaxis = e.attribute(d->getAttrName(Report::Attribute::LogYAxis), "0").toUInt();
     d->m_chartLineWidth = e.attribute(d->getAttrName(Report::Attribute::ChartLineWidth), QString(m_lineWidth)).toUInt();
 
     // read range tab
     i = kColumnTypeText.indexOf(e.attribute(d->getAttrName(Report::Attribute::ColumnType)));
     if (i != -1)
       setColumnType(static_cast<EColumnType>(i));
     else
       setColumnType(eMonths);
 
     i = kDataLockText.indexOf(e.attribute(d->getAttrName(Report::Attribute::DataLock)));
     if (i != -1)
       setDataFilter(static_cast<dataOptionE>(i));
     else
       setDataFilter(MyMoneyReport::automatic);
 
     d->m_dataRangeStart = e.attribute(d->getAttrName(Report::Attribute::DataRangeStart), "0");
     d->m_dataRangeEnd= e.attribute(d->getAttrName(Report::Attribute::DataRangeEnd), "0");
     d->m_dataMajorTick = e.attribute(d->getAttrName(Report::Attribute::DataMajorTick), "0");
     d->m_dataMinorTick = e.attribute(d->getAttrName(Report::Attribute::DataMinorTick), "0");
     d->m_yLabelsPrecision = e.attribute(d->getAttrName(Report::Attribute::YLabelsPrecision), "2").toUInt();
   } else if (d->m_reportType == eQueryTable) {
     // read rows/columns tab
     i = kRowTypeText.indexOf(e.attribute(d->getAttrName(Report::Attribute::RowType)));
     if (i != -1)
       setRowType(static_cast<ERowType>(i));
     else
       setRowType(eAccount);
 
     unsigned qc = 0;
     QStringList columns = e.attribute(d->getAttrName(Report::Attribute::QueryColumns), "none").split(',');
     foreach (const auto column, columns) {
       i = kQueryColumnsText.indexOf(column);
       if (i > 0)
         qc |= (1 << (i - 1));
     }
     setQueryColumns(static_cast<EQueryColumns>(qc));
 
     d->m_tax = e.attribute(d->getAttrName(Report::Attribute::Tax), "0").toUInt();
     d->m_investments = e.attribute(d->getAttrName(Report::Attribute::Investments), "0").toUInt();
     d->m_loans = e.attribute(d->getAttrName(Report::Attribute::Loans), "0").toUInt();
     d->m_hideTransactions = e.attribute(d->getAttrName(Report::Attribute::HideTransactions), "0").toUInt();
     d->m_showColumnTotals = e.attribute(d->getAttrName(Report::Attribute::ShowColumnTotals), "1").toUInt();
     d->m_detailLevel = kDetailLevelText.indexOf(e.attribute(d->getAttrName(Report::Attribute::Detail), "none")) == eDetailAll ? eDetailAll : eDetailNone;
 
     // read performance or capital gains tab
     if (d->m_queryColumns & eQCperformance)
       d->m_investmentSum = static_cast<EInvestmentSum>(e.attribute(d->getAttrName(Report::Attribute::InvestmentSum), QString().setNum(MyMoneyReport::eSumPeriod)).toInt());
 
     // read capital gains tab
     if (d->m_queryColumns & eQCcapitalgain) {
       d->m_investmentSum = static_cast<EInvestmentSum>(e.attribute(d->getAttrName(Report::Attribute::InvestmentSum), QString().setNum(MyMoneyReport::eSumSold)).toInt());
       if (d->m_investmentSum == MyMoneyReport::eSumSold) {
         d->m_showSTLTCapitalGains = e.attribute(d->getAttrName(Report::Attribute::ShowSTLTCapitalGains), "0").toUInt();
         d->m_settlementPeriod = e.attribute(d->getAttrName(Report::Attribute::SettlementPeriod), "3").toUInt();
         d->m_tseparator = QDate::fromString(e.attribute(d->getAttrName(Report::Attribute::TermsSeparator), QDate::currentDate().addYears(-1).toString(Qt::ISODate)),Qt::ISODate);
       }
     }
   } else if (d->m_reportType == eInfoTable) {
     if (e.hasAttribute(d->getAttrName(Report::Attribute::ShowRowTotals)))
       d->m_showRowTotals = e.attribute(d->getAttrName(Report::Attribute::ShowRowTotals)).toUInt();
     else
       d->m_showRowTotals = true;
   }
 
   QDomNode child = e.firstChild();
   while (!child.isNull() && child.isElement()) {
     QDomElement c = child.toElement();
     if (d->getElName(Report::Element::Text) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::Pattern))) {
       setTextFilter(QRegExp(c.attribute(d->getAttrName(Report::Attribute::Pattern)),
                             c.attribute(d->getAttrName(Report::Attribute::CaseSensitive), "1").toUInt()
                             ? Qt::CaseSensitive : Qt::CaseInsensitive,
                             c.attribute(d->getAttrName(Report::Attribute::RegEx), "1").toUInt()
                             ? QRegExp::Wildcard : QRegExp::RegExp),
                     c.attribute(d->getAttrName(Report::Attribute::InvertText), "0").toUInt());
     }
     if (d->getElName(Report::Element::Type) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::Type))) {
       i = kTypeText.indexOf(c.attribute(d->getAttrName(Report::Attribute::Type)));
       if (i != -1)
         addType(i);
     }
     if (d->getElName(Report::Element::State) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::State))) {
       i = kStateText.indexOf(c.attribute(d->getAttrName(Report::Attribute::State)));
       if (i != -1)
         addState(i);
     }
     if (d->getElName(Report::Element::Number) == c.tagName())
       setNumberFilter(c.attribute(d->getAttrName(Report::Attribute::From)), c.attribute(d->getAttrName(Report::Attribute::To)));
     if (d->getElName(Report::Element::Amount) == c.tagName())
       setAmountFilter(MyMoneyMoney(c.attribute(d->getAttrName(Report::Attribute::From), "0/100")), MyMoneyMoney(c.attribute(d->getAttrName(Report::Attribute::To), "0/100")));
     if (d->getElName(Report::Element::Dates) == c.tagName()) {
       QDate from, to;
       if (c.hasAttribute(d->getAttrName(Report::Attribute::From)))
         from = QDate::fromString(c.attribute(d->getAttrName(Report::Attribute::From)), Qt::ISODate);
       if (c.hasAttribute(d->getAttrName(Report::Attribute::To)))
         to = QDate::fromString(c.attribute(d->getAttrName(Report::Attribute::To)), Qt::ISODate);
       MyMoneyTransactionFilter::setDateFilter(from, to);
     }
     if (d->getElName(Report::Element::Payee) == c.tagName())
       addPayee(c.attribute(d->getAttrName(Report::Attribute::ID)));
     if (d->getElName(Report::Element::Tag) == c.tagName())
       addTag(c.attribute(d->getAttrName(Report::Attribute::ID)));
     if (d->getElName(Report::Element::Category) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::ID)))
       addCategory(c.attribute(d->getAttrName(Report::Attribute::ID)));
     if (d->getElName(Report::Element::Account) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::ID)))
       addAccount(c.attribute(d->getAttrName(Report::Attribute::ID)));
     if (d->getElName(Report::Element::AccountGroup) == c.tagName() && c.hasAttribute(d->getAttrName(Report::Attribute::Group))) {
       i = kAccountTypeText.indexOf(c.attribute(d->getAttrName(Report::Attribute::Group)));
       if (i != -1)
         addAccountGroup(static_cast<Account::Type>(i));
     }
     child = child.nextSibling();
   }
   return true;
 }
 
 void MyMoneyReport::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   QDomElement el = document.createElement(nodeNames[nnReport]);
   write(el, &document, false);
   parent.appendChild(el);
 }
 
 bool MyMoneyReport::hasReferenceTo(const QString& id) const
 {
   QStringList list;
 
   // collect all ids
   accounts(list);
   categories(list);
   payees(list);
   tags(list);
 
   return list.contains(id);
 }
 
 int MyMoneyReport::m_lineWidth = 2;
 bool MyMoneyReport::m_expertMode = false;
 
 void MyMoneyReport::setLineWidth(int width)
 {
   m_lineWidth = width;
 }
 
 void MyMoneyReport::setExpertMode(bool expertMode)
 {
   m_expertMode = expertMode;
 }
 
 QString MyMoneyReport::toString(ERowType type)
 {
   switch(type) {
   case eNoRows             : return "eNoRows";
   case eAssetLiability     : return "eAssetLiability";
   case eExpenseIncome      : return "eExpenseIncome";
   case eCategory           : return "eCategory";
   case eTopCategory        : return "eTopCategory";
   case eAccount            : return "eAccount";
   case eTag                : return "eTag";
   case ePayee              : return "ePayee";
   case eMonth              : return "eMonth";
   case eWeek               : return "eWeek";
   case eTopAccount         : return "eTopAccount";
   case eAccountByTopAccount: return "eAccountByTopAccount";
   case eEquityType         : return "eEquityType";
   case eAccountType        : return "eAccountType";
   case eInstitution        : return "eInstitution";
   case eBudget             : return "eBudget";
   case eBudgetActual       : return "eBudgetActual";
   case eSchedule           : return "eSchedule";
   case eAccountInfo        : return "eAccountInfo";
   case eAccountLoanInfo    : return "eAccountLoanInfo";
   case eAccountReconcile   : return "eAccountReconcile";
   case eCashFlow           : return "eCashFlow";
   default                  : return "undefined";
   }
 }
 
 QString MyMoneyReport::toString(MyMoneyReport::EReportType type)
 {
   switch(type) {
   case eNoReport:   return "eNoReport";
   case ePivotTable: return "ePivotTable";
   case eQueryTable: return "eQueryTable";
   case eInfoTable:  return "eInfoTable";
   default:          return "undefined";
   }
 }
diff --git a/kmymoney/mymoney/mymoneyschedule.cpp b/kmymoney/mymoney/mymoneyschedule.cpp
index 6d51eec87..69300d1e6 100644
--- a/kmymoney/mymoney/mymoneyschedule.cpp
+++ b/kmymoney/mymoney/mymoneyschedule.cpp
@@ -1,1550 +1,1550 @@
 /***************************************************************************
                           mymoneyschedule.cpp
                              -------------------
     copyright            : (C) 2000-2002 by Michael Edwardes <mte@users.sourceforge.net>
                            (C) 2007 by 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 "mymoneyschedule.h"
 #include "mymoneyschedule_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QMap>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyutils.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysplit.h"
 #include "imymoneyprocessingcalendar.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 using namespace eMyMoney;
 
 static IMyMoneyProcessingCalendar* processingCalendarPtr = 0;
 
 MyMoneySchedule::MyMoneySchedule() :
     MyMoneyObject(*new MyMoneySchedulePrivate)
 {
 }
 
 MyMoneySchedule::MyMoneySchedule(const QString& name,
                                  Schedule::Type type,
                                  Schedule::Occurrence occurrence,
                                  int occurrenceMultiplier,
                                  Schedule::PaymentType paymentType,
                                  const QDate& /* startDate */,
                                  const QDate& endDate,
                                  bool fixed,
                                  bool autoEnter) :
     MyMoneyObject(*new MyMoneySchedulePrivate)
 {
   Q_D(MyMoneySchedule);
   // Set up the values possibly differeing from defaults
   d->m_name = name;
   d->m_occurrence = occurrence;
   d->m_occurrenceMultiplier = occurrenceMultiplier;
   simpleToCompoundOccurrence(d->m_occurrenceMultiplier, d->m_occurrence);
   d->m_type = type;
   d->m_paymentType = paymentType;
   d->m_fixed = fixed;
   d->m_autoEnter = autoEnter;
   d->m_endDate = endDate;
 }
 
 MyMoneySchedule::MyMoneySchedule(const QDomElement& node) :
     MyMoneyObject(*new MyMoneySchedulePrivate, node)
 {
   if (nodeNames[nnScheduleTX] != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not SCHEDULED_TX");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not SCHEDULED_TX");
 
   Q_D(MyMoneySchedule);
   d->m_name = node.attribute(d->getAttrName(Schedule::Attribute::Name));
   d->m_startDate = MyMoneyUtils::stringToDate(node.attribute(d->getAttrName(Schedule::Attribute::StartDate)));
   d->m_endDate = MyMoneyUtils::stringToDate(node.attribute(d->getAttrName(Schedule::Attribute::EndDate)));
   d->m_lastPayment = MyMoneyUtils::stringToDate(node.attribute(d->getAttrName(Schedule::Attribute::LastPayment)));
 
   d->m_type = static_cast<Schedule::Type>(node.attribute(d->getAttrName(Schedule::Attribute::Type)).toInt());
   d->m_paymentType = static_cast<Schedule::PaymentType>(node.attribute(d->getAttrName(Schedule::Attribute::PaymentType)).toInt());
   d->m_occurrence = static_cast<Schedule::Occurrence>(node.attribute(d->getAttrName(Schedule::Attribute::Occurrence)).toInt());
   d->m_occurrenceMultiplier = node.attribute(d->getAttrName(Schedule::Attribute::OccurrenceMultiplier), "1").toInt();
   // Convert to compound occurrence
   simpleToCompoundOccurrence(d->m_occurrenceMultiplier, d->m_occurrence);
   d->m_lastDayInMonth = static_cast<bool>(node.attribute("lastDayInMonth").toInt());
   d->m_autoEnter = static_cast<bool>(node.attribute(d->getAttrName(Schedule::Attribute::AutoEnter)).toInt());
   d->m_fixed = static_cast<bool>(node.attribute(d->getAttrName(Schedule::Attribute::Fixed)).toInt());
   d->m_weekendOption = static_cast<Schedule::WeekendOption>(node.attribute(d->getAttrName(Schedule::Attribute::WeekendOption)).toInt());
 
   // read in the associated transaction
   QDomNodeList nodeList = node.elementsByTagName(nodeNames[nnTransaction]);
   if (nodeList.count() == 0)
-    throw MYMONEYEXCEPTION("SCHEDULED_TX has no TRANSACTION node");
+    throw MYMONEYEXCEPTION_CSTRING("SCHEDULED_TX has no TRANSACTION node");
 
   setTransaction(MyMoneyTransaction(nodeList.item(0).toElement(), false), true);
 
   // some old versions did not remove the entry date and post date fields
   // in the schedule. So if this is the case, we deal with a very old transaction
   // and can't use the post date field as next due date. Hence, we wipe it out here
   if (d->m_transaction.entryDate().isValid()) {
     d->m_transaction.setPostDate(QDate());
     d->m_transaction.setEntryDate(QDate());
   }
 
   // readin the recorded payments
   nodeList = node.elementsByTagName(d->getElName(Schedule::Element::Payments));
   if (nodeList.count() > 0) {
     nodeList = nodeList.item(0).toElement().elementsByTagName(d->getElName(Schedule::Element::Payment));
     for (int i = 0; i < nodeList.count(); ++i) {
       d->m_recordedPayments << MyMoneyUtils::stringToDate(nodeList.item(i).toElement().attribute(d->getAttrName(Schedule::Attribute::Date)));
     }
   }
 
   // if the next due date is not set (comes from old version)
   // then set it up the old way
   if (!nextDueDate().isValid() && !d->m_lastPayment.isValid()) {
     d->m_transaction.setPostDate(d->m_startDate);
     // clear it, because the schedule has never been used
     d->m_startDate = QDate();
   }
 
   // There are reports that lastPayment and nextDueDate are identical or
   // that nextDueDate is older than lastPayment. This could
   // be caused by older versions of the application. In this case, we just
   // clear out the nextDueDate and let it calculate from the lastPayment.
   if (nextDueDate().isValid() && nextDueDate() <= d->m_lastPayment) {
     d->m_transaction.setPostDate(QDate());
   }
 
   if (!nextDueDate().isValid()) {
     d->m_transaction.setPostDate(d->m_startDate);
     d->m_transaction.setPostDate(nextPayment(d->m_lastPayment.addDays(1)));
   }
 }
 
 MyMoneySchedule::MyMoneySchedule(const MyMoneySchedule& other) :
   MyMoneyObject(*new MyMoneySchedulePrivate(*other.d_func()), other.id())
 {
 }
 
 MyMoneySchedule::MyMoneySchedule(const QString& id, const MyMoneySchedule& other) :
   MyMoneyObject(*new MyMoneySchedulePrivate(*other.d_func()), id)
 {
 }
 
 MyMoneySchedule::~MyMoneySchedule()
 {
 }
 
 Schedule::Occurrence MyMoneySchedule::occurrence() const
 {
   Q_D(const MyMoneySchedule);
   Schedule::Occurrence occ = d->m_occurrence;
   int mult = d->m_occurrenceMultiplier;
   compoundToSimpleOccurrence(mult, occ);
   return occ;
 }
 
 int MyMoneySchedule::occurrenceMultiplier() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_occurrenceMultiplier;
 }
 
 eMyMoney::Schedule::Type MyMoneySchedule::type() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_type;
 }
 
 eMyMoney::Schedule::Occurrence MyMoneySchedule::occurrencePeriod() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_occurrence;
 }
 
 void MyMoneySchedule::setStartDate(const QDate& date)
 {
   Q_D(MyMoneySchedule);
   d->m_startDate = date;
 }
 
 void MyMoneySchedule::setPaymentType(Schedule::PaymentType type)
 {
   Q_D(MyMoneySchedule);
   d->m_paymentType = type;
 }
 
 void MyMoneySchedule::setFixed(bool fixed)
 {
   Q_D(MyMoneySchedule);
   d->m_fixed = fixed;
 }
 
 void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction)
 {
   setTransaction(transaction, false);
 }
 
 void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction, bool noDateCheck)
 {
   auto t = transaction;
   Q_D(MyMoneySchedule);
   if (!noDateCheck) {
     // don't allow a transaction that has no due date
     // if we get something like that, then we use the
     // the current next due date. If that is also invalid
     // we can't help it.
     if (!t.postDate().isValid()) {
       t.setPostDate(d->m_transaction.postDate());
     }
 
     if (!t.postDate().isValid())
       return;
   }
 
   // make sure to clear out some unused information in scheduled transactions
   // we need to do this for the case that the transaction passed as argument
   // is a matched or imported transaction.
   auto firstSplit = true;
   foreach (const auto split, t.splits()) {
     MyMoneySplit s = split;
     // clear out the bankID
     if (!split.bankID().isEmpty()) {
       s.setBankID(QString());
       t.modifySplit(s);
     }
 
     // only clear payees from second split onwards
     if (firstSplit) {
       firstSplit = false;
       continue;
     }
 
     if (!split.payeeId().isEmpty()) {
       // but only if the split references an income/expense category
       auto file = MyMoneyFile::instance();
       // some unit tests don't have a storage attached, so we
       // simply skip the test
       // Don't check for accounts with an id of 'Phony-ID' which is used
       // internally for non-existing accounts (during creation of accounts)
       if (file->storageAttached() && s.accountId() != QString("Phony-ID")) {
         auto acc = file->account(s.accountId());
         if (acc.isIncomeExpense()) {
           s.setPayeeId(QString());
           t.modifySplit(s);
         }
       }
     }
   }
 
   d->m_transaction = t;
   // make sure that the transaction does not have an id so that we can enter
   // it into the engine
   d->m_transaction.clearId();
 }
 
 void MyMoneySchedule::setEndDate(const QDate& date)
 {
   Q_D(MyMoneySchedule);
   d->m_endDate = date;
 }
 
 void MyMoneySchedule::setLastDayInMonth(bool state)
 {
   Q_D(MyMoneySchedule);
   d->m_lastDayInMonth = state;
 }
 
 void MyMoneySchedule::setAutoEnter(bool autoenter)
 {
   Q_D(MyMoneySchedule);
   d->m_autoEnter = autoenter;
 }
 
 QDate MyMoneySchedule::startDate() const
 {
   Q_D(const MyMoneySchedule);
   if (d->m_startDate.isValid())
     return d->m_startDate;
   return nextDueDate();
 }
 
 eMyMoney::Schedule::PaymentType MyMoneySchedule::paymentType() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_paymentType;
 }
 
 /**
   * Simple get method that returns true if the schedule is fixed.
   *
   * @return bool To indicate whether the instance is fixed.
   */
 bool MyMoneySchedule::isFixed() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_fixed;
 }
 
 /**
   * Simple get method that returns true if the schedule will end
   * at some time.
   *
   * @return bool Indicates whether the instance will end.
   */
 bool MyMoneySchedule::willEnd() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_endDate.isValid();
 }
 
 
 QDate MyMoneySchedule::nextDueDate() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_transaction.postDate();
 }
 
 QDate MyMoneySchedule::adjustedNextDueDate() const
 {
   if (isFinished())
     return QDate();
 
   if (lastDayInMonth()) {
     QDate date = nextDueDate();
     return adjustedDate(QDate(date.year(), date.month(), date.daysInMonth()), weekendOption());
   }
 
   return adjustedDate(nextDueDate(), weekendOption());
 }
 
 QDate MyMoneySchedule::adjustedDate(QDate date, Schedule::WeekendOption option) const
 {
   if (!date.isValid() || option == Schedule::WeekendOption::MoveNothing || isProcessingDate(date))
     return date;
 
   int step = 1;
   if (option == Schedule::WeekendOption::MoveBefore)
     step = -1;
 
   while (!isProcessingDate(date))
     date = date.addDays(step);
 
   return date;
 }
 
 void MyMoneySchedule::setNextDueDate(const QDate& date)
 {
   Q_D(MyMoneySchedule);
   if (date.isValid()) {
     d->m_transaction.setPostDate(date);
     // m_startDate = date;
   }
 }
 
 void MyMoneySchedule::setLastPayment(const QDate& date)
 {
   Q_D(MyMoneySchedule);
   // Delete all payments older than date
   QList<QDate>::Iterator it;
   QList<QDate> delList;
 
   for (it = d->m_recordedPayments.begin(); it != d->m_recordedPayments.end(); ++it) {
     if (*it < date || !date.isValid())
       delList.append(*it);
   }
 
   for (it = delList.begin(); it != delList.end(); ++it) {
     d->m_recordedPayments.removeAll(*it);
   }
 
   d->m_lastPayment = date;
   if (!d->m_startDate.isValid())
     d->m_startDate = date;
 }
 
 QString MyMoneySchedule::name() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_name;
 }
 
 void MyMoneySchedule::setName(const QString& nm)
 {
   Q_D(MyMoneySchedule);
   d->m_name = nm;
 }
 
 eMyMoney::Schedule::WeekendOption MyMoneySchedule::weekendOption() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_weekendOption;
 }
 
 void MyMoneySchedule::setOccurrence(Schedule::Occurrence occ)
 {
   auto occ2 = occ;
   auto mult = 1;
   simpleToCompoundOccurrence(mult, occ2);
   setOccurrencePeriod(occ2);
   setOccurrenceMultiplier(mult);
 }
 
 void MyMoneySchedule::setOccurrencePeriod(Schedule::Occurrence occ)
 {
   Q_D(MyMoneySchedule);
   d->m_occurrence = occ;
 }
 
 void MyMoneySchedule::setOccurrenceMultiplier(int occmultiplier)
 {
   Q_D(MyMoneySchedule);
   d->m_occurrenceMultiplier = occmultiplier < 1 ? 1 : occmultiplier;
 }
 
 void MyMoneySchedule::setType(Schedule::Type type)
 {
   Q_D(MyMoneySchedule);
   d->m_type = type;
 }
 
 void MyMoneySchedule::validate(bool id_check) const
 {
   /* Check the supplied instance is valid...
    *
    * To be valid it must not have the id set and have the following fields set:
    *
    * m_occurrence
    * m_type
    * m_startDate
    * m_paymentType
    * m_transaction
    *   the transaction must contain at least one split (two is better ;-)  )
    */
   Q_D(const MyMoneySchedule);
   if (id_check && !d->m_id.isEmpty())
-    throw MYMONEYEXCEPTION("ID for schedule not empty when required");
+    throw MYMONEYEXCEPTION_CSTRING("ID for schedule not empty when required");
 
   if (d->m_occurrence == Schedule::Occurrence::Any)
-    throw MYMONEYEXCEPTION("Invalid occurrence type for schedule");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid occurrence type for schedule");
 
   if (d->m_type == Schedule::Type::Any)
-    throw MYMONEYEXCEPTION("Invalid type for schedule");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid type for schedule");
 
   if (!nextDueDate().isValid())
-    throw MYMONEYEXCEPTION("Invalid next due date for schedule");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid next due date for schedule");
 
   if (d->m_paymentType == Schedule::PaymentType::Any)
-    throw MYMONEYEXCEPTION("Invalid payment type for schedule");
+    throw MYMONEYEXCEPTION_CSTRING("Invalid payment type for schedule");
 
   if (d->m_transaction.splitCount() == 0)
-    throw MYMONEYEXCEPTION("Scheduled transaction does not contain splits");
+    throw MYMONEYEXCEPTION_CSTRING("Scheduled transaction does not contain splits");
 
   // Check the payment types
   switch (d->m_type) {
     case Schedule::Type::Bill:
       if (d->m_paymentType == Schedule::PaymentType::DirectDeposit || d->m_paymentType == Schedule::PaymentType::ManualDeposit)
-        throw MYMONEYEXCEPTION("Invalid payment type for bills");
+        throw MYMONEYEXCEPTION_CSTRING("Invalid payment type for bills");
       break;
 
     case Schedule::Type::Deposit:
       if (d->m_paymentType == Schedule::PaymentType::DirectDebit || d->m_paymentType == Schedule::PaymentType::WriteChecque)
-        throw MYMONEYEXCEPTION("Invalid payment type for deposits");
+        throw MYMONEYEXCEPTION_CSTRING("Invalid payment type for deposits");
       break;
 
     case Schedule::Type::Any:
-      throw MYMONEYEXCEPTION("Invalid type ANY");
+      throw MYMONEYEXCEPTION_CSTRING("Invalid type ANY");
       break;
 
     case Schedule::Type::Transfer:
 //        if (m_paymentType == DirectDeposit || m_paymentType == ManualDeposit)
 //          return false;
       break;
 
     case Schedule::Type::LoanPayment:
       break;
   }
 }
 
 QDate MyMoneySchedule::adjustedNextPayment(const QDate& refDate) const
 {
   return nextPaymentDate(true, refDate);
 }
 
 QDate MyMoneySchedule::adjustedNextPayment() const
 {
   return adjustedNextPayment(QDate::currentDate());
 }
 
 QDate MyMoneySchedule::nextPayment(const QDate& refDate) const
 {
   return nextPaymentDate(false, refDate);
 }
 
 QDate MyMoneySchedule::nextPayment() const
 {
   return nextPayment(QDate::currentDate());
 }
 
 QDate MyMoneySchedule::nextPaymentDate(const bool& adjust, const QDate& refDate) const
 {
   Schedule::WeekendOption option(adjust ? weekendOption() :
                         Schedule::WeekendOption::MoveNothing);
 
   Q_D(const MyMoneySchedule);
   QDate adjEndDate(adjustedDate(d->m_endDate, option));
 
   // if the enddate is valid and it is before the reference date,
   // then there will be no more payments.
   if (adjEndDate.isValid() && adjEndDate < refDate) {
     return QDate();
   }
 
   QDate dueDate(nextDueDate());
   QDate paymentDate(adjustedDate(dueDate, option));
 
   if (paymentDate.isValid() &&
       (paymentDate <= refDate || d->m_recordedPayments.contains(dueDate))) {
     switch (d->m_occurrence) {
       case Schedule::Occurrence::Once:
         // If the lastPayment is already set or the payment should have been
         // prior to the reference date then invalidate the payment date.
         if (d->m_lastPayment.isValid() || paymentDate <= refDate)
           paymentDate = QDate();
         break;
 
       case Schedule::Occurrence::Daily: {
           int step = d->m_occurrenceMultiplier;
           do {
             dueDate = dueDate.addDays(step);
             paymentDate = adjustedDate(dueDate, option);
           } while (paymentDate.isValid() &&
                    (paymentDate <= refDate ||
                     d->m_recordedPayments.contains(dueDate)));
         }
         break;
 
       case Schedule::Occurrence::Weekly: {
           int step = 7 * d->m_occurrenceMultiplier;
           do {
             dueDate = dueDate.addDays(step);
             paymentDate = adjustedDate(dueDate, option);
           } while (paymentDate.isValid() &&
                    (paymentDate <= refDate ||
                     d->m_recordedPayments.contains(dueDate)));
         }
         break;
 
       case Schedule::Occurrence::EveryHalfMonth:
         do {
           dueDate = addHalfMonths(dueDate, d->m_occurrenceMultiplier);
           paymentDate = adjustedDate(dueDate, option);
         } while (paymentDate.isValid() &&
                  (paymentDate <= refDate ||
                   d->m_recordedPayments.contains(dueDate)));
         break;
 
       case Schedule::Occurrence::Monthly:
         do {
           dueDate = dueDate.addMonths(d->m_occurrenceMultiplier);
           fixDate(dueDate);
           paymentDate = adjustedDate(dueDate, option);
         } while (paymentDate.isValid() &&
                  (paymentDate <= refDate ||
                   d->m_recordedPayments.contains(dueDate)));
         break;
 
       case Schedule::Occurrence::Yearly:
         do {
           dueDate = dueDate.addYears(d->m_occurrenceMultiplier);
           fixDate(dueDate);
           paymentDate = adjustedDate(dueDate, option);
         } while (paymentDate.isValid() &&
                  (paymentDate <= refDate ||
                   d->m_recordedPayments.contains(dueDate)));
         break;
 
       case Schedule::Occurrence::Any:
       default:
         paymentDate = QDate();
         break;
     }
   }
   if (paymentDate.isValid() && adjEndDate.isValid() && paymentDate > adjEndDate)
     paymentDate = QDate();
 
   return paymentDate;
 }
 
 QDate MyMoneySchedule::nextPaymentDate(const bool& adjust) const
 {
   return nextPaymentDate(adjust, QDate::currentDate());
 }
 
 QList<QDate> MyMoneySchedule::paymentDates(const QDate& _startDate, const QDate& _endDate) const
 {
   QDate paymentDate(nextDueDate());
   QList<QDate> theDates;
 
   Schedule::WeekendOption option(weekendOption());
 
   Q_D(const MyMoneySchedule);
   QDate endDate(_endDate);
   if (willEnd() && d->m_endDate < endDate) {
     // consider the adjusted end date instead of the plain end date
     endDate = adjustedDate(d->m_endDate, option);
   }
 
   QDate start_date(adjustedDate(startDate(), option));
   // if the period specified by the parameters and the adjusted period
   // defined for this schedule don't overlap, then the list remains empty
   if ((willEnd() && adjustedDate(d->m_endDate, option) < _startDate)
       || start_date > endDate)
     return theDates;
 
   QDate date(adjustedDate(paymentDate, option));
 
   switch (d->m_occurrence) {
     case Schedule::Occurrence::Once:
       if (start_date >= _startDate && start_date <= endDate)
         theDates.append(start_date);
       break;
 
     case Schedule::Occurrence::Daily:
       while (date.isValid() && (date <= endDate)) {
         if (date >= _startDate)
           theDates.append(date);
         paymentDate = paymentDate.addDays(d->m_occurrenceMultiplier);
         date = adjustedDate(paymentDate, option);
       }
       break;
 
     case Schedule::Occurrence::Weekly: {
         int step = 7 * d->m_occurrenceMultiplier;
         while (date.isValid() && (date <= endDate)) {
           if (date >= _startDate)
             theDates.append(date);
           paymentDate = paymentDate.addDays(step);
           date = adjustedDate(paymentDate, option);
         }
       }
       break;
 
     case Schedule::Occurrence::EveryHalfMonth:
       while (date.isValid() && (date <= endDate)) {
         if (date >= _startDate)
           theDates.append(date);
         paymentDate = addHalfMonths(paymentDate, d->m_occurrenceMultiplier);
         date = adjustedDate(paymentDate, option);
       }
       break;
 
     case Schedule::Occurrence::Monthly:
       while (date.isValid() && (date <= endDate)) {
         if (date >= _startDate)
           theDates.append(date);
         paymentDate = paymentDate.addMonths(d->m_occurrenceMultiplier);
         fixDate(paymentDate);
         date = adjustedDate(paymentDate, option);
       }
       break;
 
     case Schedule::Occurrence::Yearly:
       while (date.isValid() && (date <= endDate)) {
         if (date >= _startDate)
           theDates.append(date);
         paymentDate = paymentDate.addYears(d->m_occurrenceMultiplier);
         fixDate(paymentDate);
         date = adjustedDate(paymentDate, option);
       }
       break;
 
     case Schedule::Occurrence::Any:
     default:
       break;
   }
 
   return theDates;
 }
 
 bool MyMoneySchedule::operator <(const MyMoneySchedule& right) const
 {
   return adjustedNextDueDate() < right.adjustedNextDueDate();
 }
 
 bool MyMoneySchedule::operator ==(const MyMoneySchedule& right) const
 {
   Q_D(const MyMoneySchedule);
   auto d2 = static_cast<const MyMoneySchedulePrivate *>(right.d_func());
   if (MyMoneyObject::operator==(right) &&
       d->m_occurrence == d2->m_occurrence &&
       d->m_occurrenceMultiplier == d2->m_occurrenceMultiplier &&
       d->m_type == d2->m_type &&
       d->m_startDate == d2->m_startDate &&
       d->m_paymentType == d2->m_paymentType &&
       d->m_fixed == d2->m_fixed &&
       d->m_transaction == d2->m_transaction &&
       d->m_endDate == d2->m_endDate &&
       d->m_lastDayInMonth == d2->m_lastDayInMonth &&
       d->m_autoEnter == d2->m_autoEnter &&
       d->m_lastPayment == d2->m_lastPayment &&
       ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)))
     return true;
   return false;
 }
 
 bool MyMoneySchedule::operator !=(const MyMoneySchedule& right) const
 {
   return ! operator==(right);
 }
 
 int MyMoneySchedule::transactionsRemaining() const
 {
   Q_D(const MyMoneySchedule);
   return transactionsRemainingUntil(adjustedDate(d->m_endDate, weekendOption()));
 }
 
 int MyMoneySchedule::transactionsRemainingUntil(const QDate& endDate) const
 {
   auto counter = 0;
   Q_D(const MyMoneySchedule);
 
   QDate startDate = d->m_lastPayment.isValid() ? d->m_lastPayment : d->m_startDate;
   if (startDate.isValid() && endDate.isValid()) {
     QList<QDate> dates = paymentDates(startDate, endDate);
     counter = dates.count();
   }
   return counter;
 }
 
 QDate MyMoneySchedule::endDate() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_endDate;
 }
 
 bool MyMoneySchedule::autoEnter() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_autoEnter;
 }
 
 bool MyMoneySchedule::lastDayInMonth() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_lastDayInMonth;
 }
 
 MyMoneyTransaction MyMoneySchedule::transaction() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_transaction;
 }
 
 QDate MyMoneySchedule::lastPayment() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_lastPayment;
 }
 
 MyMoneyAccount MyMoneySchedule::account(int cnt) const
 {
   Q_D(const MyMoneySchedule);
   QList<MyMoneySplit> splits = d->m_transaction.splits();
   QList<MyMoneySplit>::ConstIterator it;
   auto file = MyMoneyFile::instance();
   MyMoneyAccount acc;
 
   // search the first asset or liability account
   for (it = splits.constBegin(); it != splits.constEnd() && (acc.id().isEmpty() || cnt); ++it) {
     try {
       acc = file->account((*it).accountId());
       if (acc.isAssetLiability())
         --cnt;
 
       if (!cnt)
         return acc;
     } catch (const MyMoneyException &) {
       qWarning("Schedule '%s' references unknown account '%s'", qPrintable(id()),   qPrintable((*it).accountId()));
       return MyMoneyAccount();
     }
   }
 
   return MyMoneyAccount();
 }
 
 MyMoneyAccount MyMoneySchedule::transferAccount() const {
   return account(2);
 }
 
 QDate MyMoneySchedule::dateAfter(int transactions) const
 {
   auto counter = 1;
   QDate paymentDate(startDate());
 
   if (transactions <= 0)
     return paymentDate;
 
   Q_D(const MyMoneySchedule);
   switch (d->m_occurrence) {
     case Schedule::Occurrence::Once:
       break;
 
     case Schedule::Occurrence::Daily:
       while (counter++ < transactions)
         paymentDate = paymentDate.addDays(d->m_occurrenceMultiplier);
       break;
 
     case Schedule::Occurrence::Weekly: {
         int step = 7 * d->m_occurrenceMultiplier;
         while (counter++ < transactions)
           paymentDate = paymentDate.addDays(step);
       }
       break;
 
     case Schedule::Occurrence::EveryHalfMonth:
       paymentDate = addHalfMonths(paymentDate, d->m_occurrenceMultiplier * (transactions - 1));
       break;
 
     case Schedule::Occurrence::Monthly:
       while (counter++ < transactions)
         paymentDate = paymentDate.addMonths(d->m_occurrenceMultiplier);
       break;
 
     case Schedule::Occurrence::Yearly:
       while (counter++ < transactions)
         paymentDate = paymentDate.addYears(d->m_occurrenceMultiplier);
       break;
 
     case Schedule::Occurrence::Any:
     default:
       break;
   }
 
   return paymentDate;
 }
 
 bool MyMoneySchedule::isOverdue() const
 {
   if (isFinished())
     return false;
 
   if (adjustedNextDueDate() >= QDate::currentDate())
     return false;
 
   return true;
 }
 
 bool MyMoneySchedule::isFinished() const
 {
   Q_D(const MyMoneySchedule);
   if (!d->m_lastPayment.isValid())
     return false;
 
   if (d->m_endDate.isValid()) {
     if (d->m_lastPayment >= d->m_endDate
         || !nextDueDate().isValid()
         || nextDueDate() > d->m_endDate)
       return true;
   }
 
   // Check to see if its a once off payment
   if (d->m_occurrence == Schedule::Occurrence::Once)
     return true;
 
   return false;
 }
 
 bool MyMoneySchedule::hasRecordedPayment(const QDate& date) const
 {
   Q_D(const MyMoneySchedule);
   // m_lastPayment should always be > recordedPayments()
   if (d->m_lastPayment.isValid() && d->m_lastPayment >= date)
     return true;
 
   if (d->m_recordedPayments.contains(date))
     return true;
 
   return false;
 }
 
 void MyMoneySchedule::recordPayment(const QDate& date)
 {
   Q_D(MyMoneySchedule);
   d->m_recordedPayments.append(date);
 }
 
 QList<QDate> MyMoneySchedule::recordedPayments() const
 {
   Q_D(const MyMoneySchedule);
   return d->m_recordedPayments;
 }
 
 void MyMoneySchedule::setWeekendOption(const Schedule::WeekendOption option)
 {
   Q_D(MyMoneySchedule);
   // make sure only valid values are used. Invalid defaults to MoveNothing.
   switch (option) {
     case Schedule::WeekendOption::MoveBefore:
     case Schedule::WeekendOption::MoveAfter:
       d->m_weekendOption = option;
       break;
 
     default:
       d->m_weekendOption = Schedule::WeekendOption::MoveNothing;
       break;
   }
 }
 
 void MyMoneySchedule::fixDate(QDate& date) const
 {
   Q_D(const MyMoneySchedule);
   QDate fixDate(d->m_startDate);
   if (fixDate.isValid()
       && date.day() != fixDate.day()
       && QDate::isValid(date.year(), date.month(), fixDate.day())) {
     date = QDate(date.year(), date.month(), fixDate.day());
   }
 }
 
 void MyMoneySchedule::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   auto el = document.createElement(nodeNames[nnScheduleTX]);
 
   Q_D(const MyMoneySchedule);
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Schedule::Attribute::Name), d->m_name);
   el.setAttribute(d->getAttrName(Schedule::Attribute::Type), (int)d->m_type);
   el.setAttribute(d->getAttrName(Schedule::Attribute::Occurrence), (int)d->m_occurrence);
   el.setAttribute(d->getAttrName(Schedule::Attribute::OccurrenceMultiplier), d->m_occurrenceMultiplier);
   el.setAttribute(d->getAttrName(Schedule::Attribute::PaymentType), (int)d->m_paymentType);
   el.setAttribute(d->getAttrName(Schedule::Attribute::StartDate), MyMoneyUtils::dateToString(d->m_startDate));
   el.setAttribute(d->getAttrName(Schedule::Attribute::EndDate), MyMoneyUtils::dateToString(d->m_endDate));
   el.setAttribute(d->getAttrName(Schedule::Attribute::Fixed), d->m_fixed);
   el.setAttribute(d->getAttrName(Schedule::Attribute::LastDayInMonth), d->m_lastDayInMonth);
   el.setAttribute(d->getAttrName(Schedule::Attribute::AutoEnter), d->m_autoEnter);
   el.setAttribute(d->getAttrName(Schedule::Attribute::LastPayment), MyMoneyUtils::dateToString(d->m_lastPayment));
   el.setAttribute(d->getAttrName(Schedule::Attribute::WeekendOption), (int)d->m_weekendOption);
 
   //store the payment history for this scheduled task.
   QList<QDate> payments = recordedPayments();
   QList<QDate>::ConstIterator it;
   QDomElement paymentsElement = document.createElement(d->getElName(Schedule::Element::Payments));
   for (it = payments.constBegin(); it != payments.constEnd(); ++it) {
     QDomElement paymentEntry = document.createElement(d->getElName(Schedule::Element::Payment));
     paymentEntry.setAttribute(d->getAttrName(Schedule::Attribute::Date), MyMoneyUtils::dateToString(*it));
     paymentsElement.appendChild(paymentEntry);
   }
   el.appendChild(paymentsElement);
 
   //store the transaction data for this task.
   d->m_transaction.writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneySchedule::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneySchedule);
   return d->m_transaction.hasReferenceTo(id);
 }
 
 QString MyMoneySchedule::occurrenceToString() const
 {
   return occurrenceToString(occurrenceMultiplier(), occurrencePeriod());
 }
 
 QString MyMoneySchedule::occurrenceToString(Schedule::Occurrence occurrence)
 {
   QString occurrenceString = I18N_NOOP2("Frequency of schedule", "Any");
 
   if (occurrence == Schedule::Occurrence::Once)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Once");
   else if (occurrence == Schedule::Occurrence::Daily)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Daily");
   else if (occurrence == Schedule::Occurrence::Weekly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Weekly");
   else if (occurrence == Schedule::Occurrence::Fortnightly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Fortnightly");
   else if (occurrence == Schedule::Occurrence::EveryOtherWeek)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every other week");
   else if (occurrence == Schedule::Occurrence::EveryHalfMonth)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every half month");
   else if (occurrence == Schedule::Occurrence::EveryThreeWeeks)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every three weeks");
   else if (occurrence == Schedule::Occurrence::EveryFourWeeks)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every four weeks");
   else if (occurrence == Schedule::Occurrence::EveryThirtyDays)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every thirty days");
   else if (occurrence == Schedule::Occurrence::Monthly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Monthly");
   else if (occurrence == Schedule::Occurrence::EveryEightWeeks)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every eight weeks");
   else if (occurrence == Schedule::Occurrence::EveryOtherMonth)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every two months");
   else if (occurrence == Schedule::Occurrence::EveryThreeMonths)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every three months");
   else if (occurrence == Schedule::Occurrence::Quarterly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Quarterly");
   else if (occurrence == Schedule::Occurrence::EveryFourMonths)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every four months");
   else if (occurrence == Schedule::Occurrence::TwiceYearly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Twice yearly");
   else if (occurrence == Schedule::Occurrence::Yearly)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Yearly");
   else if (occurrence == Schedule::Occurrence::EveryOtherYear)
     occurrenceString = I18N_NOOP2("Frequency of schedule", "Every other year");
   return occurrenceString;
 }
 
 QString MyMoneySchedule::occurrenceToString(int mult, Schedule::Occurrence type)
 {
   QString occurrenceString = I18N_NOOP2("Frequency of schedule", "Any");
 
   if (type == Schedule::Occurrence::Once)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Once");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("%1 times").arg(mult));
     }
   else if (type == Schedule::Occurrence::Daily)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Daily");
         break;
       case 30:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every thirty days");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("Every %1 days").arg(mult));
     }
   else if (type == Schedule::Occurrence::Weekly)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Weekly");
         break;
       case 2:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every other week");
         break;
       case 3:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every three weeks");
         break;
       case 4:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every four weeks");
         break;
       case 8:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every eight weeks");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("Every %1 weeks").arg(mult));
     }
   else if (type == Schedule::Occurrence::EveryHalfMonth)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every half month");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("Every %1 half months").arg(mult));
     }
   else if (type == Schedule::Occurrence::Monthly)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Monthly");
         break;
       case 2:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every two months");
         break;
       case 3:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every three months");
         break;
       case 4:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every four months");
         break;
       case 6:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Twice yearly");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("Every %1 months").arg(mult));
     }
   else if (type == Schedule::Occurrence::Yearly)
     switch (mult) {
       case 1:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Yearly");
         break;
       case 2:
         occurrenceString = I18N_NOOP2("Frequency of schedule", "Every other year");
         break;
       default:
         occurrenceString = I18N_NOOP2("Frequency of schedule", QString("Every %1 years").arg(mult));
     }
   return occurrenceString;
 }
 
 QString MyMoneySchedule::occurrencePeriodToString(Schedule::Occurrence type)
 {
   QString occurrenceString = I18N_NOOP2("Schedule occurrence period", "Any");
 
   if (type == Schedule::Occurrence::Once)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Once");
   else if (type == Schedule::Occurrence::Daily)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Day");
   else if (type == Schedule::Occurrence::Weekly)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Week");
   else if (type == Schedule::Occurrence::EveryHalfMonth)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Half-month");
   else if (type == Schedule::Occurrence::Monthly)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Month");
   else if (type == Schedule::Occurrence::Yearly)
     occurrenceString = I18N_NOOP2("Schedule occurrence period", "Year");
   return occurrenceString;
 }
 
 QString MyMoneySchedule::scheduleTypeToString(Schedule::Type type)
 {
   QString text;
 
   switch (type) {
     case Schedule::Type::Bill:
       text = I18N_NOOP2("Scheduled transaction type", "Bill");
       break;
     case Schedule::Type::Deposit:
       text = I18N_NOOP2("Scheduled transaction type", "Deposit");
       break;
     case Schedule::Type::Transfer:
       text = I18N_NOOP2("Scheduled transaction type", "Transfer");
       break;
     case Schedule::Type::LoanPayment:
       text = I18N_NOOP2("Scheduled transaction type", "Loan payment");
       break;
     case Schedule::Type::Any:
     default:
       text = I18N_NOOP2("Scheduled transaction type", "Unknown");
   }
   return text;
 }
 
 
 QString MyMoneySchedule::paymentMethodToString(Schedule::PaymentType paymentType)
 {
   QString text;
 
   switch (paymentType) {
     case Schedule::PaymentType::DirectDebit:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Direct debit");
       break;
     case Schedule::PaymentType::DirectDeposit:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Direct deposit");
       break;
     case Schedule::PaymentType::ManualDeposit:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Manual deposit");
       break;
     case Schedule::PaymentType::Other:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Other");
       break;
     case Schedule::PaymentType::WriteChecque:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Write check");
       break;
     case Schedule::PaymentType::StandingOrder:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Standing order");
       break;
     case Schedule::PaymentType::BankTransfer:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Bank transfer");
       break;
     case Schedule::PaymentType::Any:
       text = I18N_NOOP2("Scheduled Transaction payment type", "Any (Error)");
       break;
   }
   return text;
 }
 
 QString MyMoneySchedule::weekendOptionToString(Schedule::WeekendOption weekendOption)
 {
   QString text;
 
   switch (weekendOption) {
     case Schedule::WeekendOption::MoveBefore:
       text = I18N_NOOP("Change the date to the previous processing day");
       break;
     case Schedule::WeekendOption::MoveAfter:
       text = I18N_NOOP("Change the date to the next processing day");
       break;
     case Schedule::WeekendOption::MoveNothing:
       text = I18N_NOOP("Do not change the date");
       break;
   }
   return text;
 }
 
 // until we don't have the means to store the value
 // of the variation, we default to 10% in case this
 // scheduled transaction is marked 'not fixed'.
 //
 // ipwizard 2009-04-18
 
 int MyMoneySchedule::variation() const
 {
   int rc = 0;
   if (!isFixed()) {
     rc = 10;
 #if 0
     QString var = value("kmm-variation");
     if (!var.isEmpty())
       rc = var.toInt();
 #endif
   }
   return rc;
 }
 
 void MyMoneySchedule::setVariation(int var)
 {
   Q_UNUSED(var)
 #if 0
   deletePair("kmm-variation");
   if (var != 0)
     setValue("kmm-variation", QString("%1").arg(var));
 #endif
 }
 
 int MyMoneySchedule::eventsPerYear(Schedule::Occurrence occurrence)
 {
   int rc = 0;
 
   switch (occurrence) {
     case Schedule::Occurrence::Daily:
       rc = 365;
       break;
     case Schedule::Occurrence::Weekly:
       rc = 52;
       break;
     case Schedule::Occurrence::Fortnightly:
       rc = 26;
       break;
     case Schedule::Occurrence::EveryOtherWeek:
       rc = 26;
       break;
     case Schedule::Occurrence::EveryHalfMonth:
       rc = 24;
       break;
     case Schedule::Occurrence::EveryThreeWeeks:
       rc = 17;
       break;
     case Schedule::Occurrence::EveryFourWeeks:
       rc = 13;
       break;
     case Schedule::Occurrence::Monthly:
     case Schedule::Occurrence::EveryThirtyDays:
       rc = 12;
       break;
     case Schedule::Occurrence::EveryEightWeeks:
       rc = 6;
       break;
     case Schedule::Occurrence::EveryOtherMonth:
       rc = 6;
       break;
     case Schedule::Occurrence::EveryThreeMonths:
     case Schedule::Occurrence::Quarterly:
       rc = 4;
       break;
     case Schedule::Occurrence::EveryFourMonths:
       rc = 3;
       break;
     case Schedule::Occurrence::TwiceYearly:
       rc = 2;
       break;
     case Schedule::Occurrence::Yearly:
       rc = 1;
       break;
     default:
       qWarning("Occurrence not supported by financial calculator");
   }
 
   return rc;
 }
 
 int MyMoneySchedule::daysBetweenEvents(Schedule::Occurrence occurrence)
 {
   int rc = 0;
 
   switch (occurrence) {
     case Schedule::Occurrence::Daily:
       rc = 1;
       break;
     case Schedule::Occurrence::Weekly:
       rc = 7;
       break;
     case Schedule::Occurrence::Fortnightly:
       rc = 14;
       break;
     case Schedule::Occurrence::EveryOtherWeek:
       rc = 14;
       break;
     case Schedule::Occurrence::EveryHalfMonth:
       rc = 15;
       break;
     case Schedule::Occurrence::EveryThreeWeeks:
       rc = 21;
       break;
     case Schedule::Occurrence::EveryFourWeeks:
       rc = 28;
       break;
     case Schedule::Occurrence::EveryThirtyDays:
       rc = 30;
       break;
     case Schedule::Occurrence::Monthly:
       rc = 30;
       break;
     case Schedule::Occurrence::EveryEightWeeks:
       rc = 56;
       break;
     case Schedule::Occurrence::EveryOtherMonth:
       rc = 60;
       break;
     case Schedule::Occurrence::EveryThreeMonths:
     case Schedule::Occurrence::Quarterly:
       rc = 90;
       break;
     case Schedule::Occurrence::EveryFourMonths:
       rc = 120;
       break;
     case Schedule::Occurrence::TwiceYearly:
       rc = 180;
       break;
     case Schedule::Occurrence::Yearly:
       rc = 360;
       break;
     default:
       qWarning("Occurrence not supported by financial calculator");
   }
 
   return rc;
 }
 
 QDate MyMoneySchedule::addHalfMonths(QDate date, int mult) const
 {
   QDate newdate = date;
   int d, dm;
   if (mult > 0) {
     d = newdate.day();
     if (d <= 12) {
       if (mult % 2 == 0)
         newdate = newdate.addMonths(mult >> 1);
       else
         newdate = newdate.addMonths(mult >> 1).addDays(15);
     } else
       for (int i = 0; i < mult; i++) {
         if (d <= 13)
           newdate = newdate.addDays(15);
         else {
           dm = newdate.daysInMonth();
           if (d == 14)
             newdate = newdate.addDays((dm < 30) ? dm - d : 15);
           else if (d == 15)
             newdate = newdate.addDays(dm - d);
           else if (d == dm)
             newdate = newdate.addDays(15 - d).addMonths(1);
           else
             newdate = newdate.addDays(-15).addMonths(1);
         }
         d = newdate.day();
       }
   } else if (mult < 0)  // Go backwards
     for (int i = 0; i > mult; i--) {
       d = newdate.day();
       dm = newdate.daysInMonth();
       if (d > 15) {
         dm = newdate.daysInMonth();
         newdate = newdate.addDays((d == dm) ? 15 - dm : -15);
       } else if (d <= 13)
         newdate = newdate.addMonths(-1).addDays(15);
       else if (d == 15)
         newdate = newdate.addDays(-15);
       else { // 14
         newdate = newdate.addMonths(-1);
         dm = newdate.daysInMonth();
         newdate = newdate.addDays((dm < 30) ? dm - d : 15);
       }
     }
   return newdate;
 }
 
 /**
   * Helper method to convert simple occurrence to compound occurrence + multiplier
   *
   * @param multiplier Returned by reference.  Adjusted multiplier
   * @param occurrence Returned by reference.  Occurrence type
   */
 void MyMoneySchedule::simpleToCompoundOccurrence(int& multiplier, Schedule::Occurrence& occurrence)
 {
   Schedule::Occurrence newOcc = occurrence;
   int newMulti = 1;
   if (occurrence == Schedule::Occurrence::Once ||
       occurrence == Schedule::Occurrence::Daily ||
       occurrence == Schedule::Occurrence::Weekly ||
       occurrence == Schedule::Occurrence::EveryHalfMonth ||
       occurrence == Schedule::Occurrence::Monthly ||
       occurrence == Schedule::Occurrence::Yearly) { // Already a base occurrence and multiplier
   } else if (occurrence == Schedule::Occurrence::Fortnightly ||
              occurrence == Schedule::Occurrence::EveryOtherWeek) {
     newOcc    = Schedule::Occurrence::Weekly;
     newMulti  = 2;
   } else if (occurrence == Schedule::Occurrence::EveryThreeWeeks) {
     newOcc    = Schedule::Occurrence::Weekly;
     newMulti  = 3;
   } else if (occurrence == Schedule::Occurrence::EveryFourWeeks) {
     newOcc    = Schedule::Occurrence::Weekly;
     newMulti  = 4;
   } else if (occurrence == Schedule::Occurrence::EveryThirtyDays) {
     newOcc    = Schedule::Occurrence::Daily;
     newMulti  = 30;
   } else if (occurrence == Schedule::Occurrence::EveryEightWeeks) {
     newOcc    = Schedule::Occurrence::Weekly;
     newMulti  = 8;
   } else if (occurrence == Schedule::Occurrence::EveryOtherMonth) {
     newOcc    = Schedule::Occurrence::Monthly;
     newMulti  = 2;
   } else if (occurrence == Schedule::Occurrence::EveryThreeMonths ||
              occurrence == Schedule::Occurrence::Quarterly) {
     newOcc    = Schedule::Occurrence::Monthly;
     newMulti  = 3;
   } else if (occurrence == Schedule::Occurrence::EveryFourMonths) {
     newOcc    = Schedule::Occurrence::Monthly;
     newMulti  = 4;
   } else if (occurrence == Schedule::Occurrence::TwiceYearly) {
     newOcc    = Schedule::Occurrence::Monthly;
     newMulti  = 6;
   } else if (occurrence == Schedule::Occurrence::EveryOtherYear) {
     newOcc    = Schedule::Occurrence::Yearly;
     newMulti  = 2;
   } else { // Unknown
     newOcc    = Schedule::Occurrence::Any;
     newMulti  = 1;
   }
   if (newOcc != occurrence) {
     occurrence   = newOcc;
     multiplier  = newMulti == 1 ? multiplier : newMulti * multiplier;
   }
 }
 
 /**
   * Helper method to convert compound occurrence + multiplier to simple occurrence
   *
   * @param multiplier Returned by reference.  Adjusted multiplier
   * @param occurrence Returned by reference.  Occurrence type
   */
 void MyMoneySchedule::compoundToSimpleOccurrence(int& multiplier, Schedule::Occurrence& occurrence)
 {
   Schedule::Occurrence newOcc = occurrence;
   if (occurrence == Schedule::Occurrence::Once) { // Nothing to do
   } else if (occurrence == Schedule::Occurrence::Daily) {
     switch (multiplier) {
       case 1:
         break;
       case 30:
         newOcc = Schedule::Occurrence::EveryThirtyDays;
         break;
     }
   } else if (newOcc == Schedule::Occurrence::Weekly) {
     switch (multiplier) {
       case 1:
         break;
       case 2:
         newOcc = Schedule::Occurrence::EveryOtherWeek;
         break;
       case 3:
         newOcc = Schedule::Occurrence::EveryThreeWeeks;
         break;
       case 4:
         newOcc = Schedule::Occurrence::EveryFourWeeks;
         break;
       case 8:
         newOcc = Schedule::Occurrence::EveryEightWeeks;
         break;
     }
   } else if (occurrence == Schedule::Occurrence::Monthly)
     switch (multiplier) {
       case 1:
         break;
       case 2:
         newOcc = Schedule::Occurrence::EveryOtherMonth;
         break;
       case 3:
         newOcc = Schedule::Occurrence::EveryThreeMonths;
         break;
       case 4:
         newOcc = Schedule::Occurrence::EveryFourMonths;
         break;
       case 6:
         newOcc = Schedule::Occurrence::TwiceYearly;
         break;
     }
   else if (occurrence == Schedule::Occurrence::EveryHalfMonth)
     switch (multiplier) {
       case 1:
         break;
     }
   else if (occurrence == Schedule::Occurrence::Yearly) {
     switch (multiplier) {
       case 1:
         break;
       case 2:
         newOcc = Schedule::Occurrence::EveryOtherYear;
         break;
     }
   }
   if (occurrence != newOcc) { // Changed to derived type
     occurrence = newOcc;
     multiplier = 1;
   }
 }
 
 void MyMoneySchedule::setProcessingCalendar(IMyMoneyProcessingCalendar* pc)
 {
   processingCalendarPtr = pc;
 }
 
 bool MyMoneySchedule::isProcessingDate(const QDate& date) const
 {
   if (processingCalendarPtr)
     return processingCalendarPtr->isProcessingDate(date);
 
   /// @todo test against m_processingDays instead?  (currently only for tests)
   return date.dayOfWeek() < Qt::Saturday;
 }
 
 IMyMoneyProcessingCalendar* MyMoneySchedule::processingCalendar() const
 {
   return processingCalendarPtr;
 }
 
 bool MyMoneySchedule::replaceId(const QString& newId, const QString& oldId)
 {
   Q_D(MyMoneySchedule);
   return d->m_transaction.replaceId(newId, oldId);
 }
diff --git a/kmymoney/mymoney/mymoneysecurity.cpp b/kmymoney/mymoney/mymoneysecurity.cpp
index 5d78fc38f..0bab57b18 100644
--- a/kmymoney/mymoney/mymoneysecurity.cpp
+++ b/kmymoney/mymoney/mymoneysecurity.cpp
@@ -1,352 +1,352 @@
 /***************************************************************************
                           mymoneysecurity.cpp  -  description
                              -------------------
     begin                : Tue Jan 29 2002
     copyright            : (C) 2000-2002 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneysecurity.h"
 #include "mymoneysecurity_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QDomDocument>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneystoragenames.h"
 
 using namespace eMyMoney;
 using namespace MyMoneyStorageNodes;
 
 MyMoneySecurity::MyMoneySecurity() :
   MyMoneyObject(*new MyMoneySecurityPrivate)
 {
 }
 
 MyMoneySecurity::MyMoneySecurity(const QString& id,
                                  const QString& name,
                                  const QString& symbol,
                                  const int smallestCashFraction,
                                  const int smallestAccountFraction,
                                  const int pricePrecision) :
   MyMoneyObject(*new MyMoneySecurityPrivate, id),
   MyMoneyKeyValueContainer()
 {
   Q_D(MyMoneySecurity);
   d->m_name = name;
   d->m_smallestCashFraction = smallestCashFraction;
   d->m_pricePrecision = pricePrecision;
   d->m_securityType = eMyMoney::Security::Type::Currency;
 
   if (symbol.isEmpty())
     d->m_tradingSymbol = id;
   else
     d->m_tradingSymbol = symbol;
 
   if (smallestAccountFraction)
     d->m_smallestAccountFraction = smallestAccountFraction;
   else
     d->m_smallestAccountFraction = smallestCashFraction;
 }
 
 MyMoneySecurity::MyMoneySecurity(const QDomElement& node) :
   MyMoneyObject(*new MyMoneySecurityPrivate, node),
   MyMoneyKeyValueContainer(node.elementsByTagName(nodeNames[nnKeyValuePairs]).item(0).toElement())
 {
   {
     const auto tag = node.tagName();
     if ((nodeNames[nnSecurity] != tag)
         && (nodeNames[nnEquity] != tag)
         && (nodeNames[nnCurrency] != tag))
-      throw MYMONEYEXCEPTION("Node was not SECURITY or CURRENCY");
+      throw MYMONEYEXCEPTION_CSTRING("Node was not SECURITY or CURRENCY");
   }
 
   Q_D(MyMoneySecurity);
   d->m_name = node.attribute(d->getAttrName(Security::Attribute::Name));
   d->m_tradingSymbol = node.attribute(d->getAttrName(Security::Attribute::Symbol));
   d->m_securityType = static_cast<eMyMoney::Security::Type>(node.attribute(d->getAttrName(Security::Attribute::Type)).toInt());
   d->m_roundingMethod = static_cast<AlkValue::RoundingMethod>(node.attribute(d->getAttrName(Security::Attribute::RoundingMethod)).toInt());
   d->m_smallestAccountFraction = node.attribute(d->getAttrName(Security::Attribute::SAF)).toUInt();
   d->m_pricePrecision = node.attribute(d->getAttrName(Security::Attribute::PP)).toUInt();
 
   if (d->m_smallestAccountFraction == 0)
     d->m_smallestAccountFraction = 100;
   if (d->m_pricePrecision == 0 || d->m_pricePrecision > 10)
     d->m_pricePrecision = 4;
 
   if (isCurrency()) {
     d->m_smallestCashFraction = node.attribute(d->getAttrName(Security::Attribute::SCF)).toUInt();
     if (d->m_smallestCashFraction == 0)
       d->m_smallestCashFraction = 100;
   } else {
     d->m_tradingCurrency = node.attribute(d->getAttrName(Security::Attribute::TradingCurrency));
     d->m_tradingMarket = node.attribute(d->getAttrName(Security::Attribute::TradingMarket));
   }
 }
 
 MyMoneySecurity::MyMoneySecurity(const MyMoneySecurity& other) :
   MyMoneyObject(*new MyMoneySecurityPrivate(*other.d_func()), other.id()),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneySecurity::MyMoneySecurity(const QString& id, const MyMoneySecurity& other) :
   MyMoneyObject(*new MyMoneySecurityPrivate(*other.d_func()), id),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneySecurity::~MyMoneySecurity()
 {
 }
 
 bool MyMoneySecurity::operator == (const MyMoneySecurity& right) const
 {
   Q_D(const MyMoneySecurity);
   auto d2 = static_cast<const MyMoneySecurityPrivate *>(right.d_func());
   return (d->m_id == d2->m_id)
          && (d->m_name == d2->m_name)
          && (d->m_tradingSymbol == d2->m_tradingSymbol)
          && (d->m_tradingMarket == d2->m_tradingMarket)
          && (d->m_roundingMethod == d2->m_roundingMethod)
          && (d->m_tradingSymbol == d2->m_tradingSymbol)
          && (d->m_tradingCurrency == d2->m_tradingCurrency)
          && (d->m_securityType == d2->m_securityType)
          && (d->m_smallestAccountFraction == d2->m_smallestAccountFraction)
          && (d->m_smallestCashFraction == d2->m_smallestCashFraction)
          && (d->m_pricePrecision == d2->m_pricePrecision)
          && this->MyMoneyKeyValueContainer::operator == (right);
 }
 
 bool MyMoneySecurity::operator < (const MyMoneySecurity& right) const
 {
   Q_D(const MyMoneySecurity);
   auto d2 = static_cast<const MyMoneySecurityPrivate *>(right.d_func());
   if (d->m_securityType == d2->m_securityType)
     return d->m_name < d2->m_name;
   return d->m_securityType < d2->m_securityType;
 }
 
 QString MyMoneySecurity::name() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_name;
 }
 
 void MyMoneySecurity::setName(const QString& str)
 {
   Q_D(MyMoneySecurity);
   d->m_name = str;
 }
 
 QString MyMoneySecurity::tradingSymbol() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_tradingSymbol;
 }
 
 void MyMoneySecurity::setTradingSymbol(const QString& str)
 {
   Q_D(MyMoneySecurity);
   d->m_tradingSymbol = str;
 }
 
 QString MyMoneySecurity::tradingMarket() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_tradingMarket;
 }
 
 void MyMoneySecurity::setTradingMarket(const QString& str)
 {
   Q_D(MyMoneySecurity);
   d->m_tradingMarket = str;
 }
 
 QString MyMoneySecurity::tradingCurrency() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_tradingCurrency;
 }
 
 void MyMoneySecurity::setTradingCurrency(const QString& str)
 {
   Q_D(MyMoneySecurity);
   d->m_tradingCurrency = str;
 }
 
 bool MyMoneySecurity::operator != (const MyMoneySecurity& r) const
 {
   return !(*this == r);
 }
 
 eMyMoney::Security::Type MyMoneySecurity::securityType() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_securityType;
 }
 
 void MyMoneySecurity::setSecurityType(const eMyMoney::Security::Type s)
 {
   Q_D(MyMoneySecurity);
   d->m_securityType = s;
 }
 
 bool MyMoneySecurity::isCurrency() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_securityType == eMyMoney::Security::Type::Currency;
 }
 
 AlkValue::RoundingMethod MyMoneySecurity::roundingMethod() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_roundingMethod;
 }
 
 void MyMoneySecurity::setRoundingMethod(const AlkValue::RoundingMethod rnd)
 {
   Q_D(MyMoneySecurity);
   d->m_roundingMethod = rnd;
 }
 
 int MyMoneySecurity::smallestAccountFraction() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_smallestAccountFraction;
 }
 
 void MyMoneySecurity::setSmallestAccountFraction(const int sf)
 {
   Q_D(MyMoneySecurity);
   d->m_smallestAccountFraction = sf;
 }
 
 int MyMoneySecurity::smallestCashFraction() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_smallestCashFraction;
 }
 
 void MyMoneySecurity::setSmallestCashFraction(const int cf)
 {
   Q_D(MyMoneySecurity);
   d->m_smallestCashFraction = cf;
 }
 
 int MyMoneySecurity::pricePrecision() const
 {
   Q_D(const MyMoneySecurity);
   return d->m_pricePrecision;
 }
 
 void MyMoneySecurity::setPricePrecision(const int pp)
 {
   Q_D(MyMoneySecurity);
   d->m_pricePrecision = pp;
 }
 
 bool MyMoneySecurity::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneySecurity);
   return (id == d->m_tradingCurrency);
 }
 
 void MyMoneySecurity::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   QDomElement el;
   if (isCurrency())
     el = document.createElement(nodeNames[nnCurrency]);
   else
     el = document.createElement(nodeNames[nnSecurity]);
 
   Q_D(const MyMoneySecurity);
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Security::Attribute::Name), d->m_name);
   el.setAttribute(d->getAttrName(Security::Attribute::Symbol),d->m_tradingSymbol);
   el.setAttribute(d->getAttrName(Security::Attribute::Type), static_cast<int>(d->m_securityType));
   el.setAttribute(d->getAttrName(Security::Attribute::RoundingMethod), static_cast<int>(d->m_roundingMethod));
   el.setAttribute(d->getAttrName(Security::Attribute::SAF), d->m_smallestAccountFraction);
   el.setAttribute(d->getAttrName(Security::Attribute::PP), d->m_pricePrecision);
   if (isCurrency())
     el.setAttribute(d->getAttrName(Security::Attribute::SCF), d->m_smallestCashFraction);
   else {
     el.setAttribute(d->getAttrName(Security::Attribute::TradingCurrency), d->m_tradingCurrency);
     el.setAttribute(d->getAttrName(Security::Attribute::TradingMarket), d->m_tradingMarket);
   }
 
   //Add in Key-Value Pairs for securities.
   MyMoneyKeyValueContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 QString MyMoneySecurity::securityTypeToString(const eMyMoney::Security::Type securityType)
 {
   switch (securityType) {
     case eMyMoney::Security::Type::Stock:
       return i18nc("Security type", "Stock");
     case eMyMoney::Security::Type::MutualFund:
       return i18nc("Security type", "Mutual Fund");
     case eMyMoney::Security::Type::Bond:
       return i18nc("Security type", "Bond");
     case eMyMoney::Security::Type::Currency:
       return i18nc("Security type", "Currency");
     case eMyMoney::Security::Type::None:
       return i18nc("Security type", "None");
     default:
       return i18nc("Security type", "Unknown");
   }
 }
 
 QString MyMoneySecurity::roundingMethodToString(const AlkValue::RoundingMethod roundingMethod)
 {
   switch (roundingMethod) {
     case AlkValue::RoundNever:
       return I18N_NOOP("Never");
     case AlkValue::RoundFloor:
       return I18N_NOOP("Floor");
     case AlkValue::RoundCeil:
       return I18N_NOOP("Ceil");
     case AlkValue::RoundTruncate:
       return I18N_NOOP("Truncate");
     case AlkValue::RoundPromote:
       return I18N_NOOP("Promote");
     case AlkValue::RoundHalfDown:
       return I18N_NOOP("HalfDown");
     case AlkValue::RoundHalfUp:
       return I18N_NOOP("HalfUp");
     case AlkValue::RoundRound:
       return I18N_NOOP("Round");
     default:
       return I18N_NOOP("Unknown");
   }
 }
diff --git a/kmymoney/mymoney/mymoneysplit.cpp b/kmymoney/mymoney/mymoneysplit.cpp
index 9ef64c9c8..16f49397d 100644
--- a/kmymoney/mymoney/mymoneysplit.cpp
+++ b/kmymoney/mymoney/mymoneysplit.cpp
@@ -1,517 +1,517 @@
 /***************************************************************************
                           mymoneysplit.cpp  -  description
                              -------------------
     begin                : Sun Apr 28 2002
     copyright            : (C) 2000-2002 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneysplit.h"
 #include "mymoneysplit_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDomDocument>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyutils.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 
 MyMoneySplit::MyMoneySplit() :
   MyMoneyObject(*new MyMoneySplitPrivate)
 {
   Q_D(MyMoneySplit);
   d->m_reconcileFlag = eMyMoney::Split::State::NotReconciled;
 }
 
 MyMoneySplit::MyMoneySplit(const QDomElement& node) :
     MyMoneyObject(*new MyMoneySplitPrivate, node, false),
     MyMoneyKeyValueContainer(node.elementsByTagName(MyMoneySplitPrivate::getElName(Split::Element::KeyValuePairs)).item(0).toElement())
 {
   Q_D(MyMoneySplit);
   if (d->getElName(Split::Element::Split) != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not SPLIT");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not SPLIT");
 
   clearId();
 
   d->m_payee = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Payee)));
 
   QDomNodeList nodeList = node.elementsByTagName(d->getElName(Split::Element::Tag));
   for (int i = 0; i < nodeList.count(); i++)
     d->m_tagList << MyMoneyUtils::QStringEmpty(nodeList.item(i).toElement().attribute(d->getAttrName(Split::Attribute::ID)));
 
   d->m_reconcileDate = MyMoneyUtils::stringToDate(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::ReconcileDate))));
   d->m_action = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Action)));
   d->m_reconcileFlag = static_cast<eMyMoney::Split::State>(node.attribute(d->getAttrName(Split::Attribute::ReconcileFlag)).toInt());
   d->m_memo = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Memo)));
   d->m_value = MyMoneyMoney(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Value))));
   d->m_shares = MyMoneyMoney(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Shares))));
   d->m_price = MyMoneyMoney(MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Price))));
   d->m_account = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Account)));
   d->m_costCenter = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::CostCenter)));
   d->m_number = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::Number)));
   d->m_bankID = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Split::Attribute::BankID)));
 }
 
 MyMoneySplit::MyMoneySplit(const MyMoneySplit& other) :
   MyMoneyObject(*new MyMoneySplitPrivate(*other.d_func()), other.id()),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneySplit::MyMoneySplit(const QString& id, const MyMoneySplit& other) :
   MyMoneyObject(*new MyMoneySplitPrivate(*other.d_func()), id),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneySplit::~MyMoneySplit()
 {
 }
 
 bool MyMoneySplit::operator == (const MyMoneySplit& right) const
 {
   Q_D(const MyMoneySplit);
   auto d2 = static_cast<const MyMoneySplitPrivate *>(right.d_func());
   return MyMoneyObject::operator==(right) &&
          MyMoneyKeyValueContainer::operator==(right) &&
          d->m_account == d2->m_account &&
          d->m_costCenter == d2->m_costCenter &&
          d->m_payee == d2->m_payee &&
          d->m_tagList == d2->m_tagList &&
          d->m_memo == d2->m_memo &&
          d->m_action == d2->m_action &&
          d->m_reconcileDate == d2->m_reconcileDate &&
          d->m_reconcileFlag == d2->m_reconcileFlag &&
          ((d->m_number.length() == 0 && d2->m_number.length() == 0) || d->m_number == d2->m_number) &&
          d->m_shares == d2->m_shares &&
          d->m_value == d2->m_value &&
          d->m_price == d2->m_price &&
          d->m_transactionId == d2->m_transactionId;
 }
 
 MyMoneySplit MyMoneySplit::operator-() const
 {
     MyMoneySplit rc(*this);
   rc.d_func()->m_shares = -rc.d_func()->m_shares;
   rc.d_func()->m_value = -rc.d_func()->m_value;
   return rc;
 }
 
 QString MyMoneySplit::accountId() const
 {
   Q_D(const MyMoneySplit);
   return d->m_account;
 }
 
 void MyMoneySplit::setAccountId(const QString& account)
 {
   Q_D(MyMoneySplit);
   d->m_account = account;
 }
 
 QString MyMoneySplit::costCenterId() const
 {
   Q_D(const MyMoneySplit);
   return d->m_costCenter;
 }
 
 void MyMoneySplit::setCostCenterId(const QString& costCenter)
 {
   Q_D(MyMoneySplit);
   d->m_costCenter = costCenter;
 }
 
 QString MyMoneySplit::memo() const
 {
   Q_D(const MyMoneySplit);
   return d->m_memo;
 }
 
 void MyMoneySplit::setMemo(const QString& memo)
 {
   Q_D(MyMoneySplit);
   d->m_memo = memo;
 }
 
 eMyMoney::Split::State MyMoneySplit::reconcileFlag() const
 {
   Q_D(const MyMoneySplit);
   return d->m_reconcileFlag;
 }
 
 QDate MyMoneySplit::reconcileDate() const
 {
   Q_D(const MyMoneySplit);
   return d->m_reconcileDate;
 }
 
 void MyMoneySplit::setReconcileDate(const QDate& date)
 {
   Q_D(MyMoneySplit);
   d->m_reconcileDate = date;
 }
 
 void MyMoneySplit::setReconcileFlag(const eMyMoney::Split::State flag)
 {
   Q_D(MyMoneySplit);
   d->m_reconcileFlag = flag;
 }
 
 MyMoneyMoney MyMoneySplit::shares() const
 {
   Q_D(const MyMoneySplit);
   return d->m_shares;
 }
 
 void MyMoneySplit::setShares(const MyMoneyMoney& shares)
 {
   Q_D(MyMoneySplit);
   d->m_shares = shares;
 }
 
 QString MyMoneySplit::value(const QString& key) const
 {
   return MyMoneyKeyValueContainer::value(key);
 }
 
 void MyMoneySplit::setValue(const QString& key, const QString& value)
 {
   MyMoneyKeyValueContainer::setValue(key, value);
 }
 
 void MyMoneySplit::setValue(const MyMoneyMoney& value)
 {
   Q_D(MyMoneySplit);
   d->m_value = value;
 }
 
 void MyMoneySplit::setValue(const MyMoneyMoney& value, const QString& transactionCurrencyId, const QString& splitCurrencyId)
 {
   if (transactionCurrencyId == splitCurrencyId)
     setValue(value);
   else
     setShares(value);
 }
 
 QString MyMoneySplit::payeeId() const
 {
   Q_D(const MyMoneySplit);
   return d->m_payee;
 }
 
 void MyMoneySplit::setPayeeId(const QString& payee)
 {
   Q_D(MyMoneySplit);
   d->m_payee = payee;
 }
 
 QList<QString> MyMoneySplit::tagIdList() const
 {
   Q_D(const MyMoneySplit);
   return d->m_tagList;
 }
 
 void MyMoneySplit::setTagIdList(const QList<QString>& tagList)
 {
   Q_D(MyMoneySplit);
   d->m_tagList = tagList;
 }
 
 void MyMoneySplit::setAction(eMyMoney::Split::InvestmentTransactionType type)
 {
   switch (type) {
     case eMyMoney::Split::InvestmentTransactionType::BuyShares:
     case eMyMoney::Split::InvestmentTransactionType::SellShares:
       setAction(actionName(Split::Action::BuyShares));
       break;
     case eMyMoney::Split::InvestmentTransactionType::Dividend:
       setAction(actionName(Split::Action::Dividend));
       break;
     case eMyMoney::Split::InvestmentTransactionType::Yield:
       setAction(actionName(Split::Action::Yield));
       break;
     case eMyMoney::Split::InvestmentTransactionType::ReinvestDividend:
       setAction(actionName(Split::Action::ReinvestDividend));
       break;
     case eMyMoney::Split::InvestmentTransactionType::AddShares:
     case eMyMoney::Split::InvestmentTransactionType::RemoveShares:
       setAction(actionName(Split::Action::AddShares));
       break;
     case eMyMoney::Split::InvestmentTransactionType::SplitShares:
       setAction(actionName(Split::Action::SplitShares));
       break;
     case eMyMoney::Split::InvestmentTransactionType::InterestIncome:
       setAction(actionName(Split::Action::InterestIncome));
       break;
     case eMyMoney::Split::InvestmentTransactionType::UnknownTransactionType:
       break;
   }
 }
 
 QString MyMoneySplit::action() const
 {
   Q_D(const MyMoneySplit);
   return d->m_action;
 }
 
 void MyMoneySplit::setAction(const QString& action)
 {
   Q_D(MyMoneySplit);
   d->m_action = action;
 }
 
 bool MyMoneySplit::isAmortizationSplit() const
 {
   Q_D(const MyMoneySplit);
   return d->m_action == actionName(Split::Action::Amortization);
 }
 
 bool MyMoneySplit::isInterestSplit() const
 {
   Q_D(const MyMoneySplit);
   return d->m_action == actionName(Split::Action::Interest);
 }
 
 QString MyMoneySplit::number() const
 {
   Q_D(const MyMoneySplit);
   return d->m_number;
 }
 
 void MyMoneySplit::setNumber(const QString& number)
 {
   Q_D(MyMoneySplit);
   d->m_number = number;
 }
 
 bool MyMoneySplit::isAutoCalc() const
 {
   Q_D(const MyMoneySplit);
   return (d->m_shares == MyMoneyMoney::autoCalc) || (d->m_value == MyMoneyMoney::autoCalc);
 }
 
 QString MyMoneySplit::bankID() const
 {
   Q_D(const MyMoneySplit);
   return d->m_bankID;
 }
 
 void MyMoneySplit::setBankID(const QString& bankID)
 {
   Q_D(MyMoneySplit);
   d->m_bankID = bankID;
 }
 
 QString MyMoneySplit::transactionId() const
 {
   Q_D(const MyMoneySplit);
   return d->m_transactionId;
 }
 
 void MyMoneySplit::setTransactionId(const QString& id)
 {
   Q_D(MyMoneySplit);
   d->m_transactionId = id;
 }
 
 
 MyMoneyMoney MyMoneySplit::value() const
 {
   Q_D(const MyMoneySplit);
   return d->m_value;
 }
 
 MyMoneyMoney MyMoneySplit::value(const QString& transactionCurrencyId, const QString& splitCurrencyId) const
 {
   Q_D(const MyMoneySplit);
   return (transactionCurrencyId == splitCurrencyId) ? d->m_value : d->m_shares;
 }
 
 MyMoneyMoney MyMoneySplit::actualPrice() const
 {
   Q_D(const MyMoneySplit);
   return d->m_price;
 }
 
 void MyMoneySplit::setPrice(const MyMoneyMoney& price)
 {
   Q_D(MyMoneySplit);
   d->m_price = price;
 }
 
 MyMoneyMoney MyMoneySplit::price() const
 {
   Q_D(const MyMoneySplit);
   if (!d->m_price.isZero())
     return d->m_price;
   if (!d->m_value.isZero() && !d->m_shares.isZero())
     return d->m_value / d->m_shares;
   return MyMoneyMoney::ONE;
 }
 
 void MyMoneySplit::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   Q_D(const MyMoneySplit);
   auto el = document.createElement(d->getElName(Split::Element::Split));
 
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Split::Attribute::Payee), d->m_payee);
   //el.setAttribute(getAttrName(Split::Attribute::Tag), m_tag);
   el.setAttribute(d->getAttrName(Split::Attribute::ReconcileDate), MyMoneyUtils::dateToString(d->m_reconcileDate));
   el.setAttribute(d->getAttrName(Split::Attribute::Action), d->m_action);
   el.setAttribute(d->getAttrName(Split::Attribute::ReconcileFlag), (int)d->m_reconcileFlag);
   el.setAttribute(d->getAttrName(Split::Attribute::Value), d->m_value.toString());
   el.setAttribute(d->getAttrName(Split::Attribute::Shares), d->m_shares.toString());
   if (!d->m_price.isZero())
     el.setAttribute(d->getAttrName(Split::Attribute::Price), d->m_price.toString());
   el.setAttribute(d->getAttrName(Split::Attribute::Memo), d->m_memo);
   // No need to write the split id as it will be re-assigned when the file is read
   // el.setAttribute(getAttrName(Split::Attribute::ID), split.id());
   el.setAttribute(d->getAttrName(Split::Attribute::Account), d->m_account);
   el.setAttribute(d->getAttrName(Split::Attribute::Number), d->m_number);
   el.setAttribute(d->getAttrName(Split::Attribute::BankID), d->m_bankID);
   if(!d->m_costCenter.isEmpty())
     el.setAttribute(d->getAttrName(Split::Attribute::CostCenter), d->m_costCenter);
 
   for (int i = 0; i < d->m_tagList.count(); i++) {
     QDomElement sel = document.createElement(d->getElName(Split::Element::Tag));
     sel.setAttribute(d->getAttrName(Split::Attribute::ID), d->m_tagList[i]);
     el.appendChild(sel);
   }
 
   MyMoneyKeyValueContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneySplit::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneySplit);
   auto rc = false;
   if (isMatched()) {
     rc = matchedTransaction().hasReferenceTo(id);
   }
   for (int i = 0; i < d->m_tagList.size(); i++)
     if (id == d->m_tagList[i])
       return true;
   return rc || (id == d->m_account) || (id == d->m_payee) || (id == d->m_costCenter);
 }
 
 bool MyMoneySplit::isMatched() const
 {
   Q_D(const MyMoneySplit);
   return !(value(d->getAttrName(Split::Attribute::KMMatchedTx)).isEmpty());
 }
 
 void MyMoneySplit::addMatch(const MyMoneyTransaction& _t)
 {
   Q_D(MyMoneySplit);
   //  now we allow matching of two manual transactions
   if (!isMatched()) {
     MyMoneyTransaction t(_t);
     t.clearId();
     QDomDocument doc(d->getElName(Split::Element::Match));
     QDomElement el = doc.createElement(d->getElName(Split::Element::Container));
     doc.appendChild(el);
     t.writeXML(doc, el);
     QString xml = doc.toString();
     xml.replace('<', "&lt;");
     setValue(d->getAttrName(Split::Attribute::KMMatchedTx), xml);
   }
 }
 
 void MyMoneySplit::removeMatch()
 {
   Q_D(MyMoneySplit);
   deletePair(d->getAttrName(Split::Attribute::KMMatchedTx));
 }
 
 MyMoneyTransaction MyMoneySplit::matchedTransaction() const
 {
   Q_D(const MyMoneySplit);
   auto xml = value(d->getAttrName(Split::Attribute::KMMatchedTx));
   if (!xml.isEmpty()) {
     xml.replace("&lt;", "<");
     QDomDocument doc;
     QDomElement node;
     doc.setContent(xml);
     node = doc.documentElement().firstChild().toElement();
     MyMoneyTransaction t(node, false);
     return t;
   }
   return MyMoneyTransaction();
 }
 
 bool MyMoneySplit::replaceId(const QString& newId, const QString& oldId)
 {
   auto changed = false;
   Q_D(MyMoneySplit);
 
   if (d->m_payee == oldId) {
     d->m_payee = newId;
     changed = true;
   } else if (d->m_account == oldId) {
     d->m_account = newId;
     changed = true;
   } else if (d->m_costCenter == oldId) {
     d->m_costCenter = newId;
     changed = true;
   }
 
   if (isMatched()) {
     MyMoneyTransaction t = matchedTransaction();
     if (t.replaceId(newId, oldId)) {
       removeMatch();
       addMatch(t);
       changed = true;
     }
   }
 
   return changed;
 }
 
 QString MyMoneySplit::actionName(Split::Action action)
 {
   static const QHash<Split::Action, QString> actionNames {
     {Split::Action::Check,            QStringLiteral("Check")},
     {Split::Action::Deposit,          QStringLiteral("Deposit")},
     {Split::Action::Transfer,         QStringLiteral("Transfer")},
     {Split::Action::Withdrawal,       QStringLiteral("Withdrawal")},
     {Split::Action::ATM,              QStringLiteral("ATM")},
     {Split::Action::Amortization,     QStringLiteral("Amortization")},
     {Split::Action::Interest,         QStringLiteral("Interest")},
     {Split::Action::BuyShares,        QStringLiteral("Buy")},
     {Split::Action::Dividend,         QStringLiteral("Dividend")},
     {Split::Action::ReinvestDividend, QStringLiteral("Reinvest")},
     {Split::Action::Yield,            QStringLiteral("Yield")},
     {Split::Action::AddShares,        QStringLiteral("Add")},
     {Split::Action::SplitShares,      QStringLiteral("Split")},
     {Split::Action::InterestIncome,   QStringLiteral("IntIncome")},
   };
   return actionNames[action];
 }
diff --git a/kmymoney/mymoney/mymoneytag.cpp b/kmymoney/mymoney/mymoneytag.cpp
index 6ed976b3a..1231b0685 100644
--- a/kmymoney/mymoney/mymoneytag.cpp
+++ b/kmymoney/mymoney/mymoneytag.cpp
@@ -1,175 +1,175 @@
 /***************************************************************************
                           mymoneytag.cpp
                              -------------------
     copyright            : (C) 2012 by Alessandro Russo <alessandro@russo.it>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneytag.h"
 #include "mymoneytag_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDomDocument>
 #include <QDomElement>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 
 MyMoneyTag MyMoneyTag::null;
 
 MyMoneyTag::MyMoneyTag() :
   MyMoneyObject(*new MyMoneyTagPrivate)
 {
 }
 
 MyMoneyTag::MyMoneyTag(const QString& name) :
   MyMoneyObject(*new MyMoneyTagPrivate)
 {
   Q_D(MyMoneyTag);
   d->m_name      = name;
   d->m_tag_color = QColor();
 }
 
 MyMoneyTag::MyMoneyTag(const QString& name, const QColor& tabColor) :
   MyMoneyObject(*new MyMoneyTagPrivate)
 {
   Q_D(MyMoneyTag);
   d->m_name      = name;
   d->m_tag_color = tabColor;
 }
 
 MyMoneyTag::MyMoneyTag(const QDomElement& node) :
   MyMoneyObject(*new MyMoneyTagPrivate, node)
 {
   if (nodeNames[nnTag] != node.tagName()) {
-    throw MYMONEYEXCEPTION("Node was not TAG");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not TAG");
   }
   Q_D(MyMoneyTag);
   d->m_name = node.attribute(d->getAttrName(Tag::Attribute::Name));
   if (node.hasAttribute(d->getAttrName(Tag::Attribute::TagColor))) {
     d->m_tag_color.setNamedColor(node.attribute(d->getAttrName(Tag::Attribute::TagColor)));
   }
   if (node.hasAttribute(d->getAttrName(Tag::Attribute::Notes))) {
     d->m_notes = node.attribute(d->getAttrName(Tag::Attribute::Notes));
   }
   d->m_closed = node.attribute(d->getAttrName(Tag::Attribute::Closed), "0").toUInt();
 }
 
 MyMoneyTag::MyMoneyTag(const MyMoneyTag& other) :
   MyMoneyObject(*new MyMoneyTagPrivate(*other.d_func()), other.id())
 {
 }
 
 MyMoneyTag::MyMoneyTag(const QString& id, const MyMoneyTag& other) :
   MyMoneyObject(*new MyMoneyTagPrivate(*other.d_func()), id)
 {
   Q_D(MyMoneyTag);
   d->m_tag_color = QColor("black");
 }
 
 MyMoneyTag::~MyMoneyTag()
 {
 }
 
 QString MyMoneyTag::name() const
 {
   Q_D(const MyMoneyTag);
   return d->m_name;
 }
 
 void MyMoneyTag::setName(const QString& val)
 {
   Q_D(MyMoneyTag);
   d->m_name = val;
 }
 
 bool MyMoneyTag::isClosed() const
 {
   Q_D(const MyMoneyTag);
   return d->m_closed;
 }
 
 void MyMoneyTag::setClosed(bool val)
 {
   Q_D(MyMoneyTag);
   d->m_closed = val;
 }
 
 QColor MyMoneyTag::tagColor() const
 {
   Q_D(const MyMoneyTag);
   return d->m_tag_color;
 }
 
 void MyMoneyTag::setTagColor(const QColor& val)
 {
   Q_D(MyMoneyTag);
   d->m_tag_color = val;
 }
 
 QString MyMoneyTag::notes() const
 {
   Q_D(const MyMoneyTag);
   return d->m_notes;
 }
 
 void MyMoneyTag::setNotes(const QString& val)
 {
   Q_D(MyMoneyTag);
   d->m_notes = val;
 }
 
 bool MyMoneyTag::operator == (const MyMoneyTag& right) const
 {
   Q_D(const MyMoneyTag);
   auto d2 = static_cast<const MyMoneyTagPrivate *>(right.d_func());
   return (MyMoneyObject::operator==(right) &&
           ((d->m_name.length() == 0 && d2->m_name.length() == 0) || (d->m_name == d2->m_name)) &&
           ((d->m_tag_color.isValid() == false && d2->m_tag_color.isValid() == false) || (d->m_tag_color.name() == d2->m_tag_color.name())) &&
           (d->m_closed == d2->m_closed));
 }
 
 bool MyMoneyTag::operator < (const MyMoneyTag& right) const
 {
   Q_D(const MyMoneyTag);
   auto d2 = static_cast<const MyMoneyTagPrivate *>(right.d_func());
   return d->m_name < d2->m_name;
 }
 
 void MyMoneyTag::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   auto el = document.createElement(nodeNames[nnTag]);
 
   Q_D(const MyMoneyTag);
   d->writeBaseXML(document, el);
 
   el.setAttribute(d->getAttrName(Tag::Attribute::Name), d->m_name);
   el.setAttribute(d->getAttrName(Tag::Attribute::Closed), d->m_closed);
   if (d->m_tag_color.isValid())
     el.setAttribute(d->getAttrName(Tag::Attribute::TagColor), d->m_tag_color.name());
   if (!d->m_notes.isEmpty())
     el.setAttribute(d->getAttrName(Tag::Attribute::Notes), d->m_notes);
   parent.appendChild(el);
 }
 
 bool MyMoneyTag::hasReferenceTo(const QString& /*id*/) const
 {
   return false;
 }
diff --git a/kmymoney/mymoney/mymoneytransaction.cpp b/kmymoney/mymoney/mymoneytransaction.cpp
index e01332247..b65a0d718 100644
--- a/kmymoney/mymoney/mymoneytransaction.cpp
+++ b/kmymoney/mymoney/mymoneytransaction.cpp
@@ -1,514 +1,514 @@
 /***************************************************************************
                           mymoneytransaction.cpp
                              -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                                2002 by 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 "mymoneytransaction.h"
 #include "mymoneytransaction_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QStringList>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QMap>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneystoragenames.h"
 #include "mymoneyutils.h"
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 using namespace MyMoneyStorageNodes;
 
 MyMoneyTransaction::MyMoneyTransaction() :
     MyMoneyObject(*new MyMoneyTransactionPrivate)
 {
   Q_D(MyMoneyTransaction);
   d->m_nextSplitID = 1;
   d->m_entryDate = QDate();
   d->m_postDate = QDate();
 }
 
 MyMoneyTransaction::MyMoneyTransaction(const QDomElement& node, const bool forceId) :
     MyMoneyObject(*new MyMoneyTransactionPrivate, node, forceId)
 {
   Q_D(MyMoneyTransaction);
   if (nodeNames[nnTransaction] != node.tagName())
-    throw MYMONEYEXCEPTION("Node was not TRANSACTION");
+    throw MYMONEYEXCEPTION_CSTRING("Node was not TRANSACTION");
 
   d->m_nextSplitID = 1;
 
   d->m_postDate = MyMoneyUtils::stringToDate(node.attribute(d->getAttrName(Transaction::Attribute::PostDate)));
   d->m_entryDate = MyMoneyUtils::stringToDate(node.attribute(d->getAttrName(Transaction::Attribute::EntryDate)));
   d->m_bankID = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Transaction::Attribute::BankID)));
   d->m_memo = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Transaction::Attribute::Memo)));
   d->m_commodity = MyMoneyUtils::QStringEmpty(node.attribute(d->getAttrName(Transaction::Attribute::Commodity)));
 
   QDomNode child = node.firstChild();
   while (!child.isNull() && child.isElement()) {
     QDomElement c = child.toElement();
     if (c.tagName() == d->getElName(Transaction::Element::Splits)) {
 
       // Process any split information found inside the transaction entry.
       QDomNodeList nodeList = c.elementsByTagName(d->getElName(Transaction::Element::Split));
       for (int i = 0; i < nodeList.count(); ++i) {
         MyMoneySplit s(nodeList.item(i).toElement());
         if (!d->m_bankID.isEmpty())
           s.setBankID(d->m_bankID);
         if (!s.accountId().isEmpty())
           addSplit(s);
         else
           qDebug("Dropped split because it did not have an account id");
       }
 
     } else if (c.tagName() == nodeNames[nnKeyValuePairs]) {
       MyMoneyKeyValueContainer kvp(c);
       setPairs(kvp.pairs());
     }
 
     child = child.nextSibling();
   }
   d->m_bankID.clear();
 }
 
 MyMoneyTransaction::MyMoneyTransaction(const MyMoneyTransaction& other) :
   MyMoneyObject(*new MyMoneyTransactionPrivate(*other.d_func()), other.id()),
   MyMoneyKeyValueContainer(other)
 {
 }
 
 MyMoneyTransaction::MyMoneyTransaction(const QString& id, const MyMoneyTransaction& other) :
   MyMoneyObject(*new MyMoneyTransactionPrivate(*other.d_func()), id),
   MyMoneyKeyValueContainer(other)
 {
   Q_D(MyMoneyTransaction);
   if (d->m_entryDate == QDate())
     d->m_entryDate = QDate::currentDate();
 
   foreach (auto split, d->m_splits)
     split.setTransactionId(id);
 }
 
 MyMoneyTransaction::~MyMoneyTransaction()
 {
 }
 
 QDate MyMoneyTransaction::entryDate() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_entryDate;
 }
 
 void MyMoneyTransaction::setEntryDate(const QDate& date)
 {
   Q_D(MyMoneyTransaction);
   d->m_entryDate = date;
 }
 
 QDate MyMoneyTransaction::postDate() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_postDate;
 }
 
 void MyMoneyTransaction::setPostDate(const QDate& date)
 {
   Q_D(MyMoneyTransaction);
   d->m_postDate = date;
 }
 
 QString MyMoneyTransaction::memo() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_memo;
 }
 
 void MyMoneyTransaction::setMemo(const QString& memo)
 {
   Q_D(MyMoneyTransaction);
   d->m_memo = memo;
 }
 
 QList<MyMoneySplit> MyMoneyTransaction::splits() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_splits;
 }
 
 QList<MyMoneySplit>& MyMoneyTransaction::splits()
 {
   Q_D(MyMoneyTransaction);
   return d->m_splits;
 }
 
 MyMoneySplit MyMoneyTransaction::firstSplit() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_splits.first();
 }
 
 uint MyMoneyTransaction::splitCount() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_splits.count();
 }
 
 QString MyMoneyTransaction::commodity() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_commodity;
 }
 
 void MyMoneyTransaction::setCommodity(const QString& commodityId)
 {
   Q_D(MyMoneyTransaction);
   d->m_commodity = commodityId;
 }
 
 QString MyMoneyTransaction::bankID() const
 {
   Q_D(const MyMoneyTransaction);
   return d->m_bankID;
 }
 
 void MyMoneyTransaction::setBankID(const QString& bankID)
 {
   Q_D(MyMoneyTransaction);
   d->m_bankID = bankID;
 }
 
 bool MyMoneyTransaction::operator == (const MyMoneyTransaction& right) const
 {
   Q_D(const MyMoneyTransaction);
   auto d2 = static_cast<const MyMoneyTransactionPrivate *>(right.d_func());
   return (MyMoneyObject::operator==(right) &&
           MyMoneyKeyValueContainer::operator==(right) &&
           (d->m_commodity == d2->m_commodity) &&
           ((d->m_memo.length() == 0 && d2->m_memo.length() == 0) || (d->m_memo == d2->m_memo)) &&
           (d->m_splits == d2->m_splits) &&
           (d->m_entryDate == d2->m_entryDate) &&
           (d->m_postDate == d2->m_postDate));
 }
 
 bool MyMoneyTransaction::operator != (const MyMoneyTransaction& r) const
 {
   return !(*this == r);
 }
 
 bool MyMoneyTransaction::operator< (const MyMoneyTransaction& r) const
 {
   return postDate() < r.postDate();
 }
 
 bool MyMoneyTransaction::operator<= (const MyMoneyTransaction& r) const
 {
   return postDate() <= r.postDate();
 }
 
 bool MyMoneyTransaction::operator> (const MyMoneyTransaction& r) const
 {
   return postDate() > r.postDate();
 }
 
 bool MyMoneyTransaction::accountReferenced(const QString& id) const
 {
   Q_D(const MyMoneyTransaction);
 
   foreach (const auto split, d->m_splits) {
     if (split.accountId() == id)
       return true;
   }
   return false;
 }
 
 void MyMoneyTransaction::addSplit(MyMoneySplit &split)
 {
   if (!split.id().isEmpty())
-    throw MYMONEYEXCEPTION("Cannot add split with assigned id (" + split.id() + ')');
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot add split with assigned id '%1'").arg(split.id()));
 
   if (split.accountId().isEmpty())
-    throw MYMONEYEXCEPTION("Cannot add split that does not contain an account reference");
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot add split that does not contain an account reference"));
 
   Q_D(MyMoneyTransaction);
   MyMoneySplit newSplit(d->nextSplitID(), split);
   split = newSplit;
   split.setTransactionId(id());
   d->m_splits.append(split);
 }
 
 void MyMoneyTransaction::modifySplit(const MyMoneySplit& split)
 {
 // This is the other version which allows having more splits referencing
 // the same account.
   if (split.accountId().isEmpty())
-    throw MYMONEYEXCEPTION("Cannot modify split that does not contain an account reference");
+    throw MYMONEYEXCEPTION_CSTRING("Cannot modify split that does not contain an account reference");
 
   Q_D(MyMoneyTransaction);
   for (auto& it_split : d->m_splits) {
     if (split.id() == it_split.id()) {
       it_split = split;
       return;
     }
   }
-  throw MYMONEYEXCEPTION(QString("Invalid split id '%1'").arg(split.id()));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid split id '%1'").arg(split.id()));
 }
 
 void MyMoneyTransaction::removeSplit(const MyMoneySplit& split)
 {
   Q_D(MyMoneyTransaction);
   for (auto end = d->m_splits.size(), i = 0; i < end; ++i) {
     if (split.id() == d->m_splits.at(i).id()) {
       d->m_splits.removeAt(i);
       return;
     }
   }
 
-  throw MYMONEYEXCEPTION(QString("Invalid split id '%1'").arg(split.id()));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid split id '%1'").arg(split.id()));
 }
 
 void MyMoneyTransaction::removeSplits()
 {
   Q_D(MyMoneyTransaction);
   d->m_splits.clear();
   d->m_nextSplitID = 1;
 }
 
 MyMoneySplit MyMoneyTransaction::splitByPayee(const QString& payeeId) const
 {
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if (split.payeeId() == payeeId)
       return split;
   }
-  throw MYMONEYEXCEPTION(QString("Split not found for payee '%1'").arg(QString(payeeId)));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Split not found for payee '%1'").arg(QString(payeeId)));
 }
 
 MyMoneySplit MyMoneyTransaction::splitByAccount(const QString& accountId, const bool match) const
 {
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if ((match == true && split.accountId() == accountId) ||
         (match == false && split.accountId() != accountId))
       return split;
   }
-  throw MYMONEYEXCEPTION(QString("Split not found for account %1%2").arg(match ? "" : "!").arg(QString(accountId)));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Split not found for account %1%2").arg(match ? "" : "!").arg(QString(accountId)));
 }
 
 MyMoneySplit MyMoneyTransaction::splitByAccount(const QStringList& accountIds, const bool match) const
 {
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if ((match == true && accountIds.contains(split.accountId())) ||
         (match == false && !accountIds.contains(split.accountId())))
       return split;
   }
-  throw MYMONEYEXCEPTION(QString("Split not found for account  %1%1...%2").arg(match ? "" : "!").arg(accountIds.front(), accountIds.back()));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Split not found for account  %1%1...%2").arg(match ? "" : "!").arg(accountIds.front(), accountIds.back()));
 }
 
 MyMoneySplit MyMoneyTransaction::splitById(const QString& splitId) const
 {
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if (split.id() == splitId)
       return split;
   }
-  throw MYMONEYEXCEPTION(QString("Split not found for id '%1'").arg(QString(splitId)));
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Split not found for id '%1'").arg(QString(splitId)));
 }
 
 QString MyMoneyTransaction::firstSplitID()
 {
   QString id;
   id = 'S' + id.setNum(1).rightJustified(MyMoneyTransactionPrivate::SPLIT_ID_SIZE, '0');
   return id;
 }
 
 MyMoneyMoney MyMoneyTransaction::splitSum() const
 {
   MyMoneyMoney result;
 
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits)
     result += split.value();
   return result;
 }
 
 bool MyMoneyTransaction::isLoanPayment() const
 {
   try {
 
     Q_D(const MyMoneyTransaction);
     foreach (const auto split, d->m_splits) {
       if (split.isAmortizationSplit())
         return true;
     }
   } catch (const MyMoneyException &) {
   }
   return false;
 }
 
 MyMoneySplit MyMoneyTransaction::amortizationSplit() const
 {
   static MyMoneySplit nullSplit;
 
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if (split.isAmortizationSplit() && split.isAutoCalc())
       return split;
   }
   return nullSplit;
 }
 
 MyMoneySplit MyMoneyTransaction::interestSplit() const
 {
   static MyMoneySplit nullSplit;
 
   Q_D(const MyMoneyTransaction);
   foreach (const auto split, d->m_splits) {
     if (split.isInterestSplit() && split.isAutoCalc())
       return split;
   }
   return nullSplit;
 }
 
 unsigned long MyMoneyTransaction::hash(const QString& txt, unsigned long h)
 {
   unsigned long g;
 
   for (int i = 0; i < txt.length(); ++i) {
     unsigned short uc = txt[i].unicode();
     for (unsigned j = 0; j < 2; ++j) {
       unsigned char c = uc & 0xff;
       // if either the cell or the row of the Unicode char is 0, stop processing
       if (!c)
         break;
       h = (h << 4) + c;
       if ((g = (h & 0xf0000000))) {
         h = h ^(g >> 24);
         h = h ^ g;
       }
       uc >>= 8;
     }
   }
   return h;
 }
 
 bool MyMoneyTransaction::isStockSplit() const
 {
   Q_D(const MyMoneyTransaction);
   return (d->m_splits.count() == 1 && d->m_splits.first().action() == MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares));
 }
 
 bool MyMoneyTransaction::isImported() const
 {
   return value("Imported").toLower() == QString("true");
 }
 
 void MyMoneyTransaction::setImported(bool state)
 {
   if (state)
     setValue("Imported", "true");
   else
     deletePair("Imported");
 }
 
 void MyMoneyTransaction::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   Q_D(const MyMoneyTransaction);
   auto el = document.createElement(nodeNames[nnTransaction]);
 
   d->writeBaseXML(document, el);
   el.setAttribute(d->getAttrName(Transaction::Attribute::PostDate), MyMoneyUtils::dateToString(d->m_postDate));
   el.setAttribute(d->getAttrName(Transaction::Attribute::Memo), d->m_memo);
   el.setAttribute(d->getAttrName(Transaction::Attribute::EntryDate), MyMoneyUtils::dateToString(d->m_entryDate));
   el.setAttribute(d->getAttrName(Transaction::Attribute::Commodity), d->m_commodity);
 
   auto splits = document.createElement(d->getElName(Transaction::Element::Splits));
   foreach (const auto split, d->m_splits)
     split.writeXML(document, splits);
   el.appendChild(splits);
 
   MyMoneyKeyValueContainer::writeXML(document, el);
 
   parent.appendChild(el);
 }
 
 bool MyMoneyTransaction::hasReferenceTo(const QString& id) const
 {
   Q_D(const MyMoneyTransaction);
   if (id == d->m_commodity)
     return true;
 
   foreach (const auto split, d->m_splits) {
     if (split.hasReferenceTo(id))
       return true;
   }
   return false;
 }
 
 bool MyMoneyTransaction::hasAutoCalcSplit() const
 {
   Q_D(const MyMoneyTransaction);
 
   foreach (const auto split, d->m_splits)
     if (split.isAutoCalc())
       return true;
   return false;
 }
 
 QString MyMoneyTransaction::accountSignature(bool includeSplitCount) const
 {
   Q_D(const MyMoneyTransaction);
   QMap<QString, int> accountList;
   foreach (const auto split, d->m_splits)
     accountList[split.accountId()] += 1;
 
   QMap<QString, int>::const_iterator it_a;
   QString rc;
   for (it_a = accountList.constBegin(); it_a != accountList.constEnd(); ++it_a) {
     if (it_a != accountList.constBegin())
       rc += '-';
     rc += it_a.key();
     if (includeSplitCount)
       rc += QString("*%1").arg(*it_a);
   }
   return rc;
 }
 
 QString MyMoneyTransaction::uniqueSortKey() const
 {
   Q_D(const MyMoneyTransaction);
   QString year, month, day, key;
   const auto postdate = postDate();
   year = year.setNum(postdate.year()).rightJustified(MyMoneyTransactionPrivate::YEAR_SIZE, '0');
   month = month.setNum(postdate.month()).rightJustified(MyMoneyTransactionPrivate::MONTH_SIZE, '0');
   day = day.setNum(postdate.day()).rightJustified(MyMoneyTransactionPrivate::DAY_SIZE, '0');
   key = QString::fromLatin1("%1-%2-%3-%4").arg(year, month, day, d->m_id);
   return key;
 }
 
 bool MyMoneyTransaction::replaceId(const QString& newId, const QString& oldId)
 {
   auto changed = false;
   Q_D(MyMoneyTransaction);
   for (MyMoneySplit& split : d->m_splits)
     changed |= split.replaceId(newId, oldId);
 
   return changed;
 }
diff --git a/kmymoney/mymoney/onlinejob.cpp b/kmymoney/mymoney/onlinejob.cpp
index 6bb9841b6..e52e0791b 100644
--- a/kmymoney/mymoney/onlinejob.cpp
+++ b/kmymoney/mymoney/onlinejob.cpp
@@ -1,323 +1,323 @@
 /*
   This file is part of KMyMoney, A Personal Finance Manager by KDE
   Copyright (C) 2013 Christian Dávid <christian-david@web.de>
 
   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.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "onlinejob.h"
 #include "onlinejob_p.h"
 
 #include <QDomDocument>
 #include <QDomElement>
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 
 #include "tasks/onlinetask.h"
 #include "onlinejobadministration.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStorageNodes;
 
 onlineJob::onlineJob() :
   MyMoneyObject(*new onlineJobPrivate),
   m_task(0)
 {
   Q_D(onlineJob);
   d->m_jobSend = QDateTime();
   d->m_jobBankAnswerDate = QDateTime();
   d->m_jobBankAnswerState = noBankAnswer;
   d->m_messageList = QList<onlineJobMessage>();
   d->m_locked = false;
 }
 
 onlineJob::onlineJob(onlineTask* onlinetask, const QString &id) :
   MyMoneyObject(*new onlineJobPrivate, id),
   m_task(onlinetask)
 {
   Q_D(onlineJob);
   d->m_jobSend = QDateTime();
   d->m_jobBankAnswerDate = QDateTime();
   d->m_jobBankAnswerState = noBankAnswer;
   d->m_messageList = QList<onlineJobMessage>();
   d->m_locked = false;
 }
 
 onlineJob::onlineJob(onlineTask* onlinetask) :
     MyMoneyObject(*new onlineJobPrivate, QString()),
     m_task(onlinetask)
 {
   Q_D(onlineJob);
   d->m_jobSend = QDateTime();
   d->m_jobBankAnswerDate = QDateTime();
   d->m_jobBankAnswerState = noBankAnswer;
   d->m_messageList = QList<onlineJobMessage>();
   d->m_locked = false;
 }
 
 onlineJob::onlineJob(onlineJob const& other) :
   MyMoneyObject(*new onlineJobPrivate(*other.d_func()), other.id()),
   m_task(0)
 {
   copyPointerFromOtherJob(other);
 }
 
 onlineJob::onlineJob(const QString &id, const onlineJob& other) :
   MyMoneyObject(*new onlineJobPrivate(*other.d_func()), id),
   m_task()
 {
   Q_D(onlineJob);
   d->m_jobSend = QDateTime();
   d->m_jobBankAnswerDate = QDateTime();
   d->m_jobBankAnswerState = noBankAnswer;
   d->m_messageList = QList<onlineJobMessage>();
   d->m_locked = false;
   copyPointerFromOtherJob(other);
 }
 
 onlineJob::onlineJob(const QDomElement& element) :
   MyMoneyObject(*new onlineJobPrivate, element, true)
 {
   Q_D(onlineJob);
   d->m_messageList = QList<onlineJobMessage>();
   d->m_locked = false;
   d->m_jobSend = QDateTime::fromString(element.attribute(d->getAttrName(OnlineJob::Attribute::Send)), Qt::ISODate);
   d->m_jobBankAnswerDate = QDateTime::fromString(element.attribute(d->getAttrName(OnlineJob::Attribute::BankAnswerDate)), Qt::ISODate);
   QString state = element.attribute(d->getAttrName(OnlineJob::Attribute::BankAnswerState));
   if (state == d->getAttrName(OnlineJob::Attribute::AbortedByUser))
     d->m_jobBankAnswerState = abortedByUser;
   else if (state == d->getAttrName(OnlineJob::Attribute::AcceptedByBank))
     d->m_jobBankAnswerState = acceptedByBank;
   else if (state == d->getAttrName(OnlineJob::Attribute::RejectedByBank))
     d->m_jobBankAnswerState = rejectedByBank;
   else if (state == d->getAttrName(OnlineJob::Attribute::SendingError))
     d->m_jobBankAnswerState = sendingError;
   else
     d->m_jobBankAnswerState = noBankAnswer;
 
   QDomElement taskElem = element.firstChildElement(d->getElName(OnlineJob::Element::OnlineTask));
   m_task = onlineJobAdministration::instance()->createOnlineTaskByXml(taskElem.attribute(d->getAttrName(OnlineJob::Attribute::IID)), taskElem);
 }
 
 void onlineJob::copyPointerFromOtherJob(const onlineJob &other)
 {
   if (!other.isNull())
     m_task = other.constTask()->clone();
 }
 
 void onlineJob::reset()
 {
   Q_D(onlineJob);
   clearId();
   d->m_jobSend = QDateTime();
   d->m_jobBankAnswerDate = QDateTime();
   d->m_jobBankAnswerState = noBankAnswer;
   d->m_locked = false;
 }
 
 onlineJob::~onlineJob()
 {
   delete m_task;
 }
 
 onlineTask* onlineJob::task()
 {
   if (m_task == 0)
-    throw emptyTask(__FILE__, __LINE__);
+    throw EMPTYTASKEXCEPTION();
   return m_task;
 }
 
 const onlineTask* onlineJob::task() const
 {
   if (m_task == 0)
-    throw emptyTask(__FILE__, __LINE__);
+    throw EMPTYTASKEXCEPTION();
   return m_task;
 }
 
 const onlineTask* onlineJob::constTask() const
 {
   return task();
 }
 
 
 QString onlineJob::taskIid() const
 {
   try {
     return task()->taskName();
   } catch (const emptyTask&) {
   }
   return QString();
 }
 
 QString onlineJob::responsibleAccount() const
 {
   try {
     return task()->responsibleAccount();
   } catch (const emptyTask&) {
   }
   return QString();
 }
 
 MyMoneyAccount onlineJob::responsibleMyMoneyAccount() const
 {
   QString accountId = responsibleAccount();
   if (!accountId.isEmpty())
     return MyMoneyFile::instance()->account(accountId);
 
   return MyMoneyAccount();
 }
 
 bool onlineJob::setLock(bool enable)
 {
   Q_D(onlineJob);
   d->m_locked = enable;
   return true;
 }
 
 bool onlineJob::isLocked() const
 {
   Q_D(const onlineJob);
   return d->m_locked;
 }
 
 bool onlineJob::isEditable() const
 {
   Q_D(const onlineJob);
   return (!isLocked() && sendDate().isNull() && (d->m_jobBankAnswerState == noBankAnswer || d->m_jobBankAnswerState == sendingError));
 }
 
 bool onlineJob::isNull() const
 {
   return (m_task == 0);
 }
 
 void onlineJob::setJobSend(const QDateTime &dateTime)
 {
   Q_D(onlineJob);
   d->m_jobSend = dateTime;
 }
 
 void onlineJob::setJobSend()
 {
   setJobSend(QDateTime::currentDateTime());
 }
 
 void onlineJob::setBankAnswer(const onlineJob::sendingState state, const QDateTime &dateTime)
 {
   Q_D(onlineJob);
   d->m_jobBankAnswerState = state;
   d->m_jobBankAnswerDate = dateTime;
 }
 
 void onlineJob::setBankAnswer(const onlineJob::sendingState state)
 {
   setBankAnswer(state, QDateTime::currentDateTime());
 }
 
 QDateTime onlineJob::bankAnswerDate() const
 {
   Q_D(const onlineJob);
   return d->m_jobBankAnswerDate;
 }
 
 onlineJob::sendingState onlineJob::bankAnswerState() const
 {
   Q_D(const onlineJob);
   return d->m_jobBankAnswerState;
 }
 
 void onlineJob::addJobMessage(const onlineJobMessage& message)
 {
   Q_D(onlineJob);
   d->m_messageList.append(message);
 }
 
 void onlineJob::addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message, const QString& errorCode, const QDateTime& timestamp)
 {
   Q_D(onlineJob);
   onlineJobMessage logMessage(type, sender, message, timestamp);
   logMessage.setSenderErrorCode(errorCode);
   d->m_messageList.append(logMessage);
 }
 
 void onlineJob::addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message, const QString& errorCode)
 {
   addJobMessage(type, sender, message, errorCode, QDateTime::currentDateTime());
 }
 
 void onlineJob::addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message)
 {
   addJobMessage(type, sender, message, QString(), QDateTime::currentDateTime());
 
 }
 
 QList<onlineJobMessage> onlineJob::jobMessageList() const
 {
   Q_D(const onlineJob);
   return d->m_messageList;
 }
 
 /** @todo give life */
 void onlineJob::writeXML(QDomDocument &document, QDomElement &parent) const
 {
   auto el = document.createElement(nodeNames[nnOnlineJob]);
 
   Q_D(const onlineJob);
   d->writeBaseXML(document, el);
 
   if (!d->m_jobSend.isNull())
     el.setAttribute(d->getAttrName(OnlineJob::Attribute::Send), d->m_jobSend.toString(Qt::ISODate));
   if (!d->m_jobBankAnswerDate.isNull())
     el.setAttribute(d->getAttrName(OnlineJob::Attribute::BankAnswerDate), d->m_jobBankAnswerDate.toString(Qt::ISODate));
 
   switch (d->m_jobBankAnswerState) {
     case abortedByUser: el.setAttribute(d->getAttrName(OnlineJob::Attribute::BankAnswerState), d->getAttrName(OnlineJob::Attribute::AbortedByUser)); break;
     case acceptedByBank: el.setAttribute(d->getAttrName(OnlineJob::Attribute::BankAnswerState), d->getAttrName(OnlineJob::Attribute::AcceptedByBank)); break;
     case rejectedByBank: el.setAttribute(d->getAttrName(OnlineJob::Attribute::BankAnswerState), d->getAttrName(OnlineJob::Attribute::RejectedByBank)); break;
     case sendingError: el.setAttribute(d->getAttrName(OnlineJob::Attribute::BankAnswerState), d->getAttrName(OnlineJob::Attribute::SendingError)); break;
     case noBankAnswer:
     default: void();
   }
 
   QDomElement taskEl = document.createElement(d->getElName(OnlineJob::Element::OnlineTask));
   taskEl.setAttribute(d->getAttrName(OnlineJob::Attribute::IID), taskIid());
   try {
     task()->writeXML(document, taskEl); // throws execption if there is no task
     el.appendChild(taskEl); // only append child if there is something to append
   } catch (const emptyTask&) {
   }
 
   parent.appendChild(el);
 }
 
 bool onlineJob::isValid() const
 {
   if (m_task != 0)
     return m_task->isValid();
   return false;
 }
 
 QDateTime onlineJob::sendDate() const
 {
   Q_D(const onlineJob);
   return d->m_jobSend;
 }
 
 bool onlineJob::hasReferenceTo(const QString& id) const
 {
   if (m_task != 0)
     return m_task->hasReferenceTo(id);
   return false;
 }
diff --git a/kmymoney/mymoney/onlinejob.h b/kmymoney/mymoney/onlinejob.h
index a7dfb026d..c748fba5f 100644
--- a/kmymoney/mymoney/onlinejob.h
+++ b/kmymoney/mymoney/onlinejob.h
@@ -1,355 +1,360 @@
 /*
   This file is part of KMyMoney, A Personal Finance Manager by KDE
   Copyright (C) 2013 Christian Dávid <christian-david@web.de>
 
   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.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
 #ifndef ONLINEJOB_H
 #define ONLINEJOB_H
 
+#define STRINGIFY(x) #x
+#define TOSTRING(x) STRINGIFY(x)
+#define BADTASKEXCEPTION(what) badTaskCast("Casted onlineTask with wrong type. " __FILE__ ":" TOSTRING(__LINE__))
+#define EMPTYTASKEXCEPTION(what) emptyTask("Requested onlineTask of onlineJob without any task. " __FILE__ ":" TOSTRING(__LINE__))
+
 #include <QMetaType>
 #include <QString>
 #include "mymoneyobject.h"
 #include "mymoneyexception.h"
 #include "onlinejobmessage.h"
 
 class onlineTask;
 class MyMoneyAccount;
 
 /**
  * @brief Class to share jobs which can be procceded by an online banking plugin
  *
  * This class stores only the status information and a pointer to an @r onlineTask which stores
  * the real data. So onlineJob is similar to an shared pointer.
  *
  * If you know the type of the onlineTask, @r onlineJobTyped is the first choice to use.
  *
  * It is save to use because accesses to pointers (e.g. task() ) throw an execption if onlineJob is null.
  *
  * Online jobs are usually not created directly but over @r onlineJobAdministration::createOnlineJob. This is
  * required to allow loading of onlineTasks at runtime and only if needed.
  *
  * This class was created to help writing stable and reliable code. Before an unsafe structure (= pointer)
  * is accessed it is checked. Exceptions are thrown if the content is unsafe.
  *
  * @see onlineTask
  * @see onlineJobTyped
  * @todo LOW make data implicitly shared
  */
 class onlineJobPrivate;
 class KMM_MYMONEY_EXPORT onlineJob : public MyMoneyObject
 {
   Q_DECLARE_PRIVATE(onlineJob)
 
   KMM_MYMONEY_UNIT_TESTABLE
 
 public:
    /**
    * @brief Contructor for null onlineJobs
    *
    * A onlineJob which is null cannot become valid again.
    * @see isNull()
    */
   onlineJob();
 
   /**
    * @brief Default construtor
    *
    * The onlineJob takes ownership of the task. The task is deleted in the destructor.
    */
   onlineJob(onlineTask* task, const QString& id); // krazy:exclude=explicit
   onlineJob(onlineTask* task); // krazy:exclude=explicit
 
   /** @brief Contruct from xml */
   explicit onlineJob(const QDomElement&);
 
   /**
    * @brief Create new onlineJob as copy of other
    *
    * This constructor does not copy the status information but the task only.
    */
   onlineJob(const QString &id,
             const onlineJob& other);
 
   onlineJob(const onlineJob & other);
   onlineJob(onlineJob && other);
   onlineJob & operator=(onlineJob other);
   friend void swap(onlineJob& first, onlineJob& second);
 
   virtual ~onlineJob();
 
   /**
    * @brief Returns task attached to this onlineJob
    *
    * You should not store this pointer but use onlineJob::task() (or @r onlineJobTyped::task())
    * every time you access it.
    *
    * @note The return type may change in future (e.g. to an atomic pointer). But you can always expect
    * the operator @c -> to work like it does for onlineTask*.
    *
    * @throws emptyTask if isNull()
    */
   onlineTask* task();
 
   /** @copydoc task(); */
   const onlineTask* task() const;
 
   /**
    * @brief Returns task attached to this onlineJob as const
    * @throws emptyTask if isNull()
    */
   const onlineTask* constTask() const;
 
   /**
    * @brief Returns task of type T attached to this onlineJob
    *
    * Internaly a dynamic_cast is done and the result is checked.
    *
    * @throws emptyTask if isNull()
    * @throws badTaskCast if attached task cannot be casted to T
    */
   template<class T> T* task();
 
   /** @copydoc task() */
   template<class T> const T* task() const;
   template<class T> const T* constTask() const {
     return task<T>();
   }
 
   template<class T> bool canTaskCast() const;
 
   QString taskIid() const;
 
   /** @todo implement */
   bool hasReferenceTo(const QString &id) const override;
   void writeXML(QDomDocument &document, QDomElement &parent) const override;
 
   /**
    * @brief The state of a job given by the onlinePlugin
    */
   enum sendingState {
     noBankAnswer, /**< Used during or before sending or if sendDate().isValid() the job was successfully sent */
     acceptedByBank, /**< bank definetly confirmed the job */
     rejectedByBank, /**< bank definetly rejected this job */
     abortedByUser, /**< aborted by user during sending */
     sendingError /**< an error occurred, the job is certainly not executed by the bank */
   };
 
   /**
    * @brief Account this job is related to
    *
    * Each job must have an account on which the job operates. This is used to determine
    * the correct onlinePlugin which can execute this job. If the job is related to more
    * than one account (e.g. a password change) select a random one.
    *
    * @return accountId or QString() if none is set or job isNull.
    */
   virtual QString responsibleAccount() const;
 
   /**
    * @brief Returns the MyMoneyAccount this job is related to
    * @see responsibleAccount()
    */
   MyMoneyAccount responsibleMyMoneyAccount() const;
 
   /**
    * @brief Check if this onlineJob is editable by the user
    *
    * A job is no longer editable by the user if it is used for documentary purposes
    * e.g. the job was sent to the bank. In that case create a new job based on the
    * old one.
    *
    * @todo make it possible to use onlineJobs as templates
    */
   virtual bool isEditable() const;
 
   /**
    * @brief Checks if this onlineJob has an attached task
    *
    * @return true if no task is attached to this job
    */
   virtual bool isNull() const;
 
   /**
    * @brief Checks if an valid onlineTask is attached
    *
    * @return true if task().isValid(), false if isNull() or !task.isValid()
    */
   virtual bool isValid() const;
 
   /**
    * @brief DateTime the job was sent to the bank
    *
    * A valid return does not mean that this job was accepted by the bank.
    *
    * @return A valid QDateTime if send to bank, an QDateTime() if not send.
    */
   virtual QDateTime sendDate() const;
 
   /**
    * @brief Mark this job as send
    *
    * To be used by online plugin only!
    *
    * Set dateTime to QDateTime to mark unsend.
    */
   virtual void setJobSend(const QDateTime &dateTime);
   virtual void setJobSend();
 
   /**
    * @brief The bank's answer to this job
    *
    * To be used by online plugin only!
    *
    * Set dateTime to QDateTime() and bankAnswer to noState to mark unsend. If bankAnswer == noState dateTime.isNull() must be true!
    */
   void setBankAnswer(const sendingState state, const QDateTime &dateTime);
   void setBankAnswer(const sendingState state);
 
   /**
    * @brief DateTime of the last status update by the bank
    *
    */
   QDateTime bankAnswerDate() const;
 
   /**
    * @brief Returns last status sand by bank
    * @return
    */
   sendingState bankAnswerState() const;
 
   /**
    * @brief locks the onlineJob for sending it
    *
    * Used when the job is in sending process by the online plugin.
    *
    * A locked onlineJob cannot be removed from the storage.
    *
    * @note The onlineJob can still be edited and stored. But it should be done by
    * the one how owns the lock only.
    *
    * @todo Enforce the lock somehow? Note: the onlinePlugin must still be able to
    * write to the job.
    *
    * @param enable true locks the job, false unlocks the job
    */
   virtual bool setLock(bool enable = true);
 
   /**
    * @brief Get lock status
    */
   virtual bool isLocked() const;
 
   /**
    * @brief Make this onlineJob a "new" onlineJob
    *
    * Removes all status information, log, and the id. Only
    * the task is keept.
    */
   virtual void reset();
 
   /**
    * @brief addJobMessage
    *
    * To be used by online plugin only.
    * @param message
    */
   void addJobMessage(const onlineJobMessage &message);
 
   /**
    * @brief Convenient method to set add a log message
    */
   void addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message, const QString& errorCode, const QDateTime& timestamp);
   void addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message, const QString& errorCode);
   void addJobMessage(const eMyMoney::OnlineJob::MessageType& type, const QString& sender, const QString& message);
 
 
   /**
    * @brief jobMessageList
    * @return
    */
   virtual QList<onlineJobMessage> jobMessageList() const;
 
   /**
    * @brief Thrown if a cast of a task fails
    *
    * This is inspired by std::bad_cast
    */
-  class badTaskCast : public MyMoneyException
+  class badTaskCast : public std::runtime_error
   {
   public:
-    explicit badTaskCast(const QString& file = QString(), const long unsigned int& line = 0)
-      : MyMoneyException("Casted onlineTask with wrong type", file, line) {}
+    explicit badTaskCast(const char *msg) : std::runtime_error(msg) {}
   };
 
   /**
    * @brief Thrown if a task of an invalid onlineJob is requested
    */
-  class emptyTask : public MyMoneyException
+  class emptyTask : public std::runtime_error
   {
   public:
-    explicit emptyTask(const QString& file = QString(), const long unsigned int& line = 0)
-      : MyMoneyException("Requested onlineTask of onlineJob without any task", file, line) {}
+    explicit emptyTask(const char *msg) : std::runtime_error(msg) {}
   };
 
   /** @brief onlineTask attatched to this job */
   onlineTask* m_task;
 
 private:
 
   /** @brief Copies stored pointers (used by copy constructors) */
   inline void copyPointerFromOtherJob(const onlineJob& other);
 };
 
 inline void swap(onlineJob& first, onlineJob& second) // krazy:exclude=inline
 {
   using std::swap;
   swap(first.d_ptr, second.d_ptr);
   swap(first.m_task, second.m_task);
 }
 
 inline onlineJob::onlineJob(onlineJob && other) : onlineJob() // krazy:exclude=inline
 {
   swap(*this, other);
 }
 
 inline onlineJob & onlineJob::operator=(onlineJob other) // krazy:exclude=inline
 {
   swap(*this, other);
   return *this;
 }
 
 template<class T>
 T* onlineJob::task()
 {
   T* ret = dynamic_cast<T*>(m_task);
   if (ret == 0)
-    throw badTaskCast(__FILE__, __LINE__);
+    throw EMPTYTASKEXCEPTION();
+//    throw badTaskCast(__FILE__, __LINE__);
   return ret;
 }
 
 template<class T>
 const T* onlineJob::task() const
 {
   const T* ret = dynamic_cast<const T*>(m_task);
   if (ret == 0)
-    throw badTaskCast(__FILE__, __LINE__);
+    throw BADTASKEXCEPTION();
+//    throw badTaskCast(__FILE__, __LINE__);
   return ret;
 }
 
 Q_DECLARE_METATYPE(onlineJob)
 
 #endif // ONLINEJOB_H
diff --git a/kmymoney/mymoney/onlinejobtyped.h b/kmymoney/mymoney/onlinejobtyped.h
index be61c3239..32450969e 100644
--- a/kmymoney/mymoney/onlinejobtyped.h
+++ b/kmymoney/mymoney/onlinejobtyped.h
@@ -1,148 +1,148 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2013 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef ONLINEJOBTYPED_H
 #define ONLINEJOBTYPED_H
 
 #include "onlinejob.h"
 #include "onlinejobadministration.h"
 
 /**
  * @brief Convenient template if you know the task type of an onlineJob
  *
  * To prevent using onlineJob.task<T>() repeatingly you can use this class
  * where task() has a defined return type.
  *
  * Any type check is done in the constructors. So an invalid onlineJobTyped
  * cannot exist. This class is very fast as well because task() does not need
  * any checks.
  *
  * onlineJobTyped::isNull() is always false. All constructors will throw
  * onlineJobTyped::badCast or onlineJobTyped::emptyTask if they fail.
  */
 template<class T>
 class onlineJobTyped : public onlineJob
 {
   KMM_MYMONEY_UNIT_TESTABLE
 public:
   /**
    * @brief create new task
    *
    * @throws emptyTask if plugin could not be found/loaded (determined at runtime).
    */
   explicit onlineJobTyped();
 
   /**
     * @brief Create typed onlineJob
     *
     * @throws emptyTask if task == 0
     */
   explicit onlineJobTyped(T* task, const QString& id = QString());
 
   /** @brief Copy constructor */
   onlineJobTyped(onlineJobTyped<T> const& other);
 
   /**
     * @brief Copy from onlineJob
     *
     * @throws badTaskCast if task in other does not fit T
     * @throws emptyTask if other has no task
     */
   explicit onlineJobTyped(const onlineJob &other);
 
   /** @brief Copy constructor with new id */
   explicit onlineJobTyped(const QString &id, const onlineJobTyped<T>& other);
 
   /** Does not throw */
   inline T* task(); // krazy:exclude=inline
 
   /** Does not throw */
   inline const T* task() const; // krazy:exclude=inline
 
   /** Does not throw */
   inline const T* constTask() const { // krazy:exclude=inline
     return task();
   }
 
   /** Does not throw */
   onlineJobTyped<T> operator =(onlineJobTyped<T> const& other);
 
 private:
   T* m_taskTyped;
 };
 
 template<class T>
 onlineJobTyped<T>::onlineJobTyped()
     : onlineJob(onlineJobAdministration::instance()->createOnlineTask(T::name()))
 {
   m_taskTyped = static_cast<T*>(onlineJob::task());   // this can throw emptyTask
 
   // Just be safe: an onlineTask developer could have done something wrong
   Q_CHECK_PTR(dynamic_cast<T*>(onlineJob::task()));
 }
 
 template<class T>
 onlineJobTyped<T>::onlineJobTyped(T* task, const QString& id)
     : onlineJob(task, id),
     m_taskTyped(task)
 {
-  if (task == 0)
-    throw emptyTask(__FILE__, __LINE__);
+  if (!task)
+    throw EMPTYTASKEXCEPTION();
 }
 
 template<class T>
 onlineJobTyped<T>::onlineJobTyped(onlineJobTyped<T> const& other)
     : onlineJob(other)
 {
   m_taskTyped = dynamic_cast<T*>(onlineJob::task());
   Q_CHECK_PTR(m_taskTyped);
 }
 
 template<class T>
 onlineJobTyped<T> onlineJobTyped<T>::operator =(onlineJobTyped<T> const & other)
 {
   onlineJob::operator =(other);
   m_taskTyped = dynamic_cast<T*>(onlineJob::task());
   Q_CHECK_PTR(m_taskTyped);
   return (*this);
 }
 
 template<class T>
 onlineJobTyped<T>::onlineJobTyped(const onlineJob &other)
     : onlineJob(other)
 {
   m_taskTyped = dynamic_cast<T*>(onlineJob::task()); // can throw emptyTask
-  if (m_taskTyped == 0)
-    throw badTaskCast(__FILE__, __LINE__);
+  if (!m_taskTyped)
+    throw BADTASKEXCEPTION();
 }
 
 template<class T>
 T* onlineJobTyped<T>::task()
 {
   Q_CHECK_PTR(m_taskTyped);
   return m_taskTyped;
 }
 
 template<class T>
 const T* onlineJobTyped<T>::task() const
 {
   Q_CHECK_PTR(m_taskTyped);
   return m_taskTyped;
 }
 
 #endif // ONLINEJOBTYPED_H
diff --git a/kmymoney/mymoney/payeeidentifier/payeeidentifier.cpp b/kmymoney/mymoney/payeeidentifier/payeeidentifier.cpp
index 8931d77fc..f52ebd96e 100644
--- a/kmymoney/mymoney/payeeidentifier/payeeidentifier.cpp
+++ b/kmymoney/mymoney/payeeidentifier/payeeidentifier.cpp
@@ -1,159 +1,159 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "payeeidentifier.h"
 
 #include <QDomDocument>
 #include <QDomElement>
 
 #include "payeeidentifierdata.h"
 
 payeeIdentifier::payeeIdentifier()
     : m_id(0),
     m_payeeIdentifier(0)
 {
 }
 
 payeeIdentifier::payeeIdentifier(const payeeIdentifier& other)
     : m_id(other.m_id),
     m_payeeIdentifier(0)
 {
   if (other.m_payeeIdentifier != 0)
     m_payeeIdentifier = other.m_payeeIdentifier->clone();
 }
 
 payeeIdentifier::payeeIdentifier(payeeIdentifierData*const identifierdata)
     : m_id(0),
     m_payeeIdentifier(identifierdata)
 {
 }
 
 payeeIdentifier::payeeIdentifier(const payeeIdentifier::id_t& id, payeeIdentifierData*const identifierdata)
     : m_id(id),
     m_payeeIdentifier(identifierdata)
 {
 }
 
 payeeIdentifier::payeeIdentifier(const QString& id, payeeIdentifierData*const identifierdata)
     : m_id(id.mid(5).toUInt()),
     m_payeeIdentifier(identifierdata)
 {
   bool ok = false; // hopefully the compiler optimizes this away if compiled in non-debug mode
   Q_ASSERT(id.mid(5).toUInt(&ok) && ok);
 }
 
 payeeIdentifier::payeeIdentifier(const payeeIdentifier::id_t& id, const payeeIdentifier& other)
     : m_id(id),
     m_payeeIdentifier(0)
 {
   if (other.m_payeeIdentifier != 0)
     m_payeeIdentifier = other.m_payeeIdentifier->clone();
 }
 
 QString payeeIdentifier::idString() const
 {
   if (m_id == 0)
     return QString();
   return QLatin1String("IDENT") + QString::number(m_id).rightJustified(6, '0');
 }
 
 payeeIdentifier::~payeeIdentifier()
 {
   delete m_payeeIdentifier;
 }
 
 payeeIdentifierData* payeeIdentifier::operator->()
 {
   if (m_payeeIdentifier == 0)
-    throw empty(__FILE__, __LINE__);
+    throw PAYEEIDENTIFIEREMPTYEXCEPTION();
   return m_payeeIdentifier;
 }
 
 const payeeIdentifierData* payeeIdentifier::operator->() const
 {
   if (m_payeeIdentifier == 0)
-    throw empty(__FILE__, __LINE__);
+    throw PAYEEIDENTIFIEREMPTYEXCEPTION();
   return m_payeeIdentifier;
 }
 
 payeeIdentifierData* payeeIdentifier::data()
 {
   return operator->();
 }
 
 const payeeIdentifierData* payeeIdentifier::data() const
 {
   return operator->();
 }
 
 bool payeeIdentifier::isValid() const
 {
   if (m_payeeIdentifier != 0)
     return m_payeeIdentifier->isValid();
   return false;
 }
 
 QString payeeIdentifier::iid() const
 {
   if (m_payeeIdentifier != 0)
     return m_payeeIdentifier->payeeIdentifierId();
   return QString();
 }
 
 payeeIdentifier& payeeIdentifier::operator=(const payeeIdentifier & other)
 {
   if (this == &other)
     return *this;
 
   m_id = other.m_id;
   if (other.m_payeeIdentifier == 0)
     m_payeeIdentifier = 0;
   else
     m_payeeIdentifier = other.m_payeeIdentifier->clone();
 
   return *this;
 }
 
 bool payeeIdentifier::operator==(const payeeIdentifier& other)
 {
   if (m_id != other.m_id)
     return false;
 
   if (isNull() || other.isNull()) {
     if (!isNull() ||  !other.isNull())
       return false;
     return true;
   }
   return (*data() == *(other.data()));
 }
 
 void payeeIdentifier::writeXML(QDomDocument& document, QDomElement& parent, const QString& elemenName) const
 {
   // Important: type must be set before calling m_payeeIdentifier->writeXML()
   // the plugin for unavailable plugins must be able to set type itself
   QDomElement elem = document.createElement(elemenName);
   if (m_id != 0)
     elem.setAttribute("id", m_id);
 
   if (!isNull()) {
     elem.setAttribute("type", m_payeeIdentifier->payeeIdentifierId());
     m_payeeIdentifier->writeXML(document, elem);
   }
   parent.appendChild(elem);
 }
 
diff --git a/kmymoney/mymoney/payeeidentifier/payeeidentifier.h b/kmymoney/mymoney/payeeidentifier/payeeidentifier.h
index 34a6c0ede..ae884c80d 100644
--- a/kmymoney/mymoney/payeeidentifier/payeeidentifier.h
+++ b/kmymoney/mymoney/payeeidentifier/payeeidentifier.h
@@ -1,178 +1,164 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef PAYEEIDENTIFIER_H
 #define PAYEEIDENTIFIER_H
 
+#define KMM_STRINGIFY(x) #x
+#define KMM_TOSTRING(x) KMM_STRINGIFY(x)
+
 #include <QMetaType>
 #include <QString>
 #include <qglobal.h>
+#include "mymoneyexception.h"
 
 /** @todo fix include path after upgrade to cmake 3 */
 #include "payeeidentifier/kmm_payeeidentifier_export.h"
 
+#define PAYEEIDENTIFIERBADCASTEXCEPTION(exceptionMessage) payeeIdentifier::badCast("Casted payeeIdentifier with wrong type " __FILE__ ":" KMM_TOSTRING(__LINE__))
+#define PAYEEIDENTIFIEREMPTYEXCEPTION(exceptionMessage) payeeIdentifier::empty("Requested payeeIdentifierData of empty payeeIdentifier " __FILE__ ":" KMM_TOSTRING(__LINE__))
+
 // Q_DECLARE_METATYPE requries this include
 
 class QDomDocument;
 class QDomElement;
 class payeeIdentifierData;
 class KMM_PAYEEIDENTIFIER_EXPORT payeeIdentifier
 {
 public:
   typedef unsigned int id_t;
 
   explicit payeeIdentifier();
   explicit payeeIdentifier(payeeIdentifierData *const data);
   explicit payeeIdentifier(const id_t& id, payeeIdentifierData *const data);
   explicit payeeIdentifier(const QString& id, payeeIdentifierData *const data);
   explicit payeeIdentifier(const id_t& id, const payeeIdentifier& other);
 
   payeeIdentifier(const payeeIdentifier& other);
   ~payeeIdentifier();
   payeeIdentifier& operator=(const payeeIdentifier& other);
   bool operator==(const payeeIdentifier& other);
 
   /** @brief Check if any data is associated */
   bool isNull() const {
     return (m_payeeIdentifier == 0);
   }
 
   /**
    * @brief create xml to save this payeeIdentifier
    *
    * It creates a new element below parent which is used to store all data.
    *
    * The counter part to load a payee identifier again is payeeIdentifierLoader::createPayeeIdentifierFromXML().
    */
   void writeXML(QDomDocument &document, QDomElement &parent, const QString& elementName = QLatin1String("payeeIdentifier")) const;
 
   /**
    * @throws payeeIdentifier::empty
    */
   payeeIdentifierData* operator->();
 
   /** @copydoc operator->() */
   const payeeIdentifierData* operator->() const;
 
   /** @copydoc operator->() */
   payeeIdentifierData* data();
 
   /** @copydoc operator->() */
   const payeeIdentifierData* data() const;
 
   template< class T >
   T* data();
 
   template< class T >
   const T* data() const;
 
   bool isValid() const;
 
 
   id_t id() const {
     return m_id;
   }
 
   QString idString() const;
 
   void clearId() {
     m_id = 0;
   }
 
   /**
    * @brief Get payeeIdentifier Iid which identifiers the type
    *
    * @return An payeeIdentifier id or QString() if no data is associated
    */
   QString iid() const;
 
-  /**
-   * @brief Base for exceptions thrown by payeeIdentifier
-   *
-   * @internal Using MyMoneyException instead is not possible because
-   * it would lead to cyclic inter-target dependenies. We could create a new
-   * shared library which includes MyMoneyException only, but this could be over-
-   * powered.
-   */
-  class exception
-    {};
-
   /**
    * @brief Thrown if a cast of a payeeIdentifier fails
    *
    * This is inspired by std::bad_cast
-   * @todo inherit from MyMoneyException
    */
-  class badCast : public exception
+  class badCast : public MyMoneyException
   {
   public:
-    explicit badCast(const QString& file = "", const long unsigned int& line = 0)
-    //: MyMoneyException("Casted payeeIdentifier with wrong type", file, line)
-    {
-      Q_UNUSED(file); Q_UNUSED(line);
-    }
+    explicit badCast(const char *exceptionMessage) : MyMoneyException(exceptionMessage) {}
   };
 
   /**
    * @brief Thrown if one tried to access the data of a null payeeIdentifier
-   * @todo inherit from MyMoneyException
    */
-  class empty : public exception
+  class empty : public MyMoneyException
   {
   public:
-    explicit empty(const QString& file = "", const long unsigned int& line = 0)
-    //: MyMoneyException("Requested payeeIdentifierData of empty payeeIdentifier", file, line)
-    {
-      Q_UNUSED(file); Q_UNUSED(line);
-    }
+    explicit empty(const char *exceptionMessage) : MyMoneyException(exceptionMessage) {}
   };
 
 private:
   /**
    * The id is only used in MyMoneyPayeeIdentifierContainer at the moment.
    */
   id_t m_id;
 
   // Must access the id, but the id should not be used outside of that class at the moment
   friend class MyMoneyPayeeIdentifierContainer;
   friend class payeeIdentifierLoader;
 
   payeeIdentifierData* m_payeeIdentifier;
 };
 
 template<class T>
 T* payeeIdentifier::data()
 {
   T *const ident = dynamic_cast<T*>(operator->());
   if (ident == 0)
-    throw badCast(__FILE__, __LINE__);
+    throw PAYEEIDENTIFIERBADCASTEXCEPTION();
   return ident;
 }
 
 template<class T>
 const T* payeeIdentifier::data() const
 {
   const T *const ident = dynamic_cast<const T*>(operator->());
   if (ident == 0)
-    throw badCast(__FILE__, __LINE__);
+    throw PAYEEIDENTIFIERBADCASTEXCEPTION();
   return ident;
 }
 
 Q_DECLARE_METATYPE(payeeIdentifier)
 
 #endif // PAYEEIDENTIFIER_H
diff --git a/kmymoney/mymoney/payeeidentifier/payeeidentifiertyped.h b/kmymoney/mymoney/payeeidentifier/payeeidentifiertyped.h
index 763fdba94..ddf559445 100644
--- a/kmymoney/mymoney/payeeidentifier/payeeidentifiertyped.h
+++ b/kmymoney/mymoney/payeeidentifier/payeeidentifiertyped.h
@@ -1,119 +1,119 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #ifndef PAYEEIDENTIFIERTYPED_H
 #define PAYEEIDENTIFIERTYPED_H
 
 #include "payeeidentifier.h"
 
 template<class T>
 class payeeIdentifierTyped : public payeeIdentifier
 {
 public:
   payeeIdentifierTyped(const payeeIdentifierTyped& other);
   payeeIdentifierTyped(T* pid);
   //explicit payeeIdentifierTyped();
   explicit payeeIdentifierTyped(const payeeIdentifier& other);
 
   T* operator->();
   const T* operator->() const;
 
   T* data() {
     return operator->();
   }
   const T* data() const {
     return operator->();
   }
 
   payeeIdentifierTyped& operator=(const payeeIdentifierTyped& other);
   bool operator==(const payeeIdentifierTyped& other);
 
 private:
   /** this method is not save in this class, so deactivate it */
   void setData(payeeIdentifierData* dataPtr);
   T* m_payeeIdentifierTyped;
 };
 
 #if 0
 template< class T >
 payeeIdentifierTyped<T>::payeeIdentifierTyped()
     : payeeIdentifier()
 {
   Q_ASSERT(false && "This method is not implemented yet");
   throw payeeIdentifier::empty();
 }
 #endif
 
 template< class T >
 payeeIdentifierTyped<T>::payeeIdentifierTyped(T* pid)
     : payeeIdentifier(pid),
     m_payeeIdentifierTyped(pid)
 {
   if (m_payeeIdentifierTyped == 0)
-    throw payeeIdentifier::empty(__FILE__, __LINE__);
+    throw PAYEEIDENTIFIEREMPTYEXCEPTION();
 }
 
 template< class T >
 payeeIdentifierTyped<T>::payeeIdentifierTyped(const payeeIdentifierTyped& other)
     : payeeIdentifier(other)
 {
   m_payeeIdentifierTyped = dynamic_cast<T*>(payeeIdentifier::data());
   Q_CHECK_PTR(m_payeeIdentifierTyped);
 }
 
 template< class T >
 payeeIdentifierTyped<T>& payeeIdentifierTyped<T>::operator=(const payeeIdentifierTyped<T>& other)
 {
   payeeIdentifierTyped<T>& ret = static_cast<payeeIdentifierTyped<T>&>(payeeIdentifier::operator=(other));
   // This operation is save even if this == &other
   ret.m_payeeIdentifierTyped = dynamic_cast<T*>(ret.payeeIdentifier::data());
   return ret;
 }
 
 template< class T >
 bool payeeIdentifierTyped<T>::operator==(const payeeIdentifierTyped& other)
 {
   return payeeIdentifier::operator==(other);
 }
 
 template< class T >
 payeeIdentifierTyped<T>::payeeIdentifierTyped(const payeeIdentifier& other)
     : payeeIdentifier(other)
 {
   m_payeeIdentifierTyped = dynamic_cast<T*>(payeeIdentifier::data());
   if (m_payeeIdentifierTyped == 0) {
     if (payeeIdentifier::data() == 0)
-      throw payeeIdentifier::empty(__FILE__, __LINE__);
-    throw payeeIdentifier::badCast(__FILE__, __LINE__);
+      throw PAYEEIDENTIFIEREMPTYEXCEPTION();
+    throw PAYEEIDENTIFIERBADCASTEXCEPTION();
   }
 }
 
 template< class T >
 T* payeeIdentifierTyped<T>::operator->()
 {
   return m_payeeIdentifierTyped;
 }
 
 template< class T >
 const T* payeeIdentifierTyped<T>::operator->() const
 {
   return m_payeeIdentifierTyped;
 }
 
 
 #endif // PAYEEIDENTIFIERTYPED_H
diff --git a/kmymoney/mymoney/payeeidentifiermodel.cpp b/kmymoney/mymoney/payeeidentifiermodel.cpp
index 5d0ce5814..cd7325533 100644
--- a/kmymoney/mymoney/payeeidentifiermodel.cpp
+++ b/kmymoney/mymoney/payeeidentifiermodel.cpp
@@ -1,161 +1,161 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2015, 2016  Christian David <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "payeeidentifiermodel.h"
 
 #include <limits>
 
 #include <KLocalizedString>
 
 #include "mymoneyfile.h"
 #include "mymoneyexception.h"
 
 /**
  * @brief create unique value for QModelIndex::internalId() to indicate "not set"
  */
 static constexpr decltype(reinterpret_cast<QModelIndex*>(0)->internalId()) invalidParent = std::numeric_limits<decltype(reinterpret_cast<QModelIndex*>(0)->internalId())>::max();
 
 payeeIdentifierModel::payeeIdentifierModel(QObject* parent)
     : QAbstractItemModel(parent),
     m_payeeIdentifierIds(),
     m_typeFilter()
 {
 
 }
 
 void payeeIdentifierModel::setTypeFilter(QStringList filter)
 {
   m_typeFilter = filter;
   loadData();
 }
 
 void payeeIdentifierModel::setTypeFilter(QString type)
 {
   setTypeFilter(QStringList(type));
 }
 
 
 void payeeIdentifierModel::loadData()
 {
   beginResetModel();
 
   const QList<MyMoneyPayee> payees = MyMoneyFile::instance()->payeeList();
   m_payeeIdentifierIds.clear();
   m_payeeIdentifierIds.reserve(payees.count());
   Q_FOREACH(const MyMoneyPayee& payee, payees) {
     m_payeeIdentifierIds.append(payee.id());
   }
   endResetModel();
 }
 
 MyMoneyPayee payeeIdentifierModel::payeeByIndex(const QModelIndex& index) const
 {
   if (index.isValid() && index.row() >= 0 && index.row() < m_payeeIdentifierIds.count()) {
     try {
       return MyMoneyFile::instance()->payee(m_payeeIdentifierIds.at(index.row()));
-    } catch (MyMoneyException&) {
+    } catch (const MyMoneyException &) {
     }
   }
 
   return MyMoneyPayee();
 }
 
 QVariant payeeIdentifierModel::data(const QModelIndex& index, int role) const
 {
   if (!index.isValid())
     return QVariant();
 
   const auto isPayeeIdentifierValid = index.parent().isValid();
   if (role == payeeIdentifierModel::isPayeeIdentifier)
     return isPayeeIdentifierValid;
 
   const MyMoneyPayee payee = (isPayeeIdentifierValid) ? payeeByIndex(index.parent()) : payeeByIndex(index);
 
 
   if (role == payeeName || (!isPayeeIdentifierValid && role == Qt::DisplayRole)) {
     // Return data for MyMoneyPayee
     return payee.name();
   } else if (isPayeeIdentifierValid) {
     // Return data for payeeIdentifier
     if (index.row() >= 0 && static_cast<unsigned int>(index.row()) < payee.payeeIdentifierCount()) {
       ::payeeIdentifier ident = payee.payeeIdentifier(index.row());
 
       if (role == payeeIdentifier) {
         return QVariant::fromValue< ::payeeIdentifier >(ident);
       } else if (ident.isNull()) {
         return QVariant();
       } else if (role == payeeIdentifierType) {
         return ident.iid();
       } else if (role == Qt::DisplayRole) {
         // The custom delegates won't ask for this role
         return QVariant::fromValue(i18n("The plugin to show this information could not be found."));
       }
     }
   }
 
   return QVariant();
 }
 
 Qt::ItemFlags payeeIdentifierModel::flags(const QModelIndex &index) const
 {
   Q_UNUSED(index)
 #if 0
   if (!index.parent().isValid()) {
     if (payeeByIndex(index).payeeIdentifierCount() > 0)
       return Qt::ItemIsEnabled;
   }
 #endif
 
   return (Qt::ItemIsEnabled | Qt::ItemIsSelectable);
 }
 
 /**
  * @intenal The internalId of QModelIndex is set to the row of the parent or invalidParent if there is no
  * parent.
  *
  * @todo Qt5: the type of the internal id changed!
  */
 QModelIndex payeeIdentifierModel::index(int row, int column, const QModelIndex &parent) const
 {
   if (parent.isValid())
     return createIndex(row, column, parent.row());
   return createIndex(row, column, invalidParent);
 }
 
 int payeeIdentifierModel::columnCount(const QModelIndex& parent) const
 {
   Q_UNUSED(parent);
   return 1;
 }
 
 int payeeIdentifierModel::rowCount(const QModelIndex& parent) const
 {
   if (parent.isValid()) {
     if (parent.internalId() != invalidParent)
       return 0;
     return payeeByIndex(parent).payeeIdentifierCount();
   }
   return m_payeeIdentifierIds.count();
 }
 
 QModelIndex payeeIdentifierModel::parent(const QModelIndex& child) const
 {
   if (child.internalId() != invalidParent)
     return createIndex(child.internalId(), 0, invalidParent);
   return QModelIndex();
 }
diff --git a/kmymoney/mymoney/storage/mymoneymap.h b/kmymoney/mymoney/storage/mymoneymap.h
index b80f27283..023c514d4 100644
--- a/kmymoney/mymoney/storage/mymoneymap.h
+++ b/kmymoney/mymoney/storage/mymoneymap.h
@@ -1,366 +1,366 @@
 /***************************************************************************
                           mymoneymap.h
                              -------------------
     copyright            : (C) 2007-2008 by Thomas Baumgart
     email                : <ipwizard@users.sourceforge.net>
                            (C) 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 <stdint.h>
 #include <QMap>
 #include <QStack>
 #include <mymoneyexception.h>
 
 #ifndef MYMONEYMAP_H
 #define MYMONEYMAP_H
 
 #define MY_OWN_DEBUG 0
 
 /**
   * @author Thomas Baumgart
   *
   * This template class adds transaction security to the QMap<> class.
   * The interface is very simple. Before you perform any changes,
   * you have to call the startTransaction() method. Then you can use
   * the insert(), modify() and remove() methods to modify the map.
   * Changes are recorded and if you are finished, use the
   * commitTransaction() to finish the transaction. If you want to go
   * back before you have committed the transaction, use
   * rollbackTransaction() to set the container to the state it was
   * in before you called startTransaction().
   *
   * The implementation is based on the command pattern, in case
   * someone is interested.
   */
 template <class Key, class T>
 class MyMoneyMap : protected QMap<Key, T>
 {
 private:
   // check if a key required (not already contained in the stack) or not
   bool required(const Key& key) const {
     if (m_stack.count() > 1) {
       for (auto i = 0; i < m_stack.count(); ++i) {
         if (m_stack[i]->key() == key) {
           return false;
         }
       }
     }
     return true;
   }
 
 public:
   MyMoneyMap() : QMap<Key, T>() {}
   ~MyMoneyMap() {}
 
   void startTransaction(unsigned long* id = 0) {
     m_stack.push(new MyMoneyMapStart(this, id));
   }
 
   void rollbackTransaction(void) {
     if (m_stack.isEmpty())
-      throw MYMONEYEXCEPTION("No transaction started to rollback changes");
+      throw MYMONEYEXCEPTION_CSTRING("No transaction started to rollback changes");
 
     // undo all actions
     MyMoneyMapAction* action;
     while (!m_stack.isEmpty()) {
       action = m_stack.pop();
       action->undo();
       delete action;
     }
   }
 
   bool commitTransaction(void) {
     if (m_stack.isEmpty())
-      throw MYMONEYEXCEPTION("No transaction started to commit changes");
+      throw MYMONEYEXCEPTION_CSTRING("No transaction started to commit changes");
 
     bool rc = m_stack.count() > 1;
     // remove all actions from the stack
     MyMoneyMapAction* action;
     while (!m_stack.isEmpty()) {
       action = m_stack.pop();
       delete action;
     }
     return rc;
   }
 
   void insert(const Key& key, const T& obj) {
     if (m_stack.isEmpty())
-      throw MYMONEYEXCEPTION("No transaction started to insert new element into container");
+      throw MYMONEYEXCEPTION_CSTRING("No transaction started to insert new element into container");
 
     // check if information about the object identified by 'key'
     // is already present in the stack
     if (!required(key)) {
       this->QMap<Key, T>::insert(key, obj);
       return;
     }
 
     // store object in
     m_stack.push(new MyMoneyMapInsert(this, key, obj));
   }
 
   void modify(const Key& key, const T& obj) {
     if (m_stack.isEmpty())
-      throw MYMONEYEXCEPTION("No transaction started to modify element in container");
+      throw MYMONEYEXCEPTION_CSTRING("No transaction started to modify element in container");
 
 #if 0
     // had to take this out, because we use QPair in one instance as key
     if (key.isEmpty())
-      throw MYMONEYEXCEPTION("No key to update object");
+      throw MYMONEYEXCEPTION_CSTRING("No key to update object");
 #endif
 
     // check if information about the object identified by 'key'
     // is already present in the stack
     if (!required(key)) {
       this->QMap<Key, T>::insert(key, obj);
       return;
     }
 
     m_stack.push(new MyMoneyMapModify(this, key, obj));
   }
 
   void remove(const Key& key) {
     if (m_stack.isEmpty())
-      throw MYMONEYEXCEPTION("No transaction started to remove element from container");
+      throw MYMONEYEXCEPTION_CSTRING("No transaction started to remove element from container");
 
 #if 0
     // had to take this out, because we use QPair in one instance as key
     if (key.isEmpty())
-      throw MYMONEYEXCEPTION("No key to remove object");
+      throw MYMONEYEXCEPTION_CSTRING("No key to remove object");
 #endif
 
     // check if information about the object identified by 'key'
     // is already present in the stack
     if (!required(key)) {
       this->QMap<Key, T>::remove(key);
       return;
     }
 
     m_stack.push(new MyMoneyMapRemove(this, key));
   }
 
   MyMoneyMap<Key, T>& operator= (const QMap<Key, T>& m) {
     if (!m_stack.isEmpty()) {
-      throw MYMONEYEXCEPTION("Cannot assign whole container during transaction");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot assign whole container during transaction");
     }
     QMap<Key, T>::operator=(m);
     return *this;
   }
 
 
   inline QList<T> values(void) const {
     return QMap<Key, T>::values();
   }
 
   inline QList<Key> keys(void) const {
     return QMap<Key, T>::keys();
   }
 
   const T& operator[](const Key& k) const {
     return find(k).value();
 #if 0
     /*QT_CHECK_INVALID_MAP_ELEMENT;*/ /*PORT ME KDE4*/ return QMap<Key, T>::operator[](k);
 #endif
   }
 
   inline typename QMap<Key, T>::const_iterator find(const Key& k) const {
     return QMap<Key, T>::find(k);
   }
 
   inline typename QMap<Key, T>::const_iterator begin(void) const {
     return QMap<Key, T>::constBegin();
   }
 
   inline typename QMap<Key, T>::const_iterator end(void) const {
     return QMap<Key, T>::constEnd();
   }
 
   typedef typename QMap<Key, T>::const_iterator const_iterator;
 
   inline bool contains(const Key& k) const {
     return find(k) != end();
   }
 
   inline void map(QMap<Key, T>& that) const {
     //QMap<Key, T>* ptr = dynamic_cast<QMap<Key, T>* >(this);
     //that = *ptr;
     that = *(static_cast<QMap<Key, T>* >(const_cast<MyMoneyMap<Key, T>* >(this)));
   }
 
   inline int count(void) const {
     return QMap<Key, T>::count();
   }
 
 #if MY_OWN_DEBUG
   void dump(void) const {
     printf("Container dump\n");
     printf(" items in container = %d\n", count());
     printf(" items on stack     = %d\n", m_stack.count());
 
     const_iterator it;
     for (it = begin(); it != end(); ++it) {
       printf("  %s \n", it.key().data());
     }
   }
 #endif
 
 private:
   class MyMoneyMapAction
   {
   public:
     MyMoneyMapAction(MyMoneyMap<Key, T>* container) :
         m_container(container) {}
 
     MyMoneyMapAction(MyMoneyMap<Key, T>* container, const Key& key, const T& obj) :
         m_container(container),
         m_obj(obj),
         m_key(key) {}
 
     virtual ~MyMoneyMapAction() {}
     virtual void undo(void) = 0;
     const Key& key(void) const {
       return m_key;
     }
 
   protected:
     MyMoneyMap<Key, T>* m_container;
     T m_obj;
     Key m_key;
   };
 
   class MyMoneyMapStart : public MyMoneyMapAction
   {
   public:
     MyMoneyMapStart(MyMoneyMap<Key, T>* container, unsigned long* id) :
         MyMoneyMapAction(container),
         m_idPtr(id),
         m_id(0) {
       if (id != 0)
         m_id = *id;
     }
     ~MyMoneyMapStart() final {}
     void undo(void) final override {
       if (m_idPtr != 0)
         *m_idPtr = m_id;
     }
 
   private:
     unsigned long* m_idPtr;
     unsigned long  m_id;
   };
 
   class MyMoneyMapInsert : public MyMoneyMapAction
   {
   public:
     MyMoneyMapInsert(MyMoneyMap<Key, T>* container, const Key& key, const T& obj) :
         MyMoneyMapAction(container, key, obj) {
       container->QMap<Key, T>::insert(key, obj);
     }
 
     ~MyMoneyMapInsert() final {}
     void undo(void) final override {
       // m_container->remove(m_key) does not work on GCC 4.0.2
       // using this-> to access those member does the trick
       this->m_container->QMap<Key, T>::remove(this->m_key);
     }
   };
 
   class MyMoneyMapRemove : public MyMoneyMapAction
   {
   public:
     MyMoneyMapRemove(MyMoneyMap<Key, T>* container, const Key& key) :
         MyMoneyMapAction(container, key, (*container)[key]) {
       container->QMap<Key, T>::remove(key);
     }
 
     ~MyMoneyMapRemove() final {}
     void undo(void) final override {
       this->m_container->insert(this->m_key, this->m_obj);
     }
   };
 
   class MyMoneyMapModify : public MyMoneyMapAction
   {
   public:
     MyMoneyMapModify(MyMoneyMap<Key, T>* container, const Key& key, const T& obj) :
         MyMoneyMapAction(container, key, (*container)[key]) {
       container->QMap<Key, T>::insert(key, obj);
     }
 
     ~MyMoneyMapModify() final {}
     void undo(void) final override {
       this->m_container->QMap<Key, T>::insert(this->m_key, this->m_obj);
     }
   };
 
 protected:
   QStack<MyMoneyMapAction *> m_stack;
 };
 
 #if MY_OWN_DEBUG
 #include <mymoneyaccount.h>
 #include <mymoneytransaction.h>
 main()
 {
   MyMoneyMap<QString, MyMoneyAccount> container;
   MyMoneyMap<QString, MyMoneyTransaction> ct;
 
   MyMoneyAccount acc;
   acc.setName("Test");
   // this should not be possible
   // container["a"] = acc;
 
   QList<MyMoneyAccount> list;
   list = container.values();
 
   MyMoneyAccount b;
   b.setName("Thomas");
 
   try {
     container.startTransaction();
     container.insert("001", acc);
     container.dump();
     container.commitTransaction();
     acc.setName("123");
     container.startTransaction();
     container.modify("001", acc);
     container.dump();
     container.rollbackTransaction();
     container.dump();
 
     container.startTransaction();
     container.remove(QString("001"));
     container.dump();
     container.rollbackTransaction();
     container.dump();
 
     b = container["001"];
     printf("b.name() = %s\n", b.name().data());
 
     QMap<QString, MyMoneyAccount>::ConstIterator it;
     it = container.find("001");
     it = container.begin();
 
   } catch (const MyMoneyException &e) {
     printf("Caught exception: %s\n", e.what().data());
   }
 
   QMap<QString, MyMoneyAccount> map;
   map["005"] = b;
   container = map;
 
   printf("b.name() = %s\n", container["001"].name().data());
   printf("b.name() = %s\n", container["005"].name().data());
 }
 
 #endif
 
 #endif
diff --git a/kmymoney/mymoney/storage/mymoneystorageanon.cpp b/kmymoney/mymoney/storage/mymoneystorageanon.cpp
index d9891b31f..70925c504 100644
--- a/kmymoney/mymoney/storage/mymoneystorageanon.cpp
+++ b/kmymoney/mymoney/storage/mymoneystorageanon.cpp
@@ -1,328 +1,328 @@
 /***************************************************************************
                           mymoneystorageanon.cpp
                              -------------------
     begin                : Thu Oct 24 2002
     copyright            : (C) 2000-2002 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 "mymoneystorageanon.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QMap>
 #include <QList>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QTime>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneystoragemgr.h"
 #include "mymoneyreport.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneybudget.h"
 #include "mymoneytransaction.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneykeyvaluecontainer.h"
 #include "mymoneyexception.h"
 
 QStringList MyMoneyStorageANON::zKvpNoModify = QString("kmm-baseCurrency,OpeningBalanceAccount,PreferredAccount,Tax,fixed-interest,interest-calculation,payee,schedule,term,kmm-online-source,kmm-brokerage-account,lastStatementDate,kmm-sort-reconcile,kmm-sort-std,kmm-iconpos,mm-closed,payee,schedule,term,lastImportedTransactionDate,VatAccount,VatRate,kmm-matched-tx,Imported,priceMode").split(',');
 QStringList MyMoneyStorageANON::zKvpXNumber = QString("final-payment,loan-amount,periodic-payment,lastStatementBalance").split(',');
 
 
 MyMoneyStorageANON::MyMoneyStorageANON() :
     MyMoneyStorageXML()
 {
   // Choose a quasi-random 0.0-100.0 factor which will be applied to all splits this time
   // around.
 
   int msec;
   do {
     msec = QTime::currentTime().msec();
   } while (msec == 0);
   m_factor = MyMoneyMoney(msec, 10).reduce();
 }
 
 MyMoneyStorageANON::~MyMoneyStorageANON()
 {
 }
 
 void MyMoneyStorageANON::readFile(QIODevice* , MyMoneyStorageMgr*)
 {
-  throw MYMONEYEXCEPTION("Cannot read a file through MyMoneyStorageANON!!");
+  throw MYMONEYEXCEPTION_CSTRING("Cannot read a file through MyMoneyStorageANON!!");
 }
 
 void MyMoneyStorageANON::writeUserInformation(QDomElement& userInfo)
 {
   MyMoneyPayee user = m_storage->user();
 
   userInfo.setAttribute(QString("name"), hideString(user.name()));
   userInfo.setAttribute(QString("email"), hideString(user.email()));
 
   QDomElement address = m_doc->createElement("ADDRESS");
   address.setAttribute(QString("street"), hideString(user.address()));
   address.setAttribute(QString("city"), hideString(user.city()));
   address.setAttribute(QString("county"), hideString(user.state()));
   address.setAttribute(QString("zipcode"), hideString(user.postcode()));
   address.setAttribute(QString("telephone"), hideString(user.telephone()));
 
   userInfo.appendChild(address);
 }
 
 void MyMoneyStorageANON::writeInstitution(QDomElement& institution, const MyMoneyInstitution& _i)
 {
   MyMoneyInstitution i(_i);
 
   // mangle fields
   i.setName(i.id());
   i.setManager(hideString(i.manager()));
   i.setSortcode(hideString(i.sortcode()));
 
   i.setStreet(hideString(i.street()));
   i.setCity(hideString(i.city()));
   i.setPostcode(hideString(i.postcode()));
   i.setTelephone(hideString(i.telephone()));
 
   MyMoneyStorageXML::writeInstitution(institution, i);
 }
 
 
 void MyMoneyStorageANON::writePayee(QDomElement& payee, const MyMoneyPayee& _p)
 {
   MyMoneyPayee p(_p);
 
   p.setName(p.id());
   p.setReference(hideString(p.reference()));
 
   p.setAddress(hideString(p.address()));
   p.setCity(hideString(p.city()));
   p.setPostcode(hideString(p.postcode()));
   p.setState(hideString(p.state()));
   p.setTelephone(hideString(p.telephone()));
   p.setNotes(hideString(p.notes()));
   bool ignoreCase;
   QStringList keys;
   MyMoneyPayee::payeeMatchType matchType = p.matchData(ignoreCase, keys);
   QRegExp exp("[A-Za-z]");
   p.setMatchData(matchType, ignoreCase, keys.join(";").replace(exp, "x").split(';'));
 
   // Data from plugins cannot be estranged, yet.
   p.resetPayeeIdentifiers();
 
   MyMoneyStorageXML::writePayee(payee, p);
 }
 
 void MyMoneyStorageANON::writeTag(QDomElement& tag, const MyMoneyTag& _ta)
 {
   MyMoneyTag ta(_ta);
 
   ta.setName(ta.id());
   ta.setNotes(hideString(ta.notes()));
   MyMoneyStorageXML::writeTag(tag, ta);
 }
 
 void MyMoneyStorageANON::writeAccount(QDomElement& account, const MyMoneyAccount& _p)
 {
   MyMoneyAccount p(_p);
 
   p.setNumber(hideString(p.number()));
   p.setName(p.id());
   p.setDescription(hideString(p.description()));
   fakeKeyValuePair(p);
 
   // Remove the online banking settings entirely.
   p.setOnlineBankingSettings(MyMoneyKeyValueContainer());
 
   MyMoneyStorageXML::writeAccount(account, p);
 }
 
 void MyMoneyStorageANON::fakeTransaction(MyMoneyTransaction& tx)
 {
   MyMoneyTransaction tn = tx;
 
   // hide transaction data
   tn.setMemo(tx.id());
   tn.setBankID(hideString(tx.bankID()));
 
   // hide split data
   foreach (const auto split, tx.splits()) {
     MyMoneySplit s = split;
     s.setMemo(QString("%1/%2").arg(tn.id()).arg(s.id()));
 
     if (s.value() != MyMoneyMoney::autoCalc) {
       s.setValue((s.value() * m_factor));
       s.setShares((s.shares() * m_factor));
     }
     s.setNumber(hideString(s.number()));
 
     // obfuscate a possibly matched transaction as well
     if (s.isMatched()) {
       MyMoneyTransaction t = s.matchedTransaction();
       fakeTransaction(t);
       s.removeMatch();
       s.addMatch(t);
     }
     tn.modifySplit(s);
   }
   tx = tn;
   fakeKeyValuePair(tx);
 }
 
 void MyMoneyStorageANON::fakeKeyValuePair(MyMoneyKeyValueContainer& kvp)
 {
   QMap<QString, QString> pairs;
   QMap<QString, QString>::const_iterator it;
 
   for (it = kvp.pairs().constBegin(); it != kvp.pairs().constEnd(); ++it) {
     if (zKvpXNumber.contains(it.key()) || it.key().left(3) == "ir-")
       pairs[it.key()] = hideNumber(MyMoneyMoney(it.value())).toString();
     else if (zKvpNoModify.contains(it.key()))
       pairs[it.key()] = it.value();
     else
       pairs[it.key()] = hideString(it.value());
   }
   kvp.setPairs(pairs);
 }
 
 void MyMoneyStorageANON::writeTransaction(QDomElement& transactions, const MyMoneyTransaction& tx)
 {
   MyMoneyTransaction tn = tx;
 
   fakeTransaction(tn);
 
   MyMoneyStorageXML::writeTransaction(transactions, tn);
 }
 
 void MyMoneyStorageANON::writeSchedule(QDomElement& scheduledTx, const MyMoneySchedule& sx)
 {
   MyMoneySchedule sn = sx;
   MyMoneyTransaction tn = sn.transaction();
 
   fakeTransaction(tn);
 
   sn.setName(sx.id());
   sn.setTransaction(tn, true);
 
   MyMoneyStorageXML::writeSchedule(scheduledTx, sn);
 }
 
 void MyMoneyStorageANON::writeSecurity(QDomElement& securityElement, const MyMoneySecurity& security)
 {
   MyMoneySecurity s = security;
   s.setName(security.id());
   fakeKeyValuePair(s);
 
   MyMoneyStorageXML::writeSecurity(securityElement, s);
 }
 
 QString MyMoneyStorageANON::hideString(const QString& _in) const
 {
   return QString(_in).fill('x');
 }
 
 MyMoneyMoney MyMoneyStorageANON::hideNumber(const MyMoneyMoney& _in) const
 {
   MyMoneyMoney result;
   static MyMoneyMoney counter = MyMoneyMoney(100, 100);
 
   // preserve sign
   if (_in.isNegative())
     result = MyMoneyMoney::MINUS_ONE;
   else
     result = MyMoneyMoney::ONE;
 
   result = result * counter;
   counter += MyMoneyMoney("10/100");
 
   // preserve > 1000
   if (_in >= MyMoneyMoney(1000, 1))
     result = result * MyMoneyMoney(1000, 1);
   if (_in <= MyMoneyMoney(-1000, 1))
     result = result * MyMoneyMoney(1000, 1);
 
   return result.convert();
 }
 
 void MyMoneyStorageANON::fakeBudget(MyMoneyBudget& bx)
 {
   MyMoneyBudget bn;
 
   bn.setName(bx.id());
   bn.setBudgetStart(bx.budgetStart());
   bn = MyMoneyBudget(bx.id(), bn);
 
   QList<MyMoneyBudget::AccountGroup> list = bx.getaccounts();
   QList<MyMoneyBudget::AccountGroup>::iterator it;
   for (it = list.begin(); it != list.end(); ++it) {
     // only add the account if there is a budget entered
     if (!(*it).balance().isZero()) {
       MyMoneyBudget::AccountGroup account;
       account.setId((*it).id());
       account.setBudgetLevel((*it).budgetLevel());
       account.setBudgetSubaccounts((*it).budgetSubaccounts());
       QMap<QDate, MyMoneyBudget::PeriodGroup> plist = (*it).getPeriods();
       QMap<QDate, MyMoneyBudget::PeriodGroup>::const_iterator it_p;
       for (it_p = plist.constBegin(); it_p != plist.constEnd(); ++it_p) {
         MyMoneyBudget::PeriodGroup pGroup;
         pGroup.setAmount((*it_p).amount() * m_factor);
         pGroup.setStartDate((*it_p).startDate());
         account.addPeriod(pGroup.startDate(), pGroup);
       }
       bn.setAccount(account, account.id());
     }
   }
 
   bx = bn;
 }
 
 void MyMoneyStorageANON::writeBudget(QDomElement& budgets, const MyMoneyBudget& b)
 {
   MyMoneyBudget bn = b;
 
   fakeBudget(bn);
 
   MyMoneyStorageXML::writeBudget(budgets, bn);
 }
 
 void MyMoneyStorageANON::writeReport(QDomElement& reports, const MyMoneyReport& r)
 {
   MyMoneyReport rn = r;
 
   rn.setName(rn.id());
   rn.setComment(hideString(rn.comment()));
 
   MyMoneyStorageXML::writeReport(reports, rn);
 }
 
 void MyMoneyStorageANON::writeOnlineJob(QDomElement& onlineJobs, const onlineJob& job)
 {
   Q_UNUSED(onlineJobs);
   Q_UNUSED(job);
 }
diff --git a/kmymoney/mymoney/storage/mymoneystoragemgr.cpp b/kmymoney/mymoney/storage/mymoneystoragemgr.cpp
index 57ea5b5a3..e2f401504 100644
--- a/kmymoney/mymoney/storage/mymoneystoragemgr.cpp
+++ b/kmymoney/mymoney/storage/mymoneystoragemgr.cpp
@@ -1,1959 +1,1919 @@
 /***************************************************************************
                           mymoneygenericstorage.cpp
                              -------------------
     begin                : Sun May 5 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <mte@users.sourceforge.net>
                                2002 Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneystoragemgr_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QHash>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyprice.h"
 
 MyMoneyStorageMgr::MyMoneyStorageMgr() :
   d_ptr(new MyMoneyStorageMgrPrivate(this))
 {
   Q_D(MyMoneyStorageMgr);
   d->init();
 }
 
 MyMoneyStorageMgr::~MyMoneyStorageMgr()
 {
   Q_D(MyMoneyStorageMgr);
   delete d;
 }
 
 MyMoneyPayee MyMoneyStorageMgr::user() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_user;
 }
 
 QDate MyMoneyStorageMgr::creationDate() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_creationDate;
 }
 
 QDate MyMoneyStorageMgr::lastModificationDate() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_lastModificationDate;
 }
 
 uint MyMoneyStorageMgr::currentFixVersion() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_currentFixVersion;
 }
 
 uint MyMoneyStorageMgr::fileFixVersion() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_fileFixVersion;
 }
 
 void MyMoneyStorageMgr::setUser(const MyMoneyPayee& user)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_user = user;
   d->touch();
 }
 
 void MyMoneyStorageMgr::setCreationDate(const QDate& val)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_creationDate = val; d->touch();
 }
 
 void MyMoneyStorageMgr::setLastModificationDate(const QDate& val)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_lastModificationDate = val; d->m_dirty = false;
 }
 
 void MyMoneyStorageMgr::setFileFixVersion(uint v)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_fileFixVersion = v;
 }
 
 bool MyMoneyStorageMgr::isStandardAccount(const QString& id) const
 {
   return id == stdAccNames[stdAccLiability]
          || id == stdAccNames[stdAccAsset]
          || id == stdAccNames[stdAccExpense]
          || id == stdAccNames[stdAccIncome]
          || id == stdAccNames[stdAccEquity];
 }
 
 void MyMoneyStorageMgr::setAccountName(const QString& id, const QString& name)
 {
   Q_D(MyMoneyStorageMgr);
   if (!isStandardAccount(id))
-    throw MYMONEYEXCEPTION("Only standard accounts can be modified using setAccountName()");
+    throw MYMONEYEXCEPTION_CSTRING("Only standard accounts can be modified using setAccountName()");
 
   auto acc = d->m_accountList[id];
   acc.setName(name);
   d->m_accountList.modify(acc.id(), acc);
 }
 
 MyMoneyAccount MyMoneyStorageMgr::account(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   // locate the account and if present, return it's data
   if (d->m_accountList.find(id) != d->m_accountList.end()) {
     auto acc = d->m_accountList[id];
     // is that needed at all?
     if (acc.fraction() == -1) {
       const auto& sec = security(acc.currencyId());
       acc.fraction(sec);
     }
     return acc;
   }
 
   // throw an exception, if it does not exist
-  const auto msg = QString::fromLatin1("Unknown account id '%1'").arg(id);
-  throw MYMONEYEXCEPTION(msg);
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown account id '%1'").arg(id));
 }
 
 MyMoneyAccount MyMoneyStorageMgr::accountByName(const QString& name) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (name.isEmpty())
     return MyMoneyAccount();
 
   QMap<QString, MyMoneyAccount>::ConstIterator it_a;
 
   for (it_a = d->m_accountList.begin(); it_a != d->m_accountList.end(); ++it_a) {
     if ((*it_a).name() == name) {
       return *it_a;
     }
   }
 
-  throw MYMONEYEXCEPTION("Unknown account '" + name + '\'');
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown account '%1'").arg(name));
 }
 
 void MyMoneyStorageMgr::accountList(QList<MyMoneyAccount>& list) const
 {
   Q_D(const MyMoneyStorageMgr);
   foreach(const QString& accountId, d->m_accountList.keys()) {
     if (!isStandardAccount(accountId)) {
       list.append(account(accountId));
     }
   }
 }
 
 void MyMoneyStorageMgr::addAccount(MyMoneyAccount& account)
 {
   Q_D(MyMoneyStorageMgr);
   // create the account.
   MyMoneyAccount newAccount(d->nextAccountID(), account);
   d->m_accountList.insert(newAccount.id(), newAccount);
 
   account = newAccount;
 }
 
 void MyMoneyStorageMgr::addPayee(MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageMgr);
   // create the payee
   MyMoneyPayee newPayee(d->nextPayeeID(), payee);
   d->m_payeeList.insert(newPayee.id(), newPayee);
   payee = newPayee;
 }
 
 /**
  * @brief Add onlineJob to storage
  * @param job caller stays owner of the object, but id will be set
  */
 void MyMoneyStorageMgr::addOnlineJob(onlineJob &job)
 {
   Q_D(MyMoneyStorageMgr);
   onlineJob newJob = onlineJob(d->nextOnlineJobID(), job);
   d->m_onlineJobList.insert(newJob.id(), newJob);
   job = newJob;
 }
 
 void MyMoneyStorageMgr::removeOnlineJob(const onlineJob& job)
 {
   Q_D(MyMoneyStorageMgr);
-  if (!d->m_onlineJobList.contains(job.id())) {
-    throw MYMONEYEXCEPTION("Unknown onlineJob '" + job.id() + "' should be removed.");
-  }
+  if (!d->m_onlineJobList.contains(job.id()))
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown onlineJob '%1' should be removed.").arg(job.id()));
+
   d->m_onlineJobList.remove(job.id());
 }
 
 void MyMoneyStorageMgr::modifyOnlineJob(const onlineJob &job)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, onlineJob>::ConstIterator iter = d->m_onlineJobList.find(job.id());
-  if (iter == d->m_onlineJobList.end()) {
-    throw MYMONEYEXCEPTION("Got unknown onlineJob '" + job.id() + "' for modifying");
-  }
+  if (iter == d->m_onlineJobList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Got unknown onlineJob '%1' for modifying").arg(job.id()));
   onlineJob oldJob = iter.value();
   d->m_onlineJobList.modify((*iter).id(), job);
 }
 
 onlineJob MyMoneyStorageMgr::getOnlineJob(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (d->m_onlineJobList.contains(id)) {
     return d->m_onlineJobList[id];
   }
-  throw MYMONEYEXCEPTION("Unknown online Job '" + id + '\'');
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown online Job '%1'").arg(id));
 }
 
 ulong MyMoneyStorageMgr::onlineJobId() const
 {
   return 1;
 }
 
 MyMoneyPayee MyMoneyStorageMgr::payee(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneyPayee>::ConstIterator it;
   it = d->m_payeeList.find(id);
   if (it == d->m_payeeList.end())
-    throw MYMONEYEXCEPTION("Unknown payee '" + id + '\'');
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown payee '%1'").arg(id));
 
   return *it;
 }
 
 MyMoneyPayee MyMoneyStorageMgr::payeeByName(const QString& payee) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (payee.isEmpty())
     return MyMoneyPayee::null;
 
   QMap<QString, MyMoneyPayee>::ConstIterator it_p;
 
   for (it_p = d->m_payeeList.begin(); it_p != d->m_payeeList.end(); ++it_p) {
     if ((*it_p).name() == payee) {
       return *it_p;
     }
   }
 
-  throw MYMONEYEXCEPTION("Unknown payee '" + payee + '\'');
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown payee '%1'").arg(payee));
 }
 
 void MyMoneyStorageMgr::modifyPayee(const MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyPayee>::ConstIterator it;
 
   it = d->m_payeeList.find(payee.id());
-  if (it == d->m_payeeList.end()) {
-    QString msg = "Unknown payee '" + payee.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_payeeList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown payee '%1'").arg(payee.id()));
+
   d->m_payeeList.modify((*it).id(), payee);
 }
 
 void MyMoneyStorageMgr::removePayee(const MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
   QMap<QString, MyMoneySchedule>::ConstIterator it_s;
   QMap<QString, MyMoneyPayee>::ConstIterator it_p;
 
   it_p = d->m_payeeList.find(payee.id());
-  if (it_p == d->m_payeeList.end()) {
-    QString msg = "Unknown payee '" + payee.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it_p == d->m_payeeList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown payee '%1'").arg(payee.id()));
 
   // scan all transactions to check if the payee is still referenced
   for (it_t = d->m_transactionList.begin(); it_t != d->m_transactionList.end(); ++it_t) {
     if ((*it_t).hasReferenceTo(payee.id())) {
-      throw MYMONEYEXCEPTION(QString("Cannot remove payee that is still referenced to a %1").arg("transaction"));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove payee that is still referenced to a %1").arg("transaction"));
     }
   }
 
   // check referential integrity in schedules
   for (it_s = d->m_scheduleList.begin(); it_s != d->m_scheduleList.end(); ++it_s) {
     if ((*it_s).hasReferenceTo(payee.id())) {
-      throw MYMONEYEXCEPTION(QString("Cannot remove payee that is still referenced to a %1").arg("schedule"));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove payee that is still referenced to a %1").arg("schedule"));
     }
   }
 
   // remove any reference to report and/or budget
   d->removeReferences(payee.id());
 
   d->m_payeeList.remove((*it_p).id());
 }
 
 QList<MyMoneyPayee> MyMoneyStorageMgr::payeeList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_payeeList.values();
 }
 
 void MyMoneyStorageMgr::addTag(MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageMgr);
   // create the tag
   MyMoneyTag newTag(d->nextTagID(), tag);
   d->m_tagList.insert(newTag.id(), newTag);
   tag = newTag;
 }
 
 MyMoneyTag MyMoneyStorageMgr::tag(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneyTag>::ConstIterator it;
   it = d->m_tagList.find(id);
   if (it == d->m_tagList.end())
-    throw MYMONEYEXCEPTION("Unknown tag '" + id + '\'');
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown tag '%1'").arg(id));
 
   return *it;
 }
 
 MyMoneyTag MyMoneyStorageMgr::tagByName(const QString& tag) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (tag.isEmpty())
     return MyMoneyTag::null;
 
   QMap<QString, MyMoneyTag>::ConstIterator it_ta;
 
   for (it_ta = d->m_tagList.begin(); it_ta != d->m_tagList.end(); ++it_ta) {
     if ((*it_ta).name() == tag) {
       return *it_ta;
     }
   }
 
-  throw MYMONEYEXCEPTION("Unknown tag '" + tag + '\'');
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown tag '%1'").arg(tag));
 }
 
 void MyMoneyStorageMgr::modifyTag(const MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyTag>::ConstIterator it;
 
   it = d->m_tagList.find(tag.id());
-  if (it == d->m_tagList.end()) {
-    QString msg = "Unknown tag '" + tag.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_tagList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown tag '%1'").arg(tag.id()));
+
   d->m_tagList.modify((*it).id(), tag);
 }
 
 void MyMoneyStorageMgr::removeTag(const MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
   QMap<QString, MyMoneySchedule>::ConstIterator it_s;
   QMap<QString, MyMoneyTag>::ConstIterator it_ta;
 
   it_ta = d->m_tagList.find(tag.id());
-  if (it_ta == d->m_tagList.end()) {
-    QString msg = "Unknown tag '" + tag.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it_ta == d->m_tagList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown tag '%1'").arg(tag.id()));
 
   // scan all transactions to check if the tag is still referenced
   for (it_t = d->m_transactionList.begin(); it_t != d->m_transactionList.end(); ++it_t) {
     if ((*it_t).hasReferenceTo(tag.id())) {
-      throw MYMONEYEXCEPTION(QString("Cannot remove tag that is still referenced to a %1").arg("transaction"));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove tag that is still referenced to a %1").arg("transaction"));
     }
   }
 
   // check referential integrity in schedules
   for (it_s = d->m_scheduleList.begin(); it_s != d->m_scheduleList.end(); ++it_s) {
     if ((*it_s).hasReferenceTo(tag.id())) {
-      throw MYMONEYEXCEPTION(QString("Cannot remove tag that is still referenced to a %1").arg("schedule"));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove tag that is still referenced to a %1").arg("schedule"));
     }
   }
 
   // remove any reference to report and/or budget
   d->removeReferences(tag.id());
 
   d->m_tagList.remove((*it_ta).id());
 }
 
 QList<MyMoneyTag> MyMoneyStorageMgr::tagList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_tagList.values();
 }
 
 void MyMoneyStorageMgr::addAccount(MyMoneyAccount& parent, MyMoneyAccount& account)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyAccount>::ConstIterator theParent;
   QMap<QString, MyMoneyAccount>::ConstIterator theChild;
 
   theParent = d->m_accountList.find(parent.id());
-  if (theParent == d->m_accountList.end()) {
-    QString msg = "Unknown parent account '";
-    msg += parent.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (theParent == d->m_accountList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown parent account '%1'").arg(parent.id()));
 
   theChild = d->m_accountList.find(account.id());
-  if (theChild == d->m_accountList.end()) {
-    QString msg = "Unknown child account '";
-    msg += account.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (theChild == d->m_accountList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown child account '%1'").arg(account.id()));
 
   auto acc = *theParent;
   acc.addAccountId(account.id());
   d->m_accountList.modify(acc.id(), acc);
   parent = acc;
 
   acc = *theChild;
   acc.setParentAccountId(parent.id());
   d->m_accountList.modify(acc.id(), acc);
   account = acc;
 
 }
 
 void MyMoneyStorageMgr::addInstitution(MyMoneyInstitution& institution)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyInstitution newInstitution(d->nextInstitutionID(), institution);
 
   d->m_institutionList.insert(newInstitution.id(), newInstitution);
 
   // return new data
   institution = newInstitution;
 }
 
 uint MyMoneyStorageMgr::transactionCount(const QString& account) const
 {
   Q_D(const MyMoneyStorageMgr);
   uint cnt = 0;
 
   if (account.length() == 0) {
     cnt = d->m_transactionList.count();
 
   } else {
     // scan all transactions
     foreach (const auto transaction, d->m_transactionList) {
       // scan all splits of this transaction
       auto found = false;
       foreach (const auto split, transaction.splits()) {
         // is it a split in our account?
         if (split.accountId() == account) {
           // since a transaction can only have one split referencing
           // each account, we're done with the splits here!
           found = true;
           break;
         }
       }
       // if no split contains the account id, continue with the
       // next transaction
       if (!found)
         continue;
 
       // otherwise count it
       ++cnt;
     }
   }
   return cnt;
 }
 
 QMap<QString, ulong> MyMoneyStorageMgr::transactionCountMap() const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, ulong> map;
 
   // scan all transactions
   foreach (const auto transaction, d->m_transactionList) {
     // scan all splits of this transaction
     foreach (const auto split, transaction.splits()) {
       map[split.accountId()]++;
     }
   }
   return map;
 }
 
 uint MyMoneyStorageMgr::institutionCount() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_institutionList.count();
 }
 
 uint MyMoneyStorageMgr::accountCount() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_accountList.count();
 }
 
 void MyMoneyStorageMgr::addTransaction(MyMoneyTransaction& transaction, bool skipAccountUpdate)
 {
   Q_D(MyMoneyStorageMgr);
   // perform some checks to see that the transaction stuff is OK. For
   // now we assume that
   // * no ids are assigned
   // * the date valid (must not be empty)
   // * the referenced accounts in the splits exist
 
   // first perform all the checks
   if (!transaction.id().isEmpty())
-    throw MYMONEYEXCEPTION("transaction already contains an id");
+    throw MYMONEYEXCEPTION_CSTRING("transaction already contains an id");
   if (!transaction.postDate().isValid())
-    throw MYMONEYEXCEPTION("invalid post date");
+    throw MYMONEYEXCEPTION_CSTRING("invalid post date");
 
   // now check the splits
   foreach (const auto split, transaction.splits()) {
     // the following lines will throw an exception if the
     // account or payee do not exist
     account(split.accountId());
     if (!split.payeeId().isEmpty())
       payee(split.payeeId());
   }
 
   MyMoneyTransaction newTransaction(d->nextTransactionID(), transaction);
   QString key = newTransaction.uniqueSortKey();
 
   d->m_transactionList.insert(key, newTransaction);
   d->m_transactionKeys.insert(newTransaction.id(), key);
 
   transaction = newTransaction;
 
   // adjust the balance of all affected accounts
   foreach (const auto split, transaction.splits()) {
     auto acc = d->m_accountList[split.accountId()];
     d->adjustBalance(acc, split, false);
     if (!skipAccountUpdate) {
       acc.touch();
     }
     d->m_accountList.modify(acc.id(), acc);
   }
 }
 
 bool MyMoneyStorageMgr::hasActiveSplits(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneyTransaction>::ConstIterator it;
 
   for (it = d->m_transactionList.begin(); it != d->m_transactionList.end(); ++it) {
     if ((*it).accountReferenced(id)) {
       return true;
     }
   }
   return false;
 }
 
 MyMoneyInstitution MyMoneyStorageMgr::institution(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneyInstitution>::ConstIterator pos;
 
   pos = d->m_institutionList.find(id);
   if (pos != d->m_institutionList.end())
     return *pos;
-  throw MYMONEYEXCEPTION("unknown institution");
+  throw MYMONEYEXCEPTION_CSTRING("unknown institution");
 }
 
 bool MyMoneyStorageMgr::dirty() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_dirty;
 }
 
 void MyMoneyStorageMgr::setDirty()
 {
   Q_D(MyMoneyStorageMgr);
   d->m_dirty = true;
 }
 
 QList<MyMoneyInstitution> MyMoneyStorageMgr::institutionList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_institutionList.values();
 }
 
 void MyMoneyStorageMgr::modifyAccount(const MyMoneyAccount& account, bool skipCheck)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyAccount>::ConstIterator pos;
 
   // locate the account in the file global pool
   pos = d->m_accountList.find(account.id());
   if (pos != d->m_accountList.end()) {
     // check if the new info is based on the old one.
     // this is the case, when the file and the id
     // as well as the type are equal.
     if (((*pos).parentAccountId() == account.parentAccountId()
          && ((*pos).accountType() == account.accountType()
              || ((*pos).isLiquidAsset() && account.isLiquidAsset())))
         || skipCheck == true) {
       // make sure that all the referenced objects exist
       if (!account.institutionId().isEmpty())
         institution(account.institutionId());
 
       foreach (const auto sAccount, account.accountList())
         this->account(sAccount);
 
       // update information in account list
       d->m_accountList.modify(account.id(), account);
 
     } else
-      throw MYMONEYEXCEPTION("Invalid information for update");
+      throw MYMONEYEXCEPTION_CSTRING("Invalid information for update");
 
   } else
-    throw MYMONEYEXCEPTION("Unknown account id");
+    throw MYMONEYEXCEPTION_CSTRING("Unknown account id");
 }
 
 void MyMoneyStorageMgr::modifyInstitution(const MyMoneyInstitution& institution)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyInstitution>::ConstIterator pos;
 
   // locate the institution in the file global pool
   pos = d->m_institutionList.find(institution.id());
   if (pos != d->m_institutionList.end()) {
     d->m_institutionList.modify(institution.id(), institution);
 
   } else
-    throw MYMONEYEXCEPTION("unknown institution");
+    throw MYMONEYEXCEPTION_CSTRING("unknown institution");
 }
 
 void MyMoneyStorageMgr::modifyTransaction(const MyMoneyTransaction& transaction)
 {
   Q_D(MyMoneyStorageMgr);
   // perform some checks to see that the transaction stuff is OK. For
   // now we assume that
   // * ids are assigned
   // * the pointer to the MyMoneyFile object is not 0
   // * the date valid (must not be empty)
   // * the splits must have valid account ids
 
   // first perform all the checks
   if (transaction.id().isEmpty()
 //  || transaction.file() != this
       || !transaction.postDate().isValid())
-    throw MYMONEYEXCEPTION("invalid transaction to be modified");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction to be modified");
 
   // now check the splits
   foreach (const auto split, transaction.splits()) {
     // the following lines will throw an exception if the
     // account or payee do not exist
     account(split.accountId());
     if (!split.payeeId().isEmpty())
       payee(split.payeeId());
     foreach (const auto tagId, split.tagIdList()) {
       if (!tagId.isEmpty())
         tag(tagId);
     }
   }
 
   // new data seems to be ok. find old version of transaction
   // in our pool. Throw exception if unknown.
   if (!d->m_transactionKeys.contains(transaction.id()))
-    throw MYMONEYEXCEPTION("invalid transaction id");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction id");
 
   QString oldKey = d->m_transactionKeys[transaction.id()];
   if (!d->m_transactionList.contains(oldKey))
-    throw MYMONEYEXCEPTION("invalid transaction key");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction key");
 
   QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
 
   it_t = d->m_transactionList.find(oldKey);
   if (it_t == d->m_transactionList.end())
-    throw MYMONEYEXCEPTION("invalid transaction key");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction key");
 
   foreach (const auto split, (*it_t).splits()) {
     auto acc = d->m_accountList[split.accountId()];
     // we only need to adjust non-investment accounts here
     // as for investment accounts the balance will be recalculated
     // after the transaction has been added.
     if (!acc.isInvest()) {
       d->adjustBalance(acc, split, true);
       acc.touch();
       d->m_accountList.modify(acc.id(), acc);
     }
   }
 
   // remove old transaction from lists
   d->m_transactionList.remove(oldKey);
 
   // add new transaction to lists
   QString newKey = transaction.uniqueSortKey();
   d->m_transactionList.insert(newKey, transaction);
   d->m_transactionKeys.modify(transaction.id(), newKey);
 
   // adjust account balances
   foreach (const auto split, transaction.splits()) {
     auto acc = d->m_accountList[split.accountId()];
     d->adjustBalance(acc, split, false);
     acc.touch();
     d->m_accountList.modify(acc.id(), acc);
   }
 }
 
 void MyMoneyStorageMgr::reparentAccount(MyMoneyAccount &account, MyMoneyAccount& parent)
 {
   Q_D(MyMoneyStorageMgr);
   d->reparentAccount(account, parent, true);
 }
 
 void MyMoneyStorageMgr::close()
 {
 }
 
 void MyMoneyStorageMgr::removeTransaction(const MyMoneyTransaction& transaction)
 {
   Q_D(MyMoneyStorageMgr);
   // first perform all the checks
   if (transaction.id().isEmpty())
-    throw MYMONEYEXCEPTION("invalid transaction to be deleted");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction to be deleted");
 
   QMap<QString, QString>::ConstIterator it_k;
   QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
 
   it_k = d->m_transactionKeys.find(transaction.id());
   if (it_k == d->m_transactionKeys.end())
-    throw MYMONEYEXCEPTION("invalid transaction to be deleted");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction to be deleted");
 
   it_t = d->m_transactionList.find(*it_k);
   if (it_t == d->m_transactionList.end())
-    throw MYMONEYEXCEPTION("invalid transaction key");
+    throw MYMONEYEXCEPTION_CSTRING("invalid transaction key");
 
   // keep a copy so that we still have the data after removal
   MyMoneyTransaction t(*it_t);
 
   // FIXME: check if any split is frozen and throw exception
 
   // remove the transaction from the two lists
   d->m_transactionList.remove(*it_k);
   d->m_transactionKeys.remove(transaction.id());
 
   // scan the splits and collect all accounts that need
   // to be updated after the removal of this transaction
   foreach (const auto split, t.splits()) {
     auto acc = d->m_accountList[split.accountId()];
     d->adjustBalance(acc, split, true);
     acc.touch();
     d->m_accountList.modify(acc.id(), acc);
   }
 
 }
 
 void MyMoneyStorageMgr::removeAccount(const MyMoneyAccount& account)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyAccount parent;
 
   // check that the account and it's parent exist
   // this will throw an exception if the id is unknown
   MyMoneyStorageMgr::account(account.id());
   parent = MyMoneyStorageMgr::account(account.parentAccountId());
 
   // check that it's not one of the standard account groups
   if (isStandardAccount(account.id()))
-    throw MYMONEYEXCEPTION("Unable to remove the standard account groups");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to remove the standard account groups");
 
   if (hasActiveSplits(account.id())) {
-    throw MYMONEYEXCEPTION("Unable to remove account with active splits");
+    throw MYMONEYEXCEPTION_CSTRING("Unable to remove account with active splits");
   }
 
   // re-parent all sub-ordinate accounts to the parent of the account
   // to be deleted. First round check that all accounts exist, second
   // round do the re-parenting.
 
   foreach (const auto accountID, account.accountList())
     MyMoneyStorageMgr::account(accountID);
 
   // if one of the accounts did not exist, an exception had been
   // thrown and we would not make it until here.
 
   QMap<QString, MyMoneyAccount>::ConstIterator it_a;
   QMap<QString, MyMoneyAccount>::ConstIterator it_p;
 
   // locate the account in the file global pool
 
   it_a = d->m_accountList.find(account.id());
   if (it_a == d->m_accountList.end())
-    throw MYMONEYEXCEPTION("Internal error: account not found in list");
+    throw MYMONEYEXCEPTION_CSTRING("Internal error: account not found in list");
 
   it_p = d->m_accountList.find(parent.id());
   if (it_p == d->m_accountList.end())
-    throw MYMONEYEXCEPTION("Internal error: parent account not found in list");
+    throw MYMONEYEXCEPTION_CSTRING("Internal error: parent account not found in list");
 
   if (!account.institutionId().isEmpty())
-    throw MYMONEYEXCEPTION("Cannot remove account still attached to an institution");
+    throw MYMONEYEXCEPTION_CSTRING("Cannot remove account still attached to an institution");
 
   d->removeReferences(account.id());
 
   // FIXME: check referential integrity for the account to be removed
 
   // check if the new info is based on the old one.
   // this is the case, when the file and the id
   // as well as the type are equal.
   if ((*it_a).id() == account.id()
       && (*it_a).accountType() == account.accountType()) {
 
     // second round over sub-ordinate accounts: do re-parenting
     // but only if the list contains at least one entry
     // FIXME: move this logic to MyMoneyFile
 
     foreach (const auto accountID, (*it_a).accountList()) {
       MyMoneyAccount acc(MyMoneyStorageMgr::account(accountID));
       d->reparentAccount(acc, parent, false);
     }
 
     // remove account from parent's list
     parent.removeAccountId(account.id());
     d->m_accountList.modify(parent.id(), parent);
 
     // remove account from the global account pool
     d->m_accountList.remove(account.id());
   }
 }
 
 void MyMoneyStorageMgr::removeInstitution(const MyMoneyInstitution& institution)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyInstitution>::ConstIterator it_i;
 
   it_i = d->m_institutionList.find(institution.id());
   if (it_i != d->m_institutionList.end()) {
     d->m_institutionList.remove(institution.id());
 
   } else
-    throw MYMONEYEXCEPTION("invalid institution");
+    throw MYMONEYEXCEPTION_CSTRING("invalid institution");
 }
 
 void MyMoneyStorageMgr::transactionList(QList<MyMoneyTransaction>& list, MyMoneyTransactionFilter& filter) const
 {
   Q_D(const MyMoneyStorageMgr);
   list.clear();
 
   const auto& transactions = d->m_transactionList;
   for (const auto& transaction : transactions) {
     // This code is used now. It adds the transaction to the list for
     // each matching split exactly once. This allows to show information
     // about different splits in the same register view (e.g. search result)
     //
     // I have no idea, if this has some impact on the functionality. So far,
     // I could not see it.  (ipwizard 9/5/2003)
     const auto cnt = filter.matchingSplitsCount(transaction);
     for (uint i = 0; i < cnt; ++i)
       list.append(transaction);
   }
 }
 
 void MyMoneyStorageMgr::transactionList(QList< QPair<MyMoneyTransaction, MyMoneySplit> >& list, MyMoneyTransactionFilter& filter) const
 {
   Q_D(const MyMoneyStorageMgr);
   list.clear();
 
   for (const auto& transaction : d->m_transactionList)
     for (const auto& split : filter.matchingSplits(transaction))
       list.append(qMakePair(transaction, split));
 }
 
 QList<MyMoneyTransaction> MyMoneyStorageMgr::transactionList(MyMoneyTransactionFilter& filter) const
 {
   QList<MyMoneyTransaction> list;
   transactionList(list, filter);
   return list;
 }
 
 QList<onlineJob> MyMoneyStorageMgr::onlineJobList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_onlineJobList.values();
 }
 
 QList< MyMoneyCostCenter > MyMoneyStorageMgr::costCenterList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_costCenterList.values();
 }
 
 MyMoneyCostCenter MyMoneyStorageMgr::costCenter(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
-  if (!d->m_costCenterList.contains(id)) {
-    QString msg = QString("Invalid cost center id '%1'").arg(id);
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (!d->m_costCenterList.contains(id))
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid cost center id '%1'").arg(id));
   return d->m_costCenterList[id];
 }
 
 bool MyMoneyStorageMgr::isDuplicateTransaction(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_transactionKeys.contains(id);
 }
 
 MyMoneyTransaction MyMoneyStorageMgr::transaction(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   // get the full key of this transaction, throw exception
   // if it's invalid (unknown)
   if (!d->m_transactionKeys.contains(id)) {
-    QString msg = QString("Invalid transaction id '%1'").arg(id);
-    throw MYMONEYEXCEPTION(msg);
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid transaction id '%1'").arg(id));
   }
 
   // check if this key is in the list, throw exception if not
   QString key = d->m_transactionKeys[id];
-  if (!d->m_transactionList.contains(key)) {
-    QString msg = QString("Invalid transaction key '%1'").arg(key);
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (!d->m_transactionList.contains(key))
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid transaction key '%1'").arg(key));
 
   return d->m_transactionList[key];
 }
 
 MyMoneyTransaction MyMoneyStorageMgr::transaction(const QString& account, const int idx) const
 {
   Q_D(const MyMoneyStorageMgr);
   /* removed with MyMoneyAccount::Transaction
     QMap<QString, MyMoneyAccount>::ConstIterator acc;
 
     // find account object in list, throw exception if unknown
     acc = m_accountList.find(account);
     if(acc == m_accountList.end())
-      throw MYMONEYEXCEPTION("unknown account id");
+      throw MYMONEYEXCEPTION_CSTRING("unknown account id");
 
     // get the transaction info from the account
     MyMoneyAccount::Transaction t = (*acc).transaction(idx);
 
     // return the transaction, throw exception if not found
     return transaction(t.transactionID());
   */
 
   // new implementation if the above code does not work anymore
   auto acc = d->m_accountList[account];
   MyMoneyTransactionFilter filter;
 
   if (acc.accountGroup() == eMyMoney::Account::Type::Income
       || acc.accountGroup() == eMyMoney::Account::Type::Expense)
     filter.addCategory(account);
   else
     filter.addAccount(account);
 
   const auto list = transactionList(filter);
   if (idx < 0 || idx >= static_cast<int>(list.count()))
-    throw MYMONEYEXCEPTION("Unknown idx for transaction");
+    throw MYMONEYEXCEPTION_CSTRING("Unknown idx for transaction");
 
   return transaction(list[idx].id());
 }
 
 MyMoneyMoney MyMoneyStorageMgr::balance(const QString& id, const QDate& date) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (!d->m_accountList.contains(id))
-    throw MYMONEYEXCEPTION(QString("Unknown account id '%1'").arg(id));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown account id '%1'").arg(id));
 
   // the balance of all transactions for this account has
   // been requested. no need to calculate anything as we
   // have this number with the account object already.
   if (!date.isValid())
     return d->m_accountList[id].balance();
   else
     return d->calculateBalance(id, date);
 }
 
 MyMoneyMoney MyMoneyStorageMgr::totalBalance(const QString& id, const QDate& date) const
 {
   MyMoneyMoney result(balance(id, date));
 
   foreach (const auto sAccount, account(id).accountList())
     result += totalBalance(sAccount, date);
 
   return result;
 }
 
 MyMoneyAccount MyMoneyStorageMgr::liability() const {
   return account(stdAccNames[stdAccLiability]);
 }
 
 MyMoneyAccount MyMoneyStorageMgr::asset() const {
   return account(stdAccNames[stdAccAsset]);
 }
 
 MyMoneyAccount MyMoneyStorageMgr::expense() const {
   return account(stdAccNames[stdAccExpense]);
 }
 
 MyMoneyAccount MyMoneyStorageMgr::income() const {
   return account(stdAccNames[stdAccIncome]);
 }
 
 MyMoneyAccount MyMoneyStorageMgr::equity() const {
   return account(stdAccNames[stdAccEquity]);
 }
 
 void MyMoneyStorageMgr::loadAccounts(const QMap<QString, MyMoneyAccount>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_accountList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyAccount>::const_iterator it_a;
   QString lastId("");
   for (it_a = map.begin(); it_a != map.end(); ++it_a) {
     if (!isStandardAccount((*it_a).id()) && ((*it_a).id() > lastId))
       lastId = (*it_a).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextAccountID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadTransactions(const QMap<QString, MyMoneyTransaction>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_transactionList = map;
 
   // now fill the key map and
   // identify the last used id
   QString lastId("");
   QMap<QString, QString> keys;
   QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
 
   for (it_t = map.constBegin(); it_t != map.constEnd(); ++it_t) {
     keys[(*it_t).id()] = it_t.key();
     if ((*it_t).id() > lastId)
       lastId = (*it_t).id();
   }
   d->m_transactionKeys = keys;
 
   // determine highest used ID so far
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextTransactionID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadInstitutions(const QMap<QString, MyMoneyInstitution>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_institutionList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyInstitution>::const_iterator it_i;
   QString lastId("");
   for (it_i = map.begin(); it_i != map.end(); ++it_i) {
     if ((*it_i).id() > lastId)
       lastId = (*it_i).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextInstitutionID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadPayees(const QMap<QString, MyMoneyPayee>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_payeeList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyPayee>::const_iterator it_p;
   QString lastId("");
   for (it_p = map.begin(); it_p != map.end(); ++it_p) {
     if ((*it_p).id().length() <= PAYEE_ID_SIZE + 1) {
       if ((*it_p).id() > lastId)
         lastId = (*it_p).id();
     } else {
     }
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextPayeeID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadTags(const QMap<QString, MyMoneyTag>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_tagList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyTag>::const_iterator it_ta;
   QString lastId("");
   for (it_ta = map.begin(); it_ta != map.end(); ++it_ta) {
     if ((*it_ta).id().length() <= TAG_ID_SIZE + 1) {
       if ((*it_ta).id() > lastId)
         lastId = (*it_ta).id();
     } else {
     }
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextTagID = lastId.mid(pos).toUInt();
   }
 }
 
 void MyMoneyStorageMgr::loadSecurities(const QMap<QString, MyMoneySecurity>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_securitiesList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneySecurity>::const_iterator it_s;
   QString lastId("");
   for (it_s = map.begin(); it_s != map.end(); ++it_s) {
     if ((*it_s).id() > lastId)
       lastId = (*it_s).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextSecurityID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadCurrencies(const QMap<QString, MyMoneySecurity>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_currencyList = map;
 }
 
 void MyMoneyStorageMgr::loadPrices(const MyMoneyPriceList& list)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_priceList = list;
 }
 
 void MyMoneyStorageMgr::loadOnlineJobs(const QMap< QString, onlineJob >& onlineJobs)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_onlineJobList = onlineJobs;
   QString lastId("");
   const QMap< QString, onlineJob >::const_iterator end = onlineJobs.constEnd();
   for (QMap< QString, onlineJob >::const_iterator iter = onlineJobs.constBegin(); iter != end; ++iter) {
     if ((*iter).id() > lastId)
       lastId = (*iter).id();
   }
 
   const int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextOnlineJobID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::loadCostCenters(const QMap< QString, MyMoneyCostCenter >& costCenters)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_costCenterList = costCenters;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyCostCenter>::const_iterator it_s;
   QString lastId;
   for (it_s = costCenters.constBegin(); it_s != costCenters.constEnd(); ++it_s) {
     if ((*it_s).id() > lastId)
       lastId = (*it_s).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextCostCenterID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::setValue(const QString& key, const QString& val)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyKeyValueContainer::setValue(key, val);
   d->touch();
 }
 
 void MyMoneyStorageMgr::deletePair(const QString& key)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyKeyValueContainer::deletePair(key);
   d->touch();
 }
 
 
 void MyMoneyStorageMgr::setPairs(const QMap<QString, QString>& list)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyKeyValueContainer::setPairs(list);
   d->touch();
 }
 
 void MyMoneyStorageMgr::addSchedule(MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageMgr);
   // first perform all the checks
   if (!sched.id().isEmpty())
-    throw MYMONEYEXCEPTION("schedule already contains an id");
+    throw MYMONEYEXCEPTION_CSTRING("schedule already contains an id");
 
   // The following will throw an exception when it fails
   sched.validate(false);
 
   // it is expected in mymoneygenericstorage-test
   const auto splits = sched.transaction().splits();
   for (const auto& split : splits)
     if (!d->m_accountList.contains(split.accountId()))
-      throw MYMONEYEXCEPTION("bad account id");
+      throw MYMONEYEXCEPTION_CSTRING("bad account id");
 
   MyMoneySchedule newSched(d->nextScheduleID(), sched);
   d->m_scheduleList.insert(newSched.id(), newSched);
   sched = newSched;
 }
 
 void MyMoneyStorageMgr::modifySchedule(const MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySchedule>::ConstIterator it;
 
   it = d->m_scheduleList.find(sched.id());
-  if (it == d->m_scheduleList.end()) {
-    QString msg = "Unknown schedule '" + sched.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_scheduleList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown schedule '%1'").arg(sched.id()));
 
   d->m_scheduleList.modify(sched.id(), sched);
 }
 
 void MyMoneyStorageMgr::removeSchedule(const MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySchedule>::ConstIterator it;
 
   it = d->m_scheduleList.find(sched.id());
-  if (it == d->m_scheduleList.end()) {
-    QString msg = "Unknown schedule '" + sched.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_scheduleList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown schedule '%1'").arg(sched.id()));
 
   // FIXME: check referential integrity for loan accounts
   d->m_scheduleList.remove(sched.id());
 }
 
 MyMoneySchedule MyMoneyStorageMgr::schedule(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneySchedule>::ConstIterator pos;
 
   // locate the schedule and if present, return it's data
   pos = d->m_scheduleList.find(id);
   if (pos != d->m_scheduleList.end())
     return (*pos);
 
   // throw an exception, if it does not exist
-  QString msg = "Unknown schedule id '" + id + '\'';
-  throw MYMONEYEXCEPTION(msg);
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown schedule '%1'").arg(id));
 }
 
 QList<MyMoneySchedule> MyMoneyStorageMgr::scheduleList(const QString& accountId,
   eMyMoney::Schedule::Type type,
   eMyMoney::Schedule::Occurrence occurrence,
   eMyMoney::Schedule::PaymentType paymentType,
   const QDate& startDate,
   const QDate& endDate,
   bool overdue) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneySchedule>::ConstIterator pos;
   QList<MyMoneySchedule> list;
 
   // qDebug("scheduleList()");
 
   for (pos = d->m_scheduleList.begin(); pos != d->m_scheduleList.end(); ++pos) {
     // qDebug("  '%s'", qPrintable((*pos).id()));
 
     if (type != eMyMoney::Schedule::Type::Any) {
       if (type != (*pos).type()) {
         continue;
       }
     }
 
     if (occurrence != eMyMoney::Schedule::Occurrence::Any) {
       if (occurrence != (*pos).occurrence()) {
         continue;
       }
     }
 
     if (paymentType != eMyMoney::Schedule::PaymentType::Any) {
       if (paymentType != (*pos).paymentType()) {
         continue;
       }
     }
 
     if (!accountId.isEmpty()) {
       MyMoneyTransaction t = (*pos).transaction();
       QList<MyMoneySplit>::ConstIterator it;
       QList<MyMoneySplit> splits;
       splits = t.splits();
       for (it = splits.constBegin(); it != splits.constEnd(); ++it) {
         if ((*it).accountId() == accountId)
           break;
       }
       if (it == splits.constEnd()) {
         continue;
       }
     }
 
     if (startDate.isValid() && endDate.isValid()) {
       if ((*pos).paymentDates(startDate, endDate).count() == 0) {
         continue;
       }
     }
 
     if (startDate.isValid() && !endDate.isValid()) {
       if (!(*pos).nextPayment(startDate.addDays(-1)).isValid()) {
         continue;
       }
     }
 
     if (!startDate.isValid() && endDate.isValid()) {
       if ((*pos).startDate() > endDate) {
         continue;
       }
     }
 
     if (overdue) {
       if (!(*pos).isOverdue())
         continue;
     }
 
     // qDebug("Adding '%s'", (*pos).name().toLatin1());
     list << *pos;
   }
   return list;
 }
 
 void MyMoneyStorageMgr::loadSchedules(const QMap<QString, MyMoneySchedule>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_scheduleList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneySchedule>::const_iterator it_s;
   QString lastId("");
   for (it_s = map.begin(); it_s != map.end(); ++it_s) {
     if ((*it_s).id() > lastId)
       lastId = (*it_s).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextScheduleID = lastId.mid(pos).toInt();
   }
 }
 
 QList<MyMoneySchedule> MyMoneyStorageMgr::scheduleListEx(int scheduleTypes,
     int scheduleOcurrences,
     int schedulePaymentTypes,
     QDate date,
     const QStringList& accounts) const
 {
   Q_D(const MyMoneyStorageMgr);
 //  qDebug("scheduleListEx");
 
   QMap<QString, MyMoneySchedule>::ConstIterator pos;
   QList<MyMoneySchedule> list;
 
   if (!date.isValid())
     return list;
 
   for (pos = d->m_scheduleList.begin(); pos != d->m_scheduleList.end(); ++pos) {
     if (scheduleTypes && !(scheduleTypes & (int)(*pos).type()))
       continue;
 
     if (scheduleOcurrences && !(scheduleOcurrences & (int)(*pos).occurrence()))
       continue;
 
     if (schedulePaymentTypes && !(schedulePaymentTypes & (int)(*pos).paymentType()))
       continue;
 
     if ((*pos).paymentDates(date, date).count() == 0)
       continue;
 
     if ((*pos).isFinished())
       continue;
 
     if ((*pos).hasRecordedPayment(date))
       continue;
 
     if (accounts.count() > 0) {
       if (accounts.contains((*pos).account().id()))
         continue;
     }
 
 //    qDebug("\tAdding '%s'", (*pos).name().toLatin1());
     list << *pos;
   }
 
   return list;
 }
 
 void MyMoneyStorageMgr::addSecurity(MyMoneySecurity& security)
 {
   Q_D(MyMoneyStorageMgr);
   // create the account
   MyMoneySecurity newSecurity(d->nextSecurityID(), security);
 
   d->m_securitiesList.insert(newSecurity.id(), newSecurity);
 
   security = newSecurity;
 }
 
 void MyMoneyStorageMgr::modifySecurity(const MyMoneySecurity& security)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   it = d->m_securitiesList.find(security.id());
-  if (it == d->m_securitiesList.end()) {
-    QString msg = "Unknown security  '";
-    msg += security.id() + "' during modifySecurity()";
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_securitiesList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown security '%1'").arg(security.id()));
 
   d->m_securitiesList.modify(security.id(), security);
 }
 
 void MyMoneyStorageMgr::removeSecurity(const MyMoneySecurity& security)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   // FIXME: check referential integrity
 
   it = d->m_securitiesList.find(security.id());
-  if (it == d->m_securitiesList.end()) {
-    QString msg = "Unknown security  '";
-    msg += security.id() + "' during removeSecurity()";
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_securitiesList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown security '%1'").arg(security.id()));
 
   d->m_securitiesList.remove(security.id());
 }
 
 MyMoneySecurity MyMoneyStorageMgr::security(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it = d->m_securitiesList.find(id);
   if (it != d->m_securitiesList.end()) {
     return it.value();
   }
 
   // FIXME: in places where a currency is needed, a currency method should be called even if the currency is in fact a security
   it = d->m_currencyList.find(id);
   if (it != d->m_currencyList.end()) {
     return it.value();
   }
 
   return MyMoneySecurity();
 }
 
 QList<MyMoneySecurity> MyMoneyStorageMgr::securityList() const
 {
   Q_D(const MyMoneyStorageMgr);
   //qDebug("securityList: Security list size is %d, this=%8p", m_equitiesList.size(), (void*)this);
   return d->m_securitiesList.values();
 }
 
 void MyMoneyStorageMgr::addCurrency(const MyMoneySecurity& currency)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   it = d->m_currencyList.find(currency.id());
-  if (it != d->m_currencyList.end()) {
-    throw MYMONEYEXCEPTION(i18n("Cannot add currency with existing id %1", currency.id()));
-  }
+  if (it != d->m_currencyList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot add currency with existing id %1").arg(currency.id()));
 
   d->m_currencyList.insert(currency.id(), currency);
 }
 
 void MyMoneyStorageMgr::modifyCurrency(const MyMoneySecurity& currency)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   it = d->m_currencyList.find(currency.id());
-  if (it == d->m_currencyList.end()) {
-    throw MYMONEYEXCEPTION(i18n("Cannot modify currency with unknown id %1", currency.id()));
-  }
+  if (it == d->m_currencyList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot modify currency with unknown id %1").arg(currency.id()));
 
   d->m_currencyList.modify(currency.id(), currency);
 }
 
 void MyMoneyStorageMgr::removeCurrency(const MyMoneySecurity& currency)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   // FIXME: check referential integrity
 
   it = d->m_currencyList.find(currency.id());
-  if (it == d->m_currencyList.end()) {
-    throw MYMONEYEXCEPTION(i18n("Cannot remove currency with unknown id %1", currency.id()));
-  }
+  if (it == d->m_currencyList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot remove currency with unknown id %1").arg(currency.id()));
 
   d->m_currencyList.remove(currency.id());
 }
 
 MyMoneySecurity MyMoneyStorageMgr::currency(const QString& id) const
 {
   Q_D(const MyMoneyStorageMgr);
   if (id.isEmpty()) {
 
   }
   QMap<QString, MyMoneySecurity>::ConstIterator it;
 
   it = d->m_currencyList.find(id);
-  if (it == d->m_currencyList.end()) {
-    throw MYMONEYEXCEPTION(i18n("Cannot retrieve currency with unknown id '%1'", id));
-  }
+  if (it == d->m_currencyList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot retrieve currency with unknown id '%1'").arg(id));
 
   return *it;
 }
 
 QList<MyMoneySecurity> MyMoneyStorageMgr::currencyList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_currencyList.values();
 }
 
 QList<MyMoneyReport> MyMoneyStorageMgr::reportList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_reportList.values();
 }
 
 void MyMoneyStorageMgr::addReport(MyMoneyReport& report)
 {
   Q_D(MyMoneyStorageMgr);
   if (!report.id().isEmpty())
-    throw MYMONEYEXCEPTION("report already contains an id");
+    throw MYMONEYEXCEPTION(QString::fromLatin1("report already contains an id"));
 
   MyMoneyReport newReport(d->nextReportID(), report);
   d->m_reportList.insert(newReport.id(), newReport);
   report = newReport;
 }
 
 void MyMoneyStorageMgr::loadReports(const QMap<QString, MyMoneyReport>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_reportList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyReport>::const_iterator it_r;
   QString lastId("");
   for (it_r = map.begin(); it_r != map.end(); ++it_r) {
     if ((*it_r).id() > lastId)
       lastId = (*it_r).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextReportID = lastId.mid(pos).toInt();
   }
 }
 
 void MyMoneyStorageMgr::modifyReport(const MyMoneyReport& report)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyReport>::ConstIterator it;
 
   it = d->m_reportList.find(report.id());
-  if (it == d->m_reportList.end()) {
-    QString msg = "Unknown report '" + report.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_reportList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown report '%1'").arg(report.id()));
+
   d->m_reportList.modify(report.id(), report);
 }
 
 uint MyMoneyStorageMgr::countReports() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_reportList.count();
 }
 
 MyMoneyReport MyMoneyStorageMgr::report(const QString& _id) const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_reportList[_id];
 }
 
 void MyMoneyStorageMgr::removeReport(const MyMoneyReport& report)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyReport>::ConstIterator it;
 
   it = d->m_reportList.find(report.id());
-  if (it == d->m_reportList.end()) {
-    QString msg = "Unknown report '" + report.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_reportList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown report '%1'").arg(report.id()));
 
   d->m_reportList.remove(report.id());
 }
 
 QList<MyMoneyBudget> MyMoneyStorageMgr::budgetList() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_budgetList.values();
 }
 
 
 void MyMoneyStorageMgr::addBudget(MyMoneyBudget& budget)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneyBudget newBudget(d->nextBudgetID(), budget);
   d->m_budgetList.insert(newBudget.id(), newBudget);
   budget = newBudget;
 }
 
 void MyMoneyStorageMgr::loadBudgets(const QMap<QString, MyMoneyBudget>& map)
 {
   Q_D(MyMoneyStorageMgr);
   d->m_budgetList = map;
 
   // scan the map to identify the last used id
   QMap<QString, MyMoneyBudget>::const_iterator it_b;
   QString lastId("");
   for (it_b = map.begin(); it_b != map.end(); ++it_b) {
     if ((*it_b).id() > lastId)
       lastId = (*it_b).id();
   }
 
   int pos = lastId.indexOf(QRegExp("\\d+"), 0);
   if (pos != -1) {
     d->m_nextBudgetID = lastId.mid(pos).toInt();
   }
 }
 
 MyMoneyBudget MyMoneyStorageMgr::budgetByName(const QString& budget) const
 {
   Q_D(const MyMoneyStorageMgr);
   QMap<QString, MyMoneyBudget>::ConstIterator it_p;
 
   for (it_p = d->m_budgetList.begin(); it_p != d->m_budgetList.end(); ++it_p) {
     if ((*it_p).name() == budget) {
       return *it_p;
     }
   }
 
-  throw MYMONEYEXCEPTION("Unknown budget '" + budget + '\'');
+  throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown budget '%1'").arg(budget));
 }
 
 void MyMoneyStorageMgr::modifyBudget(const MyMoneyBudget& budget)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyBudget>::ConstIterator it;
 
   it = d->m_budgetList.find(budget.id());
-  if (it == d->m_budgetList.end()) {
-    QString msg = "Unknown budget '" + budget.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_budgetList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown budget '%1'").arg(budget.id()));
+
   d->m_budgetList.modify(budget.id(), budget);
 }
 
 uint MyMoneyStorageMgr::countBudgets() const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_budgetList.count();
 }
 
 MyMoneyBudget MyMoneyStorageMgr::budget(const QString& _id) const
 {
   Q_D(const MyMoneyStorageMgr);
   return d->m_budgetList[_id];
 }
 
 void MyMoneyStorageMgr::removeBudget(const MyMoneyBudget& budget)
 {
   Q_D(MyMoneyStorageMgr);
   QMap<QString, MyMoneyBudget>::ConstIterator it;
 
   it = d->m_budgetList.find(budget.id());
-  if (it == d->m_budgetList.end()) {
-    QString msg = "Unknown budget '" + budget.id() + '\'';
-    throw MYMONEYEXCEPTION(msg);
-  }
+  if (it == d->m_budgetList.end())
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown budget '%1'").arg(budget.id()));
 
   d->m_budgetList.remove(budget.id());
 }
 
 void MyMoneyStorageMgr::addPrice(const MyMoneyPrice& price)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneySecurityPair pricePair(price.from(), price.to());
   QMap<MyMoneySecurityPair, MyMoneyPriceEntries>::ConstIterator it_m;
   it_m = d->m_priceList.find(pricePair);
 
   MyMoneyPriceEntries entries;
   if (it_m != d->m_priceList.end()) {
     entries = (*it_m);
   }
   // entries contains the current entries for this security pair
   // in case it_m points to m_priceList.end() we need to create a
   // new entry in the priceList, otherwise we need to modify
   // an existing one.
 
   MyMoneyPriceEntries::ConstIterator it;
   it = entries.constFind(price.date());
   if (it != entries.constEnd()) {
     if ((*it).rate(QString()) == price.rate(QString())
         && (*it).source() == price.source())
       // in case the information did not change, we don't do anything
       return;
   }
 
   // store new value in local copy
   entries[price.date()] = price;
 
   if (it_m != d->m_priceList.end()) {
     d->m_priceList.modify(pricePair, entries);
   } else {
     d->m_priceList.insert(pricePair, entries);
   }
 }
 
 void MyMoneyStorageMgr::removePrice(const MyMoneyPrice& price)
 {
   Q_D(MyMoneyStorageMgr);
   MyMoneySecurityPair pricePair(price.from(), price.to());
   QMap<MyMoneySecurityPair, MyMoneyPriceEntries>::ConstIterator it_m;
   it_m = d->m_priceList.find(pricePair);
 
   MyMoneyPriceEntries entries;
   if (it_m != d->m_priceList.end()) {
     entries = (*it_m);
   }
 
   // store new value in local copy
   entries.remove(price.date());
 
   if (entries.count() != 0) {
     d->m_priceList.modify(pricePair, entries);
   } else {
     d->m_priceList.remove(pricePair);
   }
 }
 
 MyMoneyPriceList MyMoneyStorageMgr::priceList() const
 {
   Q_D(const MyMoneyStorageMgr);
   MyMoneyPriceList list;
   d->m_priceList.map(list);
   return list;
 }
 
 MyMoneyPrice MyMoneyStorageMgr::price(const QString& fromId, const QString& toId, const QDate& _date, bool exactDate) const
 {
   Q_D(const MyMoneyStorageMgr);
   // if the caller selected an exact entry, we can search for it using the date as the key
   QMap<MyMoneySecurityPair, MyMoneyPriceEntries>::const_iterator itm = d->m_priceList.find(qMakePair(fromId, toId));
   if (itm != d->m_priceList.end()) {
     // if no valid date is passed, we use today's date.
     const QDate &date = _date.isValid() ? _date : QDate::currentDate();
     const MyMoneyPriceEntries &entries = itm.value();
     // regardless of the exactDate flag if the exact date is present return it's value since it's the correct value
     MyMoneyPriceEntries::const_iterator it = entries.find(date);
     if (it != entries.end())
       return it.value();
 
     // the exact date was not found look for the latest date before the requested date if the flag allows it
     if (!exactDate && !entries.empty()) {
       // if there are entries get the lower bound of the date
       it = entries.lowerBound(date);
       // since lower bound returns the first item with a larger key (we already know that key is not present)
       // if it's not the first item then we need to return the previous item (the map is not empty so there is one)
       if (it != entries.begin()) {
         return (--it).value();
       }
     }
   }
   return MyMoneyPrice();
 }
 
 void MyMoneyStorageMgr::rebuildAccountBalances()
 {
   Q_D(MyMoneyStorageMgr);
   // reset the balance of all accounts to 0
   QMap<QString, MyMoneyAccount> map;
   d->m_accountList.map(map);
 
   QMap<QString, MyMoneyAccount>::iterator it_a;
   for (it_a = map.begin(); it_a != map.end(); ++it_a) {
     (*it_a).setBalance(MyMoneyMoney());
   }
 
   // now scan over all transactions and all splits and setup the balances
   foreach (const auto transaction, d->m_transactionList) {
     foreach (const auto split, transaction.splits()) {
       if (!split.shares().isZero()) {
         const QString& id = split.accountId();
         // locate the account and if present, update data
         if (map.find(id) != map.end()) {
           map[id].adjustBalance(split);
         }
       }
     }
   }
 
   d->m_accountList = map;
 }
 
 bool MyMoneyStorageMgr::isReferenced(const MyMoneyObject& obj, const QBitArray& skipCheck) const
 {
   Q_D(const MyMoneyStorageMgr);
   Q_ASSERT(skipCheck.count() == (int)Reference::Count);
 
   // We delete all references in reports when an object
   // is deleted, so we don't need to check here. See
   // MyMoneyStorageMgr::removeReferences(). In case
   // you miss the report checks in the following lines ;)
 
   const auto& id = obj.id();
 
   // FIXME optimize the list of objects we have to checks
   //       with a bit of knowledge of the internal structure, we
   //       could optimize the number of objects we check for references
 
   // Scan all engine objects for a reference
   if (!skipCheck.testBit((int)Reference::Transaction))
     foreach (const auto it, d->m_transactionList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Account))
     foreach (const auto it, d->m_accountList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Institution))
     foreach (const auto it, d->m_institutionList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Payee))
     foreach (const auto it, d->m_payeeList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Tag))
     foreach (const auto it, d->m_tagList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Budget))
     foreach (const auto it, d->m_budgetList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Schedule))
     foreach (const auto it, d->m_scheduleList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Security))
     foreach (const auto it, d->m_securitiesList)
       if (it.hasReferenceTo(id))
         return true;
 
   if (!skipCheck.testBit((int)Reference::Currency))
     foreach (const auto it, d->m_currencyList)
       if (it.hasReferenceTo(id))
         return true;
 
   // within the pricelist we don't have to scan each entry. Checking the QPair
   // members of the MyMoneySecurityPair is enough as they are identical to the
   // two security ids
   if (!skipCheck.testBit((int)Reference::Price)) {
     for (auto it_pr = d->m_priceList.begin(); it_pr != d->m_priceList.end(); ++it_pr) {
       if ((it_pr.key().first == id) || (it_pr.key().second == id))
         return true;
     }
   }
 
   return false;
 }
 
 void MyMoneyStorageMgr::startTransaction()
 {
   Q_D(MyMoneyStorageMgr);
   d->m_payeeList.startTransaction(&d->m_nextPayeeID);
   d->m_tagList.startTransaction(&d->m_nextTagID);
   d->m_institutionList.startTransaction(&d->m_nextInstitutionID);
   d->m_accountList.startTransaction(&d->m_nextPayeeID);
   d->m_transactionList.startTransaction(&d->m_nextTransactionID);
   d->m_transactionKeys.startTransaction();
   d->m_scheduleList.startTransaction(&d->m_nextScheduleID);
   d->m_securitiesList.startTransaction(&d->m_nextSecurityID);
   d->m_currencyList.startTransaction();
   d->m_reportList.startTransaction(&d->m_nextReportID);
   d->m_budgetList.startTransaction(&d->m_nextBudgetID);
   d->m_priceList.startTransaction();
   d->m_onlineJobList.startTransaction(&d->m_nextOnlineJobID);
 }
 
 bool MyMoneyStorageMgr::commitTransaction()
 {
   Q_D(MyMoneyStorageMgr);
   bool rc = false;
   rc |= d->m_payeeList.commitTransaction();
   rc |= d->m_tagList.commitTransaction();
   rc |= d->m_institutionList.commitTransaction();
   rc |= d->m_accountList.commitTransaction();
   rc |= d->m_transactionList.commitTransaction();
   rc |= d->m_transactionKeys.commitTransaction();
   rc |= d->m_scheduleList.commitTransaction();
   rc |= d->m_securitiesList.commitTransaction();
   rc |= d->m_currencyList.commitTransaction();
   rc |= d->m_reportList.commitTransaction();
   rc |= d->m_budgetList.commitTransaction();
   rc |= d->m_priceList.commitTransaction();
   rc |= d->m_onlineJobList.commitTransaction();
 
   // if there was a change, touch the whole storage object
   if (rc)
     d->touch();
 
   return rc;
 }
 
 void MyMoneyStorageMgr::rollbackTransaction()
 {
   Q_D(MyMoneyStorageMgr);
   d->m_payeeList.rollbackTransaction();
   d->m_tagList.rollbackTransaction();
   d->m_institutionList.rollbackTransaction();
   d->m_accountList.rollbackTransaction();
   d->m_transactionList.rollbackTransaction();
   d->m_transactionKeys.rollbackTransaction();
   d->m_scheduleList.rollbackTransaction();
   d->m_securitiesList.rollbackTransaction();
   d->m_currencyList.rollbackTransaction();
   d->m_reportList.rollbackTransaction();
   d->m_budgetList.rollbackTransaction();
   d->m_priceList.rollbackTransaction();
   d->m_onlineJobList.rollbackTransaction();
 }
diff --git a/kmymoney/mymoney/storage/mymoneystoragemgr_p.h b/kmymoney/mymoney/storage/mymoneystoragemgr_p.h
index 56c83b651..93ac531ef 100644
--- a/kmymoney/mymoney/storage/mymoneystoragemgr_p.h
+++ b/kmymoney/mymoney/storage/mymoneystoragemgr_p.h
@@ -1,608 +1,608 @@
 /***************************************************************************
                           mymoneystoragemgr.cpp
                              -------------------
     begin                : Sun May 5 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <mte@users.sourceforge.net>
                                2002 Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYSTORAGEMGR_P_H
 #define MYMONEYSTORAGEMGR_P_H
 
 #include "mymoneystoragemgr.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QBitArray>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "storageenums.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneytag.h"
 #include "mymoneypayee.h"
 #include "mymoneybudget.h"
 #include "mymoneyschedule.h"
 #include "mymoneyreport.h"
 #include "mymoneymoney.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneycostcenter.h"
 #include "mymoneymap.h"
 #include "onlinejob.h"
 #include "mymoneyenums.h"
 #include "mymoneystoragenames.h"
 
 using namespace MyMoneyStandardAccounts;
 using namespace eStorage;
 
 const int INSTITUTION_ID_SIZE = 6;
 const int ACCOUNT_ID_SIZE = 6;
 const int TRANSACTION_ID_SIZE = 18;
 const int PAYEE_ID_SIZE = 6;
 const int TAG_ID_SIZE = 6;
 const int SCHEDULE_ID_SIZE = 6;
 const int SECURITY_ID_SIZE = 6;
 const int REPORT_ID_SIZE = 6;
 const int BUDGET_ID_SIZE = 6;
 const int ONLINE_JOB_ID_SIZE = 6;
 const int COSTCENTER_ID_SIZE = 6;
 
 class MyMoneyStorageMgrPrivate
 {
   Q_DISABLE_COPY(MyMoneyStorageMgrPrivate)
   Q_DECLARE_PUBLIC(MyMoneyStorageMgr)
 
 public:
   explicit MyMoneyStorageMgrPrivate(MyMoneyStorageMgr* qq) :
     q_ptr(qq),
     m_nextInstitutionID(0),
     m_nextAccountID(0),
     m_nextTransactionID(0),
     m_nextPayeeID(0),
     m_nextTagID(0),
     m_nextScheduleID(0),
     m_nextSecurityID(0),
     m_nextReportID(0),
     m_nextBudgetID(0),
     m_nextOnlineJobID(0),
     m_nextCostCenterID(0),
     m_dirty(false),
     m_creationDate(QDate::currentDate()),
     // initialize for file fixes (see kmymoneyview.cpp)
     m_currentFixVersion(4),
     m_fileFixVersion(0), // default value if no fix-version in file
     m_transactionListFull(false)
   {
   }
 
   ~MyMoneyStorageMgrPrivate()
   {
   }
 
   void init()
   {
     // setup standard accounts
     MyMoneyAccount acc_l;
     acc_l.setAccountType(eMyMoney::Account::Type::Liability);
     acc_l.setName("Liability");
     MyMoneyAccount liability(stdAccNames[stdAccLiability], acc_l);
 
     MyMoneyAccount acc_a;
     acc_a.setAccountType(eMyMoney::Account::Type::Asset);
     acc_a.setName("Asset");
     MyMoneyAccount asset(stdAccNames[stdAccAsset], acc_a);
 
     MyMoneyAccount acc_e;
     acc_e.setAccountType(eMyMoney::Account::Type::Expense);
     acc_e.setName("Expense");
     MyMoneyAccount expense(stdAccNames[stdAccExpense], acc_e);
 
     MyMoneyAccount acc_i;
     acc_i.setAccountType(eMyMoney::Account::Type::Income);
     acc_i.setName("Income");
     MyMoneyAccount income(stdAccNames[stdAccIncome], acc_i);
 
     MyMoneyAccount acc_q;
     acc_q.setAccountType(eMyMoney::Account::Type::Equity);
     acc_q.setName("Equity");
     MyMoneyAccount equity(stdAccNames[stdAccEquity], acc_q);
 
     QMap<QString, MyMoneyAccount> map;
     map[stdAccNames[stdAccAsset]] = asset;
     map[stdAccNames[stdAccLiability]] = liability;
     map[stdAccNames[stdAccIncome]] = income;
     map[stdAccNames[stdAccExpense]] = expense;
     map[stdAccNames[stdAccEquity]] = equity;
 
     // load account list with initial accounts
     m_accountList = map;
   }
 
   /**
     * This method is used to set the dirty flag and update the
     * date of the last modification.
     */
   void touch()
   {
     m_dirty = true;
     m_lastModificationDate = QDate::currentDate();
   }
 
   /**
     * Adjust the balance for account @a acc by the amount of shares in split @a split.
     * The amount is added if @a reverse is @c false, subtracted in case it is @c true.
     */
   void adjustBalance(MyMoneyAccount& acc, const MyMoneySplit& split, bool reverse)
   {
     // in case of an investment we can't just add or subtract the
     // amount of the split since we don't know about stock splits.
     // so in the case of those stocks, we simply recalculate the balance from scratch
     acc.isInvest() ? acc.setBalance(calculateBalance(acc.id(), QDate())) :
                      acc.adjustBalance(split, reverse);
   }
 
   /**
     * This method re-parents an existing account
     *
     * An exception will be thrown upon error conditions.
     *
     * @param account MyMoneyAccount reference to account to be re-parented
     * @param parent  MyMoneyAccount reference to new parent account
     * @param sendNotification if true, notifications with the ids
     *                of all modified objects are send
     */
   void reparentAccount(MyMoneyAccount &account, MyMoneyAccount& parent, bool /* sendNotification */)
   {
     Q_Q(MyMoneyStorageMgr);
     QMap<QString, MyMoneyAccount>::ConstIterator oldParent;
     QMap<QString, MyMoneyAccount>::ConstIterator newParent;
     QMap<QString, MyMoneyAccount>::ConstIterator childAccount;
 
     // verify that accounts exist. If one does not,
     // an exception is thrown
     q->account(account.id());
     q->account(parent.id());
     if (!account.parentAccountId().isEmpty()) {
       q->account(account.parentAccountId());
       oldParent = m_accountList.find(account.parentAccountId());
     }
 
     if (account.accountType() == eMyMoney::Account::Type::Stock && parent.accountType() != eMyMoney::Account::Type::Investment)
-      throw MYMONEYEXCEPTION("Cannot move a stock acocunt into a non-investment account");
+      throw MYMONEYEXCEPTION_CSTRING("Cannot move a stock acocunt into a non-investment account");
 
     newParent = m_accountList.find(parent.id());
     childAccount = m_accountList.find(account.id());
 
     MyMoneyAccount acc;
     if (!account.parentAccountId().isEmpty()) {
       acc = (*oldParent);
       acc.removeAccountId(account.id());
       m_accountList.modify(acc.id(), acc);
     }
 
     parent = (*newParent);
     parent.addAccountId(account.id());
     m_accountList.modify(parent.id(), parent);
 
     account = (*childAccount);
     account.setParentAccountId(parent.id());
     m_accountList.modify(account.id(), account);
 
   #if 0
     // make sure the type is the same as the new parent. This does not work for stock and investment
     if (account.accountType() != eMyMoney::Account::Type::Stock && account.accountType() != eMyMoney::Account::Type::Investment)
       (*childAccount).setAccountType((*newParent).accountType());
   #endif
   }
 
   /**
     * This method is used to calculate the actual balance of an account
     * without it's sub-ordinate accounts. If a @p date is presented,
     * the balance at the beginning of this date (not including any
     * transaction on this date) is returned. Otherwise all recorded
     * transactions are included in the balance.
     *
     * @param id id of the account in question
     * @param date return balance for specific date
     * @return balance of the account as MyMoneyMoney object
     */
   MyMoneyMoney calculateBalance(const QString& id, const QDate& date) const
   {
     Q_Q(const MyMoneyStorageMgr);
     MyMoneyMoney balance;
 
     MyMoneyTransactionFilter filter;
     filter.setDateFilter(QDate(), date);
     filter.setReportAllSplits(false);
 
     const auto list = q->transactionList(filter);
     for (const auto& transaction : list) {
       const auto splits = transaction.splits();
       for (const auto& split : splits) {
         if (split.accountId().compare(id) != 0)
           continue;
         else if (split.action().compare(MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares)) == 0)
           balance *= split.shares();
         else
           balance += split.shares();
       }
     }
 
     return balance;
   }
 
   void removeReferences(const QString& id)
   {
     QMap<QString, MyMoneyReport>::const_iterator it_r;
     QMap<QString, MyMoneyBudget>::const_iterator it_b;
 
     // remove from reports
     for (it_r = m_reportList.begin(); it_r != m_reportList.end(); ++it_r) {
       MyMoneyReport r = *it_r;
       r.removeReference(id);
       m_reportList.modify(r.id(), r);
     }
 
     // remove from budgets
     for (it_b = m_budgetList.begin(); it_b != m_budgetList.end(); ++it_b) {
       MyMoneyBudget b = *it_b;
       b.removeReference(id);
       m_budgetList.modify(b.id(), b);
     }
   }
 
   /**
     * The member variable m_nextAccountID keeps the number that will be
     * assigned to the next institution created. It is maintained by
     * nextAccountID().
     */
   QString nextAccountID()
   {
     QString id;
     id.setNum(++m_nextAccountID);
     id = 'A' + id.rightJustified(ACCOUNT_ID_SIZE, '0');
     return id;
   }
 
   /**
      * The member variable m_nextTransactionID keeps the number that will be
      * assigned to the next transaction created. It is maintained by
      * nextTransactionID().
      */
   QString nextTransactionID()
   {
     QString id;
     id.setNum(++m_nextTransactionID);
     id = 'T' + id.rightJustified(TRANSACTION_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextPayeeID keeps the number that will be
     * assigned to the next payee created. It is maintained by
     * nextPayeeID()
     */
   QString nextPayeeID()
   {
     QString id;
     id.setNum(++m_nextPayeeID);
     id = 'P' + id.rightJustified(PAYEE_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextTagID keeps the number that will be
     * assigned to the next tag created. It is maintained by
     * nextTagID()
     */
   QString nextTagID()
   {
     QString id;
     id.setNum(++m_nextTagID);
     id = 'G' + id.rightJustified(TAG_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextInstitutionID keeps the number that will be
     * assigned to the next institution created. It is maintained by
     * nextInstitutionID().
     */
   QString nextInstitutionID()
   {
     QString id;
     id.setNum(++m_nextInstitutionID);
     id = 'I' + id.rightJustified(INSTITUTION_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextScheduleID keeps the number that will be
     * assigned to the next schedule created. It is maintained by
     * nextScheduleID()
     */
   QString nextScheduleID()
   {
     QString id;
     id.setNum(++m_nextScheduleID);
     id = "SCH" + id.rightJustified(SCHEDULE_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextSecurityID keeps the number that will be
     * assigned to the next security object created.  It is maintained by
     * nextSecurityID()
     */
   QString nextSecurityID()
   {
     QString id;
     id.setNum(++m_nextSecurityID);
     id = 'E' + id.rightJustified(SECURITY_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextReportID keeps the number that will be
     * assigned to the next report object created.  It is maintained by
     * nextReportID()
     */
   QString nextReportID()
   {
     QString id;
     id.setNum(++m_nextReportID);
     id = 'R' + id.rightJustified(REPORT_ID_SIZE, '0');
     return id;
   }
 
   /**
     * The member variable m_nextBudgetID keeps the number that will be
     * assigned to the next budget object created.  It is maintained by
     * nextBudgetID()
     */
   QString nextBudgetID()
   {
     QString id;
     id.setNum(++m_nextBudgetID);
     id = 'B' + id.rightJustified(BUDGET_ID_SIZE, '0');
     return id;
   }
 
   /**
     * This member variable keeps the number that will be assigned to the
     * next onlineJob object created. It is maintained by nextOnlineJobID()
     */
   QString nextOnlineJobID()
   {
     QString id;
     id.setNum(++m_nextOnlineJobID);
     id = 'O' + id.rightJustified(ONLINE_JOB_ID_SIZE, '0');
     return id;
   }
 
   /**
     * This member variable keeps the number that will be assigned to the
     * next cost center object created. It is maintained by nextCostCenterID()
     */
   QString nextCostCenterID()
   {
     QString id;
     id.setNum(++m_nextCostCenterID);
     id = 'C' + id.rightJustified(COSTCENTER_ID_SIZE, '0');
     return id;
   }
 
   MyMoneyStorageMgr *q_ptr;
 
   /**
     * This member variable keeps the User information.
     * @see setUser()
     */
   MyMoneyPayee m_user;
 
   /**
     * The member variable m_nextInstitutionID keeps the number that will be
     * assigned to the next institution created. It is maintained by
     * nextInstitutionID().
     */
   ulong m_nextInstitutionID;
 
   /**
     * The member variable m_nextAccountID keeps the number that will be
     * assigned to the next institution created. It is maintained by
     * nextAccountID().
     */
   ulong m_nextAccountID;
 
   /**
     * The member variable m_nextTransactionID keeps the number that will be
     * assigned to the next transaction created. It is maintained by
     * nextTransactionID().
     */
   ulong m_nextTransactionID;
 
   /**
     * The member variable m_nextPayeeID keeps the number that will be
     * assigned to the next payee created. It is maintained by
     * nextPayeeID()
     */
   ulong m_nextPayeeID;
 
   /**
     * The member variable m_nextTagID keeps the number that will be
     * assigned to the next tag created. It is maintained by
     * nextTagID()
     */
   ulong m_nextTagID;
 
   /**
     * The member variable m_nextScheduleID keeps the number that will be
     * assigned to the next schedule created. It is maintained by
     * nextScheduleID()
     */
   ulong m_nextScheduleID;
 
   /**
     * The member variable m_nextSecurityID keeps the number that will be
     * assigned to the next security object created.  It is maintained by
     * nextSecurityID()
     */
   ulong m_nextSecurityID;
 
   ulong m_nextReportID;
 
   /**
     * The member variable m_nextBudgetID keeps the number that will be
     * assigned to the next budget object created.  It is maintained by
     * nextBudgetID()
     */
   ulong m_nextBudgetID;
 
   /**
     * This member variable keeps the number that will be assigned to the
     * next onlineJob object created. It is maintained by nextOnlineJobID()
     */
   ulong m_nextOnlineJobID;
 
   /**
     * This member variable keeps the number that will be assigned to the
     * next cost center object created. It is maintained by nextCostCenterID()
     */
   ulong m_nextCostCenterID;
 
   /**
     * The member variable m_institutionList is the container for the
     * institutions known within this file.
     */
   MyMoneyMap<QString, MyMoneyInstitution> m_institutionList;
 
   /**
     * The member variable m_accountList is the container for the accounts
     * known within this file.
     */
   MyMoneyMap<QString, MyMoneyAccount> m_accountList;
 
   /**
     * The member variable m_transactionList is the container for all
     * transactions within this file.
     * @see m_transactionKeys
     */
   MyMoneyMap<QString, MyMoneyTransaction> m_transactionList;
 
   /**
     * The member variable m_transactionKeys is used to convert
     * transaction id's into the corresponding key used in m_transactionList.
     * @see m_transactionList;
     */
   MyMoneyMap<QString, QString> m_transactionKeys;
 
   /**
     * A list containing all the payees that have been used
     */
   MyMoneyMap<QString, MyMoneyPayee> m_payeeList;
 
   /**
     * A list containing all the tags that have been used
     */
   MyMoneyMap<QString, MyMoneyTag> m_tagList;
 
   /**
     * A list containing all the scheduled transactions
     */
   MyMoneyMap<QString, MyMoneySchedule> m_scheduleList;
 
   /**
     * A list containing all the security information objects.  Each object
     * can represent a stock, bond, or mutual fund.  It contains a price
     * history that a user can add entries to.  The price history will be used
     * to determine the cost basis for sales, as well as the source of
     * information for reports in a security account.
     */
   MyMoneyMap<QString, MyMoneySecurity> m_securitiesList;
 
   /**
     * A list containing all the currency information objects.
     */
   MyMoneyMap<QString, MyMoneySecurity> m_currencyList;
 
   MyMoneyMap<QString, MyMoneyReport> m_reportList;
 
   /**
     * A list containing all the budget information objects.
     */
   MyMoneyMap<QString, MyMoneyBudget> m_budgetList;
 
   MyMoneyMap<MyMoneySecurityPair, MyMoneyPriceEntries> m_priceList;
 
   /**
     * A list containing all the onlineJob information objects.
     */
   MyMoneyMap<QString, onlineJob> m_onlineJobList;
 
   /**
    * A list containing all the cost center information objects
    */
   MyMoneyMap<QString, MyMoneyCostCenter> m_costCenterList;
 
   /**
     * This member signals if the file has been modified or not
     */
   bool  m_dirty;
 
   /**
     * This member variable keeps the creation date of this MyMoneyStorageMgr
     * object. It is set during the constructor and can only be modified using
     * the stream read operator.
     */
   QDate m_creationDate;
 
   /**
     * This member variable keeps the date of the last modification of
     * the MyMoneyStorageMgr object.
     */
   QDate m_lastModificationDate;
 
   /**
     * This member variable contains the current fix level of application
     * data files. (see kmymoneyview.cpp)
     */
   uint m_currentFixVersion;
   /**
    * This member variable contains the current fix level of the
    *  presently open data file. (see kmymoneyview.cpp)
    */
   uint m_fileFixVersion;
 
   /**
     * This member variable is set when all transactions have been read from the database.
     * This is would be probably the case when doing, for e.g., a full report,
     * or after some types of transaction search which cannot be easily implemented in SQL
     */
   bool m_transactionListFull;
 };
 #endif
diff --git a/kmymoney/mymoney/storage/mymoneystoragexml.cpp b/kmymoney/mymoney/storage/mymoneystoragexml.cpp
index 55099e515..0dbd5ce9d 100644
--- a/kmymoney/mymoney/storage/mymoneystoragexml.cpp
+++ b/kmymoney/mymoney/storage/mymoneystoragexml.cpp
@@ -1,1066 +1,1066 @@
 /***************************************************************************
                           mymoneystoragexml.cpp  -  description
                              -------------------
     begin                : Thu Oct 24 2002
     copyright            : (C) 2002 by Kevin Tambascio <ktambascio@users.sourceforge.net>
                            (C) 2004 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneystoragexml.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QMap>
 #include <QXmlLocator>
 #include <QTextStream>
 #include <QList>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDebug>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneystoragemgr.h"
 #include "mymoneyexception.h"
 #include "mymoneykeyvaluecontainer.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneymoney.h"
 #include "mymoneyschedule.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneyreport.h"
 #include "mymoneybudget.h"
 #include "mymoneyinstitution.h"
 #include "mymoneystoragenames.h"
 #include "mymoneyutils.h"
 #include "mymoneyprice.h"
 #include "mymoneycostcenter.h"
 #include "mymoneytransaction.h"
 #include "onlinejob.h"
 #include "mymoneyenums.h"
 
 using namespace MyMoneyStorageTags;
 using namespace MyMoneyStorageNodes;
 using namespace MyMoneyStorageAttributes;
 
 unsigned int MyMoneyStorageXML::fileVersionRead = 0;
 unsigned int MyMoneyStorageXML::fileVersionWrite = 0;
 
 class MyMoneyStorageXML::Private
 {
   friend class MyMoneyStorageXML;
 public:
   Private() : m_nextTransactionID(0) {}
 
   QMap<QString, MyMoneyInstitution> iList;
   QMap<QString, MyMoneyAccount> aList;
   QMap<QString, MyMoneyTransaction> tList;
   QMap<QString, MyMoneyPayee> pList;
   QMap<QString, MyMoneyTag> taList;
   QMap<QString, MyMoneySchedule> sList;
   QMap<QString, MyMoneySecurity> secList;
   QMap<QString, MyMoneyReport> rList;
   QMap<QString, MyMoneyBudget> bList;
   QMap<QString, onlineJob> onlineJobList;
   QMap<MyMoneySecurityPair, MyMoneyPriceEntries> prList;
   QMap<QString, MyMoneyCostCenter> ccList;
 
   QString           m_fromSecurity;
   QString           m_toSecurity;
   unsigned long     m_nextTransactionID;
   static const int  TRANSACTION_ID_SIZE = 18;
 
   QString nextTransactionID() {
     QString id;
     id.setNum(++m_nextTransactionID);
     id = 'T' + id.rightJustified(TRANSACTION_ID_SIZE, '0');
     return id;
   }
 
 
 };
 
 class MyMoneyXmlContentHandler : public QXmlContentHandler
 {
 public:
   MyMoneyXmlContentHandler(MyMoneyStorageXML* reader);
   virtual ~MyMoneyXmlContentHandler() {}
   virtual void setDocumentLocator(QXmlLocator * locator) final override {
     m_loc = locator;
   }
   virtual bool startDocument() final override;
   virtual bool endDocument() final override;
   virtual bool startPrefixMapping(const QString & prefix, const QString & uri) final override;
   virtual bool endPrefixMapping(const QString & prefix) final override;
   virtual bool startElement(const QString & namespaceURI, const QString & localName, const QString & qName, const QXmlAttributes & atts) final override;
   virtual bool endElement(const QString & namespaceURI, const QString & localName, const QString & qName) final override;
   virtual bool characters(const QString & ch) final override;
   virtual bool ignorableWhitespace(const QString & ch) final override;
   virtual bool processingInstruction(const QString & target, const QString & data) final override;
   virtual bool skippedEntity(const QString & name) final override;
   virtual QString errorString() const final override;
 private:
   MyMoneyStorageXML* m_reader;
   QXmlLocator*       m_loc;
   int                m_level;
   int                m_elementCount;
   QDomDocument       m_doc;
 
   /**
    * @node Text in the xml file is not added to this QDomElement. Only tags and their attributes are added.
    */
   QDomElement        m_baseNode;
 
   /**
    * @node Text in the xml file is not added to this QDomElement. Only tags and their attributes are added.
    */
   QDomElement        m_currNode;
   QString            m_errMsg;
 };
 
 MyMoneyXmlContentHandler::MyMoneyXmlContentHandler(MyMoneyStorageXML* reader) :
     m_reader(reader),
     m_loc(0),
     m_level(0),
     m_elementCount(0)
 {
 }
 
 bool MyMoneyXmlContentHandler::startDocument()
 {
   qDebug("startDocument");
   return true;
 }
 
 bool MyMoneyXmlContentHandler::endDocument()
 {
   qDebug("endDocument");
   return true;
 }
 
 bool MyMoneyXmlContentHandler::skippedEntity(const QString & /* name */)
 {
   // qDebug(QString("Skipped entity '%1'").arg(name));
   return true;
 }
 
 bool MyMoneyXmlContentHandler::startPrefixMapping(const QString& /*prefix */, const QString & /* uri */)
 {
   // qDebug(QString("start prefix '%1', '%2'").arg(prefix).arg(uri));
   return true;
 }
 
 bool MyMoneyXmlContentHandler::endPrefixMapping(const QString& /* prefix */)
 {
   // qDebug(QString("end prefix '%1'").arg(prefix));
   return true;
 }
 
 bool MyMoneyXmlContentHandler::startElement(const QString& /* namespaceURI */, const QString& /* localName */, const QString& qName, const QXmlAttributes & atts)
 {
   if (m_level == 0) {
     QString s = qName.toUpper();
     if (s == nodeNames[nnTransaction]
         || s == nodeNames[nnAccount]
         || s == nodeNames[nnPrice]
         || s == nodeNames[nnPayee]
         || s == nodeNames[nnTag]
         || s == nodeNames[nnCostCenter]
         || s == nodeNames[nnCurrency]
         || s == nodeNames[nnSecurity]
         || s == nodeNames[nnKeyValuePairs]
         || s == nodeNames[nnInstitution]
         || s == nodeNames[nnReport]
         || s == nodeNames[nnBudget]
         || s == tagNames[tnFileInfo]
         || s == tagNames[tnUser]
         || s == nodeNames[nnScheduleTX]
         || s == nodeNames[nnOnlineJob]) {
       m_baseNode = m_doc.createElement(qName);
       for (int i = 0; i < atts.count(); ++i) {
         m_baseNode.setAttribute(atts.qName(i), atts.value(i));
       }
       m_currNode = m_baseNode;
       m_level = 1;
 
     } else if (s == tagNames[tnTransactions]) {
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading transactions..."));
         m_elementCount = 0;
       }
     } else if (s == tagNames[tnAccounts]) {
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading accounts..."));
         m_elementCount = 0;
       }
     } else if (s == tagNames[tnSecurities]) {
       qDebug("reading securities");
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading securities..."));
         m_elementCount = 0;
       }
     } else if (s == tagNames[tnCurrencies]) {
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading currencies..."));
         m_elementCount = 0;
       }
     } else if (s == tagNames[tnReports]) {
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading reports..."));
         m_elementCount = 0;
       }
     } else if (s == tagNames[tnPrices]) {
       if (atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading prices..."));
         m_elementCount = 0;
       }
     } else if (s == nodeNames[nnPricePair]) {
       if (atts.count()) {
         m_reader->d->m_fromSecurity = atts.value(attrNames[anFrom]);
         m_reader->d->m_toSecurity = atts.value(attrNames[anTo]);
       }
     } else if (s == tagNames[tnCostCenters]) {
       if(atts.count()) {
         int count = atts.value(attrNames[anCount]).toInt();
         m_reader->signalProgress(0, count, i18n("Loading cost center..."));
         m_elementCount = 0;
       }
     }
 
   } else {
     m_level++;
     QDomElement node = m_doc.createElement(qName);
     for (int i = 0; i < atts.count(); ++i) {
       node.setAttribute(atts.qName(i), atts.value(i));
     }
     m_currNode.appendChild(node);
     m_currNode = node;
   }
   return true;
 }
 
 
 bool MyMoneyXmlContentHandler::endElement(const QString& /* namespaceURI */, const QString& /* localName */, const QString& qName)
 {
   bool rc = true;
   QString s = qName.toUpper();
   if (m_level) {
     m_currNode = m_currNode.parentNode().toElement();
     m_level--;
     if (!m_level) {
       try {
         if (s == nodeNames[nnTransaction]) {
           MyMoneyTransaction t0(m_baseNode);
           if (!t0.id().isEmpty()) {
             MyMoneyTransaction t1(m_reader->d->nextTransactionID(), t0);
             m_reader->d->tList[t1.uniqueSortKey()] = t1;
           }
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnAccount]) {
           MyMoneyAccount a(m_baseNode);
           if (!a.id().isEmpty())
             m_reader->d->aList[a.id()] = a;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnPayee]) {
           MyMoneyPayee p(m_baseNode);
           if (!p.id().isEmpty())
             m_reader->d->pList[p.id()] = p;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnTag]) {
           MyMoneyTag ta(m_baseNode);
           if (!ta.id().isEmpty())
             m_reader->d->taList[ta.id()] = ta;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnCurrency]) {
           MyMoneySecurity sec(m_baseNode);
           if (!sec.id().isEmpty())
             m_reader->d->secList[sec.id()] = sec;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnSecurity]) {
           MyMoneySecurity sec(m_baseNode);
           if (!sec.id().isEmpty())
             m_reader->d->secList[sec.id()] = sec;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnKeyValuePairs]) {
           MyMoneyKeyValueContainer kvp(m_baseNode);
           m_reader->m_storage->setPairs(kvp.pairs());
         } else if (s == nodeNames[nnInstitution]) {
           MyMoneyInstitution i(m_baseNode);
           if (!i.id().isEmpty())
             m_reader->d->iList[i.id()] = i;
         } else if (s == nodeNames[nnReport]) {
           MyMoneyReport r(m_baseNode);
           if (!r.id().isEmpty())
             m_reader->d->rList[r.id()] = r;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnBudget]) {
           MyMoneyBudget b(m_baseNode);
           if (!b.id().isEmpty())
             m_reader->d->bList[b.id()] = b;
         } else if (s == tagNames[tnFileInfo]) {
           rc = m_reader->readFileInformation(m_baseNode);
           m_reader->signalProgress(-1, -1);
         } else if (s == tagNames[tnUser]) {
           rc = m_reader->readUserInformation(m_baseNode);
           m_reader->signalProgress(-1, -1);
         } else if (s == nodeNames[nnScheduleTX]) {
           MyMoneySchedule sch(m_baseNode);
           if (!sch.id().isEmpty())
             m_reader->d->sList[sch.id()] = sch;
         } else if (s == nodeNames[nnPrice]) {
           MyMoneyPrice p(m_reader->d->m_fromSecurity, m_reader->d->m_toSecurity, m_baseNode);
           m_reader->d->prList[MyMoneySecurityPair(m_reader->d->m_fromSecurity, m_reader->d->m_toSecurity)][p.date()] = p;
           m_reader->signalProgress(++m_elementCount, 0);
         } else if (s == nodeNames[nnOnlineJob]) {
           onlineJob job(m_baseNode);
           if (!job.id().isEmpty())
             m_reader->d->onlineJobList[job.id()] = job;
         } else if (s == nodeNames[nnCostCenter]) {
           MyMoneyCostCenter c(m_baseNode);
           if(!c.id().isEmpty()) {
             m_reader->d->ccList[c.id()] = c;
           }
           m_reader->signalProgress(++m_elementCount, 0);
         } else {
           m_errMsg = i18n("Unknown XML tag %1 found in line %2", qName, m_loc->lineNumber());
           qWarning() << m_errMsg;
           rc = false;
         }
       } catch (const MyMoneyException &e) {
         m_errMsg = i18n("Exception while creating a %1 element: %2", s, e.what());
         qWarning() << m_errMsg;
         rc = false;
       }
       m_doc = QDomDocument();
     }
   } else {
     if (s == tagNames[tnInstitutions]) {
       // last institution read, now dump them into the engine
       m_reader->m_storage->loadInstitutions(m_reader->d->iList);
       m_reader->d->iList.clear();
     } else if (s == tagNames[tnAccounts]) {
       // last account read, now dump them into the engine
       m_reader->m_storage->loadAccounts(m_reader->d->aList);
       m_reader->d->aList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnPayees]) {
       // last payee read, now dump them into the engine
       m_reader->m_storage->loadPayees(m_reader->d->pList);
       m_reader->d->pList.clear();
     } else if (s == tagNames[tnTags]) {
       // last tag read, now dump them into the engine
       m_reader->m_storage->loadTags(m_reader->d->taList);
       m_reader->d->taList.clear();
     } else if (s == tagNames[tnTransactions]) {
       // last transaction read, now dump them into the engine
       m_reader->m_storage->loadTransactions(m_reader->d->tList);
       m_reader->d->tList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnSchedules]) {
       // last schedule read, now dump them into the engine
       m_reader->m_storage->loadSchedules(m_reader->d->sList);
       m_reader->d->sList.clear();
     } else if (s == tagNames[tnSecurities]) {
       // last security read, now dump them into the engine
       m_reader->m_storage->loadSecurities(m_reader->d->secList);
       m_reader->d->secList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnCurrencies]) {
       // last currency read, now dump them into the engine
       m_reader->m_storage->loadCurrencies(m_reader->d->secList);
       m_reader->d->secList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnReports]) {
       // last report read, now dump them into the engine
       m_reader->m_storage->loadReports(m_reader->d->rList);
       m_reader->d->rList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnBudgets]) {
       // last budget read, now dump them into the engine
       m_reader->m_storage->loadBudgets(m_reader->d->bList);
       m_reader->d->bList.clear();
     } else if (s == tagNames[tnPrices]) {
       // last price read, now dump them into the engine
       m_reader->m_storage->loadPrices(m_reader->d->prList);
       m_reader->d->bList.clear();
       m_reader->signalProgress(-1, -1);
     } else if (s == tagNames[tnOnlineJobs]) {
       m_reader->m_storage->loadOnlineJobs(m_reader->d->onlineJobList);
       m_reader->d->onlineJobList.clear();
     } else if (s == tagNames[tnCostCenters]) {
       m_reader->m_storage->loadCostCenters(m_reader->d->ccList);
       m_reader->d->ccList.clear();
       m_reader->signalProgress(-1, -1);
     }
   }
   return rc;
 }
 
 bool MyMoneyXmlContentHandler::characters(const QString& /* ch */)
 {
   return true;
 }
 
 bool MyMoneyXmlContentHandler::ignorableWhitespace(const QString& /* ch */)
 {
   return true;
 }
 
 bool MyMoneyXmlContentHandler::processingInstruction(const QString& /* target */, const QString& /* data */)
 {
   return true;
 }
 
 QString MyMoneyXmlContentHandler::errorString() const
 {
   return m_errMsg;
 }
 
 
 
 
 
 
 
 MyMoneyStorageXML::MyMoneyStorageXML() :
     m_progressCallback(0),
     m_storage(0),
     m_doc(0),
     d(new Private())
 {
 }
 
 MyMoneyStorageXML::~MyMoneyStorageXML()
 {
   delete d;
 }
 
 // Function to read in the file, send to XML parser.
 void MyMoneyStorageXML::readFile(QIODevice* pDevice, MyMoneyStorageMgr* storage)
 {
   Q_CHECK_PTR(storage);
   Q_CHECK_PTR(pDevice);
   if (!storage)
     return;
 
   m_storage = storage;
 
   m_doc = new QDomDocument;
   Q_CHECK_PTR(m_doc);
 
   qDebug("reading file");
   // creating the QXmlInputSource object based on a QIODevice object
   // reads all data of the underlying object into memory. I have not
   // found an object that reads on the fly. I tried to derive one myself,
   // but there could be a severe problem with decoding when reading
   // blocks of data and not a stream. So I left it the way it is. (ipwizard)
   QXmlInputSource xml(pDevice);
 
   qDebug("start parsing file");
   MyMoneyXmlContentHandler mmxml(this);
   QXmlSimpleReader reader;
   reader.setContentHandler(&mmxml);
 
   if (!reader.parse(&xml, false)) {
     delete m_doc;
     m_doc = 0;
     signalProgress(-1, -1);
-    throw MYMONEYEXCEPTION("File was not parsable!");
+    throw MYMONEYEXCEPTION_CSTRING("File was not parsable!");
   }
 
   // check if we need to build up the account balances
   if (fileVersionRead < 2)
     m_storage->rebuildAccountBalances();
 
   delete m_doc;
   m_doc = 0;
 
   // this seems to be nonsense, but it clears the dirty flag
   // as a side-effect.
   m_storage->setLastModificationDate(m_storage->lastModificationDate());
   m_storage = 0;
 
   //hides the progress bar.
   signalProgress(-1, -1);
 }
 
 void MyMoneyStorageXML::writeFile(QIODevice* qf, MyMoneyStorageMgr* storage)
 {
   Q_CHECK_PTR(qf);
   Q_CHECK_PTR(storage);
   if (!storage) {
     return;
   }
   m_storage = storage;
 
   // qDebug("XMLWRITER: Starting file write");
   m_doc = new QDomDocument(tagNames[tnKMMFile]);
   Q_CHECK_PTR(m_doc);
   QDomProcessingInstruction instruct = m_doc->createProcessingInstruction("xml", "version=\"1.0\" encoding=\"utf-8\"");
   m_doc->appendChild(instruct);
 
   QDomElement mainElement = m_doc->createElement(tagNames[tnKMMFile]);
   m_doc->appendChild(mainElement);
 
   QDomElement fileInfo = m_doc->createElement(tagNames[tnFileInfo]);
   writeFileInformation(fileInfo);
   mainElement.appendChild(fileInfo);
 
   QDomElement userInfo = m_doc->createElement(tagNames[tnUser]);
   writeUserInformation(userInfo);
   mainElement.appendChild(userInfo);
 
   QDomElement institutions = m_doc->createElement(tagNames[tnInstitutions]);
   writeInstitutions(institutions);
   mainElement.appendChild(institutions);
 
   QDomElement payees = m_doc->createElement(tagNames[tnPayees]);
   writePayees(payees);
   mainElement.appendChild(payees);
 
   QDomElement costCenters = m_doc->createElement(tagNames[tnCostCenters]);
   writeCostCenters(costCenters);
   mainElement.appendChild(costCenters);
 
   QDomElement tags = m_doc->createElement(tagNames[tnTags]);
   writeTags(tags);
   mainElement.appendChild(tags);
 
   QDomElement accounts = m_doc->createElement(tagNames[tnAccounts]);
   writeAccounts(accounts);
   mainElement.appendChild(accounts);
 
   QDomElement transactions = m_doc->createElement(tagNames[tnTransactions]);
   writeTransactions(transactions);
   mainElement.appendChild(transactions);
 
   QDomElement keyvalpairs = writeKeyValuePairs(m_storage->pairs());
   mainElement.appendChild(keyvalpairs);
 
   QDomElement schedules = m_doc->createElement(tagNames[tnSchedules]);
   writeSchedules(schedules);
   mainElement.appendChild(schedules);
 
   QDomElement equities = m_doc->createElement(tagNames[tnSecurities]);
   writeSecurities(equities);
   mainElement.appendChild(equities);
 
   QDomElement currencies = m_doc->createElement(tagNames[tnCurrencies]);
   writeCurrencies(currencies);
   mainElement.appendChild(currencies);
 
   QDomElement prices = m_doc->createElement(tagNames[tnPrices]);
   writePrices(prices);
   mainElement.appendChild(prices);
 
   QDomElement reports = m_doc->createElement(tagNames[tnReports]);
   writeReports(reports);
   mainElement.appendChild(reports);
 
   QDomElement budgets = m_doc->createElement(tagNames[tnBudgets]);
   writeBudgets(budgets);
   mainElement.appendChild(budgets);
 
   QDomElement onlineJobs = m_doc->createElement(tagNames[tnOnlineJobs]);
   writeOnlineJobs(onlineJobs);
   mainElement.appendChild(onlineJobs);
 
   QTextStream stream(qf);
   stream.setCodec("UTF-8");
   stream << m_doc->toString();
 
   delete m_doc;
   m_doc = 0;
 
   //hides the progress bar.
   signalProgress(-1, -1);
 
   // this seems to be nonsense, but it clears the dirty flag
   // as a side-effect.
   m_storage->setLastModificationDate(m_storage->lastModificationDate());
 
   m_storage = 0;
 }
 
 bool MyMoneyStorageXML::readFileInformation(const QDomElement& fileInfo)
 {
   signalProgress(0, 3, i18n("Loading file information..."));
   bool rc = true;
   QDomElement temp = findChildElement(getElName(enCreationDate), fileInfo);
   if (temp == QDomElement()) {
     rc = false;
   }
   QString strDate = MyMoneyUtils::QStringEmpty(temp.attribute(attrNames[anDate]));
   m_storage->setCreationDate(MyMoneyUtils::stringToDate(strDate));
   signalProgress(1, 0);
 
   temp = findChildElement(getElName(enLastModifiedDate), fileInfo);
   if (temp == QDomElement()) {
     rc = false;
   }
   strDate = MyMoneyUtils::QStringEmpty(temp.attribute(attrNames[anDate]));
   m_storage->setLastModificationDate(MyMoneyUtils::stringToDate(strDate));
   signalProgress(2, 0);
 
   temp = findChildElement(getElName(enVersion), fileInfo);
   if (temp == QDomElement()) {
     rc = false;
   }
   QString strVersion = MyMoneyUtils::QStringEmpty(temp.attribute(attrNames[anID]));
   fileVersionRead = strVersion.toUInt(0, 16);
 
   temp = findChildElement(getElName(enFixVersion), fileInfo);
   if (temp != QDomElement()) {
     QString strFixVersion = MyMoneyUtils::QStringEmpty(temp.attribute(attrNames[anID]));
     m_storage->setFileFixVersion(strFixVersion.toUInt());
     // skip KMyMoneyView::fixFile_2()
     if (m_storage->fileFixVersion() == 2) {
       m_storage->setFileFixVersion(3);
     }
   }
   // FIXME The old version stuff used this rather odd number
   //       We now use increments
   if (fileVersionRead == VERSION_0_60_XML)
     fileVersionRead = 1;
   signalProgress(3, 0);
 
   return rc;
 }
 
 void MyMoneyStorageXML::writeFileInformation(QDomElement& fileInfo)
 {
   QDomElement creationDate = m_doc->createElement(getElName(enCreationDate));
   creationDate.setAttribute(attrNames[anDate], MyMoneyUtils::dateToString(m_storage->creationDate()));
   fileInfo.appendChild(creationDate);
 
   QDomElement lastModifiedDate = m_doc->createElement(getElName(enLastModifiedDate));
   lastModifiedDate.setAttribute(attrNames[anDate], MyMoneyUtils::dateToString(m_storage->lastModificationDate()));
   fileInfo.appendChild(lastModifiedDate);
 
   QDomElement version = m_doc->createElement(getElName(enVersion));
 
   version.setAttribute(attrNames[anID], "1");
   fileInfo.appendChild(version);
 
   QDomElement fixVersion = m_doc->createElement(getElName(enFixVersion));
   fixVersion.setAttribute(attrNames[anID], m_storage->fileFixVersion());
   fileInfo.appendChild(fixVersion);
 }
 
 void MyMoneyStorageXML::writeUserInformation(QDomElement& userInfo)
 {
   MyMoneyPayee user = m_storage->user();
   userInfo.setAttribute(attrNames[anName], user.name());
   userInfo.setAttribute(attrNames[anEmail], user.email());
 
   QDomElement address = m_doc->createElement(getElName(enAddress));
   address.setAttribute(attrNames[anStreet], user.address());
   address.setAttribute(attrNames[anCity], user.city());
   address.setAttribute(attrNames[anCountry], user.state());
   address.setAttribute(attrNames[anZipCode], user.postcode());
   address.setAttribute(attrNames[anTelephone], user.telephone());
 
   userInfo.appendChild(address);
 }
 
 bool MyMoneyStorageXML::readUserInformation(const QDomElement& userElement)
 {
   bool rc = true;
   signalProgress(0, 1, i18n("Loading user information..."));
 
   MyMoneyPayee user;
   user.setName(MyMoneyUtils::QStringEmpty(userElement.attribute(attrNames[anName])));
   user.setEmail(MyMoneyUtils::QStringEmpty(userElement.attribute(attrNames[anEmail])));
 
   QDomElement addressNode = findChildElement(getElName(enAddress), userElement);
   if (!addressNode.isNull()) {
     user.setAddress(MyMoneyUtils::QStringEmpty(addressNode.attribute(attrNames[anStreet])));
     user.setCity(MyMoneyUtils::QStringEmpty(addressNode.attribute(attrNames[anCity])));
     user.setState(MyMoneyUtils::QStringEmpty(addressNode.attribute(attrNames[anCountry])));
     user.setPostcode(MyMoneyUtils::QStringEmpty(addressNode.attribute(attrNames[anZipCode])));
     user.setTelephone(MyMoneyUtils::QStringEmpty(addressNode.attribute(attrNames[anTelephone])));
   }
 
   m_storage->setUser(user);
   signalProgress(1, 0);
 
   return rc;
 }
 
 void MyMoneyStorageXML::writeInstitutions(QDomElement& institutions)
 {
   const QList<MyMoneyInstitution> list = m_storage->institutionList();
   QList<MyMoneyInstitution>::ConstIterator it;
   institutions.setAttribute(attrNames[anCount], list.count());
 
   for (it = list.begin(); it != list.end(); ++it)
     writeInstitution(institutions, *it);
 }
 
 void MyMoneyStorageXML::writeInstitution(QDomElement& institution, const MyMoneyInstitution& i)
 {
   i.writeXML(*m_doc, institution);
 }
 
 void MyMoneyStorageXML::writePayees(QDomElement& payees)
 {
   const QList<MyMoneyPayee> list = m_storage->payeeList();
   QList<MyMoneyPayee>::ConstIterator it;
   payees.setAttribute(attrNames[anCount], list.count());
 
   for (it = list.begin(); it != list.end(); ++it)
     writePayee(payees, *it);
 }
 
 void MyMoneyStorageXML::writePayee(QDomElement& payee, const MyMoneyPayee& p)
 {
   p.writeXML(*m_doc, payee);
 }
 
 void MyMoneyStorageXML::writeTags(QDomElement& tags)
 {
   const QList<MyMoneyTag> list = m_storage->tagList();
   QList<MyMoneyTag>::ConstIterator it;
   tags.setAttribute(attrNames[anCount], list.count());
 
   for (it = list.begin(); it != list.end(); ++it)
     writeTag(tags, *it);
 }
 
 void MyMoneyStorageXML::writeTag(QDomElement& tag, const MyMoneyTag& ta)
 {
   ta.writeXML(*m_doc, tag);
 }
 
 void MyMoneyStorageXML::writeAccounts(QDomElement& accounts)
 {
   QList<MyMoneyAccount> list;
   m_storage->accountList(list);
   QList<MyMoneyAccount>::ConstIterator it;
   accounts.setAttribute(attrNames[anCount], list.count() + 5);
 
   writeAccount(accounts, m_storage->asset());
   writeAccount(accounts, m_storage->liability());
   writeAccount(accounts, m_storage->expense());
   writeAccount(accounts, m_storage->income());
   writeAccount(accounts, m_storage->equity());
 
   signalProgress(0, list.count(), i18n("Saving accounts..."));
   int i = 0;
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     writeAccount(accounts, *it);
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeAccount(QDomElement& account, const MyMoneyAccount& p)
 {
   p.writeXML(*m_doc, account);
 }
 
 void MyMoneyStorageXML::writeTransactions(QDomElement& transactions)
 {
   MyMoneyTransactionFilter filter;
   filter.setReportAllSplits(false);
   const auto list = m_storage->transactionList(filter);
   transactions.setAttribute(attrNames[anCount], list.count());
 
   QList<MyMoneyTransaction>::ConstIterator it;
 
   signalProgress(0, list.count(), i18n("Saving transactions..."));
 
   int i = 0;
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     writeTransaction(transactions, *it);
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeTransaction(QDomElement& transaction, const MyMoneyTransaction& tx)
 {
   tx.writeXML(*m_doc, transaction);
 }
 
 void MyMoneyStorageXML::writeSchedules(QDomElement& scheduled)
 {
   const QList<MyMoneySchedule> list = m_storage->scheduleList(QString(), eMyMoney::Schedule::Type::Any, eMyMoney::Schedule::Occurrence::Any, eMyMoney::Schedule::PaymentType::Any,
                                                               QDate(), QDate(), false);
   QList<MyMoneySchedule>::ConstIterator it;
   scheduled.setAttribute(attrNames[anCount], list.count());
 
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     this->writeSchedule(scheduled, *it);
   }
 }
 
 void MyMoneyStorageXML::writeSchedule(QDomElement& scheduledTx, const MyMoneySchedule& tx)
 {
   tx.writeXML(*m_doc, scheduledTx);
 }
 
 void MyMoneyStorageXML::writeSecurities(QDomElement& equities)
 {
   const QList<MyMoneySecurity> securityList = m_storage->securityList();
   equities.setAttribute(attrNames[anCount], securityList.count());
   if (securityList.size()) {
     for (QList<MyMoneySecurity>::ConstIterator it = securityList.constBegin(); it != securityList.constEnd(); ++it) {
       writeSecurity(equities, (*it));
     }
   }
 }
 
 void MyMoneyStorageXML::writeSecurity(QDomElement& securityElement, const MyMoneySecurity& security)
 {
   security.writeXML(*m_doc, securityElement);
 }
 
 void MyMoneyStorageXML::writeCurrencies(QDomElement& currencies)
 {
   const QList<MyMoneySecurity> currencyList = m_storage->currencyList();
   currencies.setAttribute(attrNames[anCount], currencyList.count());
   if (currencyList.size()) {
     for (QList<MyMoneySecurity>::ConstIterator it = currencyList.constBegin(); it != currencyList.constEnd(); ++it) {
       writeSecurity(currencies, (*it));
     }
   }
 }
 
 void MyMoneyStorageXML::writeReports(QDomElement& parent)
 {
   const QList<MyMoneyReport> list = m_storage->reportList();
   QList<MyMoneyReport>::ConstIterator it;
   parent.setAttribute(attrNames[anCount], list.count());
 
   signalProgress(0, list.count(), i18n("Saving reports..."));
   unsigned i = 0;
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     writeReport(parent, (*it));
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeReport(QDomElement& report, const MyMoneyReport& r)
 {
   r.writeXML(*m_doc, report);
 }
 
 void MyMoneyStorageXML::writeBudgets(QDomElement& parent)
 {
   const QList<MyMoneyBudget> list = m_storage->budgetList();
   QList<MyMoneyBudget>::ConstIterator it;
   parent.setAttribute(attrNames[anCount], list.count());
 
   signalProgress(0, list.count(), i18n("Saving budgets..."));
   unsigned i = 0;
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     writeBudget(parent, (*it));
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeBudget(QDomElement& budget, const MyMoneyBudget& b)
 {
   b.writeXML(*m_doc, budget);
 }
 
 void MyMoneyStorageXML::writeOnlineJobs(QDomElement& parent)
 {
   const QList<onlineJob> list = m_storage->onlineJobList();
   parent.setAttribute(attrNames[anCount], list.count());
   signalProgress(0, list.count(), i18n("Saving online banking orders..."));
   unsigned i = 0;
   QList<onlineJob>::ConstIterator end = list.constEnd();
   for (QList<onlineJob>::ConstIterator it = list.constBegin(); it != end; ++it) {
     writeOnlineJob(parent, *it);
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeOnlineJob(QDomElement& onlineJobs, const onlineJob& job)
 {
   job.writeXML(*m_doc, onlineJobs);
 }
 
 void MyMoneyStorageXML::writeCostCenters(QDomElement& parent)
 {
   const QList<MyMoneyCostCenter> list = m_storage->costCenterList();
   parent.setAttribute(attrNames[anCount], list.count());
   signalProgress(0, list.count(), i18n("Saving costcenters..."));
   unsigned i = 0;
   Q_FOREACH(MyMoneyCostCenter costCenter, list) {
     writeCostCenter(parent, costCenter);
     signalProgress(++i, 0);
   }
 }
 
 void MyMoneyStorageXML::writeCostCenter(QDomElement& costCenters, const MyMoneyCostCenter& costCenter)
 {
   costCenter.writeXML(*m_doc, costCenters);
 }
 
 QDomElement MyMoneyStorageXML::findChildElement(const QString& name, const QDomElement& root)
 {
   QDomNode child = root.firstChild();
   while (!child.isNull()) {
     if (child.isElement()) {
       QDomElement childElement = child.toElement();
       if (name == childElement.tagName()) {
         return childElement;
       }
     }
 
     child = child.nextSibling();
   }
   return QDomElement();
 }
 
 QDomElement MyMoneyStorageXML::writeKeyValuePairs(const QMap<QString, QString> pairs)
 {
   if (m_doc) {
     QDomElement keyValPairs = m_doc->createElement(nodeNames[nnKeyValuePairs]);
 
     QMap<QString, QString>::const_iterator it;
     for (it = pairs.constBegin(); it != pairs.constEnd(); ++it) {
       QDomElement pair = m_doc->createElement(getElName(enPair));
       pair.setAttribute(attrNames[anKey], it.key());
       pair.setAttribute(attrNames[anValue], it.value());
       keyValPairs.appendChild(pair);
     }
     return keyValPairs;
   }
   return QDomElement();
 }
 
 void MyMoneyStorageXML::writePrices(QDomElement& prices)
 {
   const MyMoneyPriceList list = m_storage->priceList();
   MyMoneyPriceList::ConstIterator it;
   prices.setAttribute(attrNames[anCount], list.count());
 
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     QDomElement price = m_doc->createElement(nodeNames[nnPricePair]);
     price.setAttribute(attrNames[anFrom], it.key().first);
     price.setAttribute(attrNames[anTo], it.key().second);
     writePricePair(price, *it);
     prices.appendChild(price);
   }
 }
 
 void MyMoneyStorageXML::writePricePair(QDomElement& price, const MyMoneyPriceEntries& p)
 {
   MyMoneyPriceEntries::ConstIterator it;
   for (it = p.constBegin(); it != p.constEnd(); ++it) {
     QDomElement entry = m_doc->createElement(nodeNames[nnPrice]);
     writePrice(entry, *it);
     price.appendChild(entry);
   }
 }
 
 void MyMoneyStorageXML::writePrice(QDomElement& price, const MyMoneyPrice& p)
 {
   price.setAttribute(attrNames[anDate], p.date().toString(Qt::ISODate));
   price.setAttribute(attrNames[anPrice], p.rate(QString()).toString());
   price.setAttribute(attrNames[anSource], p.source());
 }
 
 void MyMoneyStorageXML::setProgressCallback(void(*callback)(int, int, const QString&))
 {
   m_progressCallback = callback;
 }
 
 void MyMoneyStorageXML::signalProgress(int current, int total, const QString& msg)
 {
   if (m_progressCallback != 0)
     (*m_progressCallback)(current, total, msg);
 }
 
 #if 0
 /*!
     This convenience function returns all of the remaining data in the
     device.
 
     @note It's copied from the original Qt sources and modified to
           fix a problem with KFilterDev that does not correctly return
           atEnd() status in certain circumstances which caused our
           application to lock at startup.
 */
 QByteArray QIODevice::readAll()
 {
   if (isDirectAccess()) {
     // we know the size
     int n = size() - at(); // ### fix for 64-bit or large files?
     int totalRead = 0;
     QByteArray ba(n);
     char* c = ba.data();
     while (n) {
       int r = read(c, n);
       if (r < 0)
         return QByteArray();
       n -= r;
       c += r;
       totalRead += r;
       // If we have a translated file, then it is possible that
       // we read less bytes than size() reports
       if (atEnd()) {
         ba.resize(totalRead);
         break;
       }
     }
     return ba;
   } else {
     // read until we reach the end
     const int blocksize = 512;
     int nread = 0;
     QByteArray ba;
     int r = 1;
     while (!atEnd() && r != 0) {
       ba.resize(nread + blocksize);
       r = read(ba.data() + nread, blocksize);
       if (r < 0)
         return QByteArray();
       nread += r;
     }
     ba.resize(nread);
     return ba;
   }
 }
 #endif
 
 const QString MyMoneyStorageXML::getElName(const elNameE _el)
 {
   static const QHash<elNameE, QString> elNames = {
     {enAddress, QStringLiteral("ADDRESS")},
     {enCreationDate, QStringLiteral("CREATION_DATE")},
     {enLastModifiedDate, QStringLiteral("LAST_MODIFIED_DATE")},
     {enVersion, QStringLiteral("VERSION")},
     {enFixVersion, QStringLiteral("FIXVERSION")},
     {enPair, QStringLiteral("PAIR")}
   };
   return elNames[_el];
 }
diff --git a/kmymoney/mymoney/storage/tests/mymoneystoragemgr-test.cpp b/kmymoney/mymoney/storage/tests/mymoneystoragemgr-test.cpp
index a21f36c2d..56e9be962 100644
--- a/kmymoney/mymoney/storage/tests/mymoneystoragemgr-test.cpp
+++ b/kmymoney/mymoney/storage/tests/mymoneystoragemgr-test.cpp
@@ -1,1855 +1,1855 @@
 /***************************************************************************
                           mymoneystoragemgrtest.cpp
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : 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 "mymoneystoragemgr-test.h"
 #include <iostream>
 #include <QList>
 #include <QtTest>
 
 #include "mymoneystoragemgr_p.h"
 
 #include "mymoneytestutils.h"
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneytag.h"
 #include "mymoneypayee.h"
 #include "mymoneyschedule.h"
 #include "mymoneyschedule_p.h"
 #include "mymoneyreport.h"
 #include "mymoneysplit.h"
 #include "mymoneysplit_p.h"
 #include "mymoneytransaction.h"
 #include "mymoneybudget.h"
 #include "mymoneyprice.h"
 #include "onlinejob.h"
 
 #include "onlinetasks/dummy/tasks/dummytask.h"
 
 #include "mymoneyenums.h"
 #include "mymoneystoragenames.h"
 
 using namespace eMyMoney;
 using namespace MyMoneyStandardAccounts;
 
 QTEST_GUILESS_MAIN(MyMoneyStorageMgrTest)
 
 void MyMoneyStorageMgrTest::init()
 {
   m = new MyMoneyStorageMgr;
   MyMoneyFile* file = MyMoneyFile::instance();
   file->attachStorage(m);
   m->startTransaction();
 }
 
 void MyMoneyStorageMgrTest::cleanup()
 {
   m->commitTransaction();
   MyMoneyFile* file = MyMoneyFile::instance();
   file->detachStorage(m);
   delete m;
 }
 
 void MyMoneyStorageMgrTest::testEmptyConstructor()
 {
   MyMoneyPayee user = m->user();
 
   QVERIFY(user.name().isEmpty());
   QVERIFY(user.address().isEmpty());
   QVERIFY(user.city().isEmpty());
   QVERIFY(user.state().isEmpty());
   QVERIFY(user.postcode().isEmpty());
   QVERIFY(user.telephone().isEmpty());
   QVERIFY(user.email().isEmpty());
   QCOMPARE(m->d_func()->m_nextInstitutionID, 0ul);
   QCOMPARE(m->d_func()->m_nextAccountID, 0ul);
   QCOMPARE(m->d_func()->m_nextTransactionID, 0ul);
   QCOMPARE(m->d_func()->m_nextPayeeID, 0ul);
   QCOMPARE(m->d_func()->m_nextScheduleID, 0ul);
   QCOMPARE(m->d_func()->m_nextReportID, 0ul);
   QCOMPARE(m->d_func()->m_institutionList.count(), 0);
   QCOMPARE(m->d_func()->m_accountList.count(), 5);
   QCOMPARE(m->d_func()->m_transactionList.count(), 0);
   QCOMPARE(m->d_func()->m_transactionKeys.count(), 0);
   QCOMPARE(m->d_func()->m_payeeList.count(), 0);
   QCOMPARE(m->d_func()->m_tagList.count(), 0);
   QCOMPARE(m->d_func()->m_scheduleList.count(), 0);
 
   QCOMPARE(m->d_func()->m_dirty, false);
   QCOMPARE(m->creationDate(), QDate::currentDate());
 
   QCOMPARE(m->liability().name(), QLatin1String("Liability"));
   QCOMPARE(m->asset().name(), QLatin1String("Asset"));
   QCOMPARE(m->expense().name(), QLatin1String("Expense"));
   QCOMPARE(m->income().name(), QLatin1String("Income"));
   QCOMPARE(m->equity().name(), QLatin1String("Equity"));
 }
 
 void MyMoneyStorageMgrTest::testSetFunctions()
 {
   MyMoneyPayee user = m->user();
 
   m->d_func()->m_dirty = false;
   user.setName("Name");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setAddress("Street");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setCity("Town");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setState("County");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setPostcode("Postcode");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setTelephone("Telephone");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   user.setEmail("Email");
   m->setUser(user);
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
   m->d_func()->m_dirty = false;
   m->setValue("key", "value");
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
 
   user = m->user();
   QCOMPARE(user.name(), QLatin1String("Name"));
   QCOMPARE(user.address(), QLatin1String("Street"));
   QCOMPARE(user.city(), QLatin1String("Town"));
   QCOMPARE(user.state(), QLatin1String("County"));
   QCOMPARE(user.postcode(), QLatin1String("Postcode"));
   QCOMPARE(user.telephone(), QLatin1String("Telephone"));
   QCOMPARE(user.email(), QLatin1String("Email"));
   QCOMPARE(m->value("key"), QLatin1String("value"));
 
   m->d_func()->m_dirty = false;
   m->deletePair("key");
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), true);
 }
 
 void MyMoneyStorageMgrTest::testSupportFunctions()
 {
   QCOMPARE(m->d_func()->nextInstitutionID(), QLatin1String("I000001"));
   QCOMPARE(m->d_func()->m_nextInstitutionID, 1ul);
   QCOMPARE(m->d_func()->nextAccountID(), QLatin1String("A000001"));
   QCOMPARE(m->d_func()->m_nextAccountID, 1ul);
   QCOMPARE(m->d_func()->nextTransactionID(), QLatin1String("T000000000000000001"));
   QCOMPARE(m->d_func()->m_nextTransactionID, 1ul);
   QCOMPARE(m->d_func()->nextPayeeID(), QLatin1String("P000001"));
   QCOMPARE(m->d_func()->m_nextPayeeID, 1ul);
   QCOMPARE(m->d_func()->nextTagID(), QLatin1String("G000001"));
   QCOMPARE(m->d_func()->m_nextTagID, 1ul);
   QCOMPARE(m->d_func()->nextScheduleID(), QLatin1String("SCH000001"));
   QCOMPARE(m->d_func()->m_nextScheduleID, 1ul);
   QCOMPARE(m->d_func()->nextReportID(), QLatin1String("R000001"));
   QCOMPARE(m->d_func()->m_nextReportID, 1ul);
   QCOMPARE(m->d_func()->nextOnlineJobID(), QLatin1String("O000001"));
   QCOMPARE(m->d_func()->m_nextOnlineJobID, 1ul);
 }
 
 void MyMoneyStorageMgrTest::testIsStandardAccount()
 {
   QCOMPARE(m->isStandardAccount(stdAccNames[stdAccLiability]), true);
   QCOMPARE(m->isStandardAccount(stdAccNames[stdAccAsset]), true);
   QCOMPARE(m->isStandardAccount(stdAccNames[stdAccExpense]), true);
   QCOMPARE(m->isStandardAccount(stdAccNames[stdAccIncome]), true);
   QCOMPARE(m->isStandardAccount("A0002"), false);
 }
 
 void MyMoneyStorageMgrTest::testNewAccount()
 {
   MyMoneyAccount a;
 
   a.setName("AccountName");
   a.setNumber("AccountNumber");
 
   m->addAccount(a);
   m->commitTransaction();
   m->startTransaction();
 
   QCOMPARE(m->d_func()->m_nextAccountID, 1ul);
   QCOMPARE(m->dirty(), true);
   QCOMPARE(m->d_func()->m_accountList.count(), 6);
   QCOMPARE(m->d_func()->m_accountList["A000001"].name(), QLatin1String("AccountName"));
 }
 
 void MyMoneyStorageMgrTest::testAccount()
 {
   testNewAccount();
   m->d_func()->m_dirty = false;
 
   MyMoneyAccount a;
 
   // make sure that an invalid ID causes an exception
   try {
     a = m->account("Unknown ID");
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
   m->commitTransaction();
   m->startTransaction();
   QCOMPARE(m->dirty(), false);
 
   // now make sure, that a real ID works
   try {
     a = m->account("A000001");
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(a.name(), QLatin1String("AccountName"));
     QCOMPARE(a.id(), QLatin1String("A000001"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testAddNewAccount()
 {
   testNewAccount();
 
   MyMoneyAccount a, b;
   b.setName("Account2");
   b.setNumber("Acc2");
   m->addAccount(b);
   m->commitTransaction();
   m->startTransaction();
 
   m->d_func()->m_dirty = false;
 
   QCOMPARE(m->d_func()->m_nextAccountID, 2ul);
   QCOMPARE(m->d_func()->m_accountList.count(), 7);
 
   // try to add account to undefined account
   try {
     MyMoneyAccount c("UnknownID", b);
     m->addAccount(c, a);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
   m->commitTransaction();
   m->startTransaction();
 
   QCOMPARE(m->dirty(), false);
   // now try to add account 1 as sub-account to account 2
   a = m->account("A000001");
   try {
     QCOMPARE(m->d_func()->m_accountList[stdAccNames[stdAccAsset]].accountList().count(), 0);
     m->addAccount(b, a);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_accountList["A000002"].accountList()[0], QLatin1String("A000001"));
     QCOMPARE(m->d_func()->m_accountList["A000002"].accountList().count(), 1);
     QCOMPARE(m->d_func()->m_accountList[stdAccNames[stdAccAsset]].accountList().count(), 0);
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testAddInstitution()
 {
   MyMoneyInstitution i;
 
   i.setName("Inst Name");
 
   m->addInstitution(i);
   QCOMPARE(m->d_func()->m_institutionList.count(), 1);
   QCOMPARE(m->d_func()->m_nextInstitutionID, 1ul);
   QCOMPARE(m->d_func()->m_institutionList["I000001"].name(), QLatin1String("Inst Name"));
 }
 
 void MyMoneyStorageMgrTest::testInstitution()
 {
   testAddInstitution();
   MyMoneyInstitution i;
 
   m->d_func()->m_dirty = false;
 
   // try to find unknown institution
   try {
     i = m->institution("Unknown ID");
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   QCOMPARE(m->dirty(), false);
 
   // now try to find real institution
   try {
     i = m->institution("I000001");
     QCOMPARE(i.name(), QLatin1String("Inst Name"));
     QCOMPARE(m->dirty(), false);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testAccount2Institution()
 {
   testAddInstitution();
   testAddNewAccount();
 
   MyMoneyInstitution i;
   MyMoneyAccount a, b;
 
   try {
     i = m->institution("I000001");
     a = m->account("A000001");
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
 
   // try to add to a false institution
   MyMoneyInstitution fake("Unknown ID", i);
   a.setInstitutionId(fake.id());
   try {
     m->modifyAccount(a);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
   m->commitTransaction();
   m->startTransaction();
 
   QCOMPARE(m->dirty(), false);
   // now try to do it with a real institution
   try {
     QCOMPARE(i.accountList().count(), 0);
     a.setInstitutionId(i.id());
     m->modifyAccount(a);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(a.institutionId(), i.id());
     b = m->account("A000001");
     QCOMPARE(b.institutionId(), i.id());
     QCOMPARE(i.accountList().count(), 0);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testModifyAccount()
 {
   testAccount2Institution();
 
   // test the OK case
   MyMoneyAccount a = m->account("A000001");
   a.setName("New account name");
   m->d_func()->m_dirty = false;
   try {
     m->modifyAccount(a);
     m->commitTransaction();
     m->startTransaction();
     MyMoneyAccount b = m->account("A000001");
     QCOMPARE(b.parentAccountId(), a.parentAccountId());
     QCOMPARE(b.name(), QLatin1String("New account name"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   // modify institution to unknown id
   MyMoneyAccount c("Unknown ID", a);
   m->d_func()->m_dirty = false;
   try {
     m->modifyAccount(c);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   // use different account type
   MyMoneyAccount d;
   d.setAccountType(Account::Type::CreditCard);
   MyMoneyAccount f("A000001", d);
   try {
     m->modifyAccount(f);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   // use different parent
   a.setParentAccountId("A000002");
   try {
     m->modifyAccount(c);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testModifyInstitution()
 {
   testAddInstitution();
   MyMoneyInstitution i = m->institution("I000001");
 
   m->d_func()->m_dirty = false;
   i.setName("New inst name");
   try {
     m->modifyInstitution(i);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     i = m->institution("I000001");
     QCOMPARE(i.name(), QLatin1String("New inst name"));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   // try to modify an institution that does not exist
   MyMoneyInstitution f("Unknown ID", i);
   try {
     m->modifyInstitution(f);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testReparentAccount()
 {
   // this one adds some accounts to the database
   MyMoneyAccount ex1;
   ex1.setAccountType(Account::Type::Expense);
   MyMoneyAccount ex2;
   ex2.setAccountType(Account::Type::Expense);
   MyMoneyAccount ex3;
   ex3.setAccountType(Account::Type::Expense);
   MyMoneyAccount ex4;
   ex4.setAccountType(Account::Type::Expense);
   MyMoneyAccount in;
   in.setAccountType(Account::Type::Income);
   MyMoneyAccount ch;
   ch.setAccountType(Account::Type::Checkings);
 
   ex1.setName("Sales Tax");
   ex2.setName("Sales Tax 16%");
   ex3.setName("Sales Tax 7%");
   ex4.setName("Grosseries");
 
   in.setName("Salary");
   ch.setName("My checkings account");
 
   try {
     m->addAccount(ex1);
     m->addAccount(ex2);
     m->addAccount(ex3);
     m->addAccount(ex4);
     m->addAccount(in);
     m->addAccount(ch);
 
     QCOMPARE(ex1.id(), QLatin1String("A000001"));
     QCOMPARE(ex2.id(), QLatin1String("A000002"));
     QCOMPARE(ex3.id(), QLatin1String("A000003"));
     QCOMPARE(ex4.id(), QLatin1String("A000004"));
     QCOMPARE(in.id(), QLatin1String("A000005"));
     QCOMPARE(ch.id(), QLatin1String("A000006"));
 
     MyMoneyAccount parent = m->expense();
 
     m->addAccount(parent, ex1);
     m->addAccount(ex1, ex2);
     m->addAccount(parent, ex3);
     m->addAccount(parent, ex4);
 
     parent = m->income();
     m->addAccount(parent, in);
 
     parent = m->asset();
     m->addAccount(parent, ch);
 
     QCOMPARE(m->expense().accountCount(), 3);
     QCOMPARE(m->account(ex1.id()).accountCount(), 1);
     QCOMPARE(ex3.parentAccountId(), stdAccNames[stdAccExpense]);
 
     m->reparentAccount(ex3, ex1);
     QCOMPARE(m->expense().accountCount(), 2);
     QCOMPARE(m->account(ex1.id()).accountCount(), 2);
     QCOMPARE(ex3.parentAccountId(), ex1.id());
   } catch (const MyMoneyException &e) {
-    std::cout << std::endl << qPrintable(e.what()) << std::endl;
+    std::cout << std::endl << e.what() << std::endl;
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testAddTransactions()
 {
   testReparentAccount();
 
   MyMoneyAccount ch;
   MyMoneyTransaction t1, t2;
   MyMoneySplit s;
 
   try {
     // I made some money, great
     s.setAccountId("A000006"); // Checkings
     s.setShares(MyMoneyMoney(100000, 100));
     s.setValue(MyMoneyMoney(100000, 100));
     QVERIFY(s.id().isEmpty());
     t1.addSplit(s);
 
     s.d_func()->setId(QString()); // enable re-usage of split variable
     s.setAccountId("A000005"); // Salary
     s.setShares(MyMoneyMoney(-100000, 100));
     s.setValue(MyMoneyMoney(-100000, 100));
     QVERIFY(s.id().isEmpty());
     t1.addSplit(s);
 
     t1.setPostDate(QDate(2002, 5, 10));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   m->d_func()->m_dirty = false;
   try {
     m->addTransaction(t1);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(t1.id(), QLatin1String("T000000000000000001"));
     QCOMPARE(t1.splitCount(), 2u);
     QCOMPARE(m->transactionCount(QString()), 1u);
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   try {
     // I spent some money, not so great
     s.d_func()->setId(QString()); // enable re-usage of split variable
     s.setAccountId("A000004"); // Grosseries
     s.setShares(MyMoneyMoney(10000, 100));
     s.setValue(MyMoneyMoney(10000, 100));
     QVERIFY(s.id().isEmpty());
     t2.addSplit(s);
 
     s.d_func()->setId(QString()); // enable re-usage of split variable
     s.setAccountId("A000002"); // 16% sales tax
     s.setShares(MyMoneyMoney(1200, 100));
     s.setValue(MyMoneyMoney(1200, 100));
     QVERIFY(s.id().isEmpty());
     t2.addSplit(s);
 
     s.d_func()->setId(QString()); // enable re-usage of split variable
     s.setAccountId("A000003"); // 7% sales tax
     s.setShares(MyMoneyMoney(400, 100));
     s.setValue(MyMoneyMoney(400, 100));
     QVERIFY(s.id().isEmpty());
     t2.addSplit(s);
 
     s.d_func()->setId(QString()); // enable re-usage of split variable
     s.setAccountId("A000006"); // Checkings account
     s.setShares(MyMoneyMoney(-11600, 100));
     s.setValue(MyMoneyMoney(-11600, 100));
     QVERIFY(s.id().isEmpty());
     t2.addSplit(s);
 
     t2.setPostDate(QDate(2002, 5, 9));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
   m->d_func()->m_dirty = false;
   try {
     m->addTransaction(t2);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(t2.id(), QLatin1String("T000000000000000002"));
     QCOMPARE(t2.splitCount(), 4u);
     QCOMPARE(m->transactionCount(QString()), 2u);
 
     QMap<QString, QString>::ConstIterator it_k;
     QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
     it_k = m->d_func()->m_transactionKeys.begin();
     it_t = m->d_func()->m_transactionList.begin();
 
     QCOMPARE((*it_k), QLatin1String("2002-05-10-T000000000000000001"));
     QCOMPARE((*it_t).id(), QLatin1String("T000000000000000002"));
     ++it_k;
     ++it_t;
     QCOMPARE((*it_k), QLatin1String("2002-05-09-T000000000000000002"));
     QCOMPARE((*it_t).id(), QLatin1String("T000000000000000001"));
     ++it_k;
     ++it_t;
     QCOMPARE(it_k, m->d_func()->m_transactionKeys.end());
     QCOMPARE(it_t, m->d_func()->m_transactionList.end());
 
     ch = m->account("A000006");
 
     // check that the account's transaction list is updated
     QList<MyMoneyTransaction> list;
     MyMoneyTransactionFilter filter("A000006");
     list = m->transactionList(filter);
     QCOMPARE(list.size(), 2);
 
     QList<MyMoneyTransaction>::ConstIterator it;
     it = list.constBegin();
     QCOMPARE((*it).id(), QLatin1String("T000000000000000002"));
     ++it;
     QCOMPARE((*it).id(), QLatin1String("T000000000000000001"));
     ++it;
     QCOMPARE(it, list.constEnd());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyStorageMgrTest::testTransactionCount()
 {
   testAddTransactions();
   QCOMPARE(m->transactionCount("A000001"), 0u);
   QCOMPARE(m->transactionCount("A000002"), 1u);
   QCOMPARE(m->transactionCount("A000003"), 1u);
   QCOMPARE(m->transactionCount("A000004"), 1u);
   QCOMPARE(m->transactionCount("A000005"), 1u);
   QCOMPARE(m->transactionCount("A000006"), 2u);
 }
 
 void MyMoneyStorageMgrTest::testBalance()
 {
   testAddTransactions();
 
   QVERIFY(m->balance("A000001", QDate()).isZero());
   QCOMPARE(m->balance("A000002", QDate()),  MyMoneyMoney(1200, 100));
   QCOMPARE(m->balance("A000003", QDate()),  MyMoneyMoney(400, 100));
   QCOMPARE(m->totalBalance("A000001", QDate()),  MyMoneyMoney(1600, 100));
   QCOMPARE(m->balance("A000006", QDate(2002, 5, 9)),  MyMoneyMoney(-11600, 100));
   QCOMPARE(m->balance("A000005", QDate(2002, 5, 10)),  MyMoneyMoney(-100000, 100));
   QCOMPARE(m->balance("A000006", QDate(2002, 5, 10)),  MyMoneyMoney(88400, 100));
 }
 
 void MyMoneyStorageMgrTest::testModifyTransaction()
 {
   testAddTransactions();
 
   MyMoneyTransaction t = m->transaction("T000000000000000002");
   MyMoneySplit s;
   MyMoneyAccount ch;
 
   // just modify simple stuff (splits)
   QCOMPARE(t.splitCount(), 4u);
 
   s = t.splits()[0];
   s.setShares(MyMoneyMoney(11000, 100));
   s.setValue(MyMoneyMoney(11000, 100));
   t.modifySplit(s);
 
   QCOMPARE(t.splitCount(), 4u);
   s = t.splits()[3];
   s.setShares(MyMoneyMoney(-12600, 100));
   s.setValue(MyMoneyMoney(-12600, 100));
   t.modifySplit(s);
 
   try {
     QCOMPARE(m->balance("A000004", QDate()),  MyMoneyMoney(10000, 100));
     QCOMPARE(m->balance("A000006", QDate()),  MyMoneyMoney(100000 - 11600, 100));
     QCOMPARE(m->totalBalance("A000001", QDate()),  MyMoneyMoney(1600, 100));
     m->modifyTransaction(t);
     QCOMPARE(m->balance("A000004", QDate()),  MyMoneyMoney(11000, 100));
     QCOMPARE(m->balance("A000006", QDate()),  MyMoneyMoney(100000 - 12600, 100));
     QCOMPARE(m->totalBalance("A000001", QDate()),  MyMoneyMoney(1600, 100));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   // now modify the date
   t.setPostDate(QDate(2002, 5, 11));
   try {
     m->modifyTransaction(t);
     QCOMPARE(m->balance("A000004", QDate()),  MyMoneyMoney(11000, 100));
     QCOMPARE(m->balance("A000006", QDate()),  MyMoneyMoney(100000 - 12600, 100));
     QCOMPARE(m->totalBalance("A000001", QDate()),  MyMoneyMoney(1600, 100));
 
     QMap<QString, QString>::ConstIterator it_k;
     QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
     it_k = m->d_func()->m_transactionKeys.begin();
     it_t = m->d_func()->m_transactionList.begin();
     QCOMPARE((*it_k), QLatin1String("2002-05-10-T000000000000000001"));
     QCOMPARE((*it_t).id(), QLatin1String("T000000000000000001"));
     ++it_k;
     ++it_t;
     QCOMPARE((*it_k), QLatin1String("2002-05-11-T000000000000000002"));
     QCOMPARE((*it_t).id(), QLatin1String("T000000000000000002"));
     ++it_k;
     ++it_t;
     QCOMPARE(it_k, m->d_func()->m_transactionKeys.end());
     QCOMPARE(it_t, m->d_func()->m_transactionList.end());
 
     ch = m->account("A000006");
 
     // check that the account's transaction list is updated
     QList<MyMoneyTransaction> list;
     MyMoneyTransactionFilter filter("A000006");
     list = m->transactionList(filter);
     QCOMPARE(list.size(), 2);
 
     QList<MyMoneyTransaction>::ConstIterator it;
     it = list.constBegin();
     QCOMPARE((*it).id(), QLatin1String("T000000000000000001"));
     ++it;
     QCOMPARE((*it).id(), QLatin1String("T000000000000000002"));
     ++it;
     QCOMPARE(it, list.constEnd());
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 
 void MyMoneyStorageMgrTest::testRemoveUnusedAccount()
 {
   testAccount2Institution();
 
   MyMoneyAccount a = m->account("A000001");
   MyMoneyInstitution i = m->institution("I000001");
 
   m->d_func()->m_dirty = false;
   // make sure, we cannot remove the standard account groups
   try {
     m->removeAccount(m->liability());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   try {
     m->removeAccount(m->asset());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   try {
     m->removeAccount(m->expense());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   try {
     m->removeAccount(m->income());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   // try to remove the account still attached to the institution
   try {
     m->removeAccount(a);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   // now really remove an account
 
   try {
     QCOMPARE(i.accountCount(), 0u);
     QCOMPARE(m->accountCount(), 7u);
 
     a.setInstitutionId(QString());
     m->modifyAccount(a);
     m->removeAccount(a);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->accountCount(), 6u);
     QCOMPARE(m->dirty(), true);
     i = m->institution("I000001");
     QCOMPARE(i.accountCount(), 0u);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testRemoveUsedAccount()
 {
   testAddTransactions();
 
   MyMoneyAccount a = m->account("A000006");
 
   try {
     m->removeAccount(a);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testRemoveInstitution()
 {
   testModifyInstitution();
   testReparentAccount();
 
   MyMoneyInstitution i;
   MyMoneyAccount a;
 
   // assign the checkings account to the institution
   try {
     i = m->institution("I000001");
     a = m->account("A000006");
     a.setInstitutionId(i.id());
     m->modifyAccount(a);
     QCOMPARE(i.accountCount(), 0u);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
   // now remove the institution and see if the account survived ;-)
   try {
     m->removeInstitution(i);
     a.setInstitutionId(QString());
     m->modifyAccount(a);
     m->commitTransaction();
     m->startTransaction();
     a = m->account("A000006");
     QCOMPARE(m->dirty(), true);
     QVERIFY(a.institutionId().isEmpty());
     QCOMPARE(m->institutionCount(), 0u);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testRemoveTransaction()
 {
   testAddTransactions();
 
   MyMoneyTransaction t = m->transaction("T000000000000000002");
 
   m->d_func()->m_dirty = false;
   try {
     m->removeTransaction(t);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->transactionCount(QString()), 1u);
     /* removed with MyMoneyAccount::Transaction
       QCOMPARE(m->account("A000006").transactionCount(QString()), 1);
     */
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testTransactionList()
 {
   testAddTransactions();
 
   QList<MyMoneyTransaction> list;
   MyMoneyTransactionFilter filter("A000006");
   list = m->transactionList(filter);
   QCOMPARE(list.count(), 2);
   QCOMPARE(list.at(0).id(), QLatin1String("T000000000000000002"));
   QCOMPARE(list.at(1).id(), QLatin1String("T000000000000000001"));
 
   filter.clear();
   filter.addAccount(QString("A000003"));
   list = m->transactionList(filter);
   QCOMPARE(list.count(), 1);
   QCOMPARE(list.at(0).id(), QLatin1String("T000000000000000002"));
 
   filter.clear();
   list = m->transactionList(filter);
   QCOMPARE(list.count(), 2);
   QCOMPARE(list.at(0).id(), QLatin1String("T000000000000000002"));
   QCOMPARE(list.at(1).id(), QLatin1String("T000000000000000001"));
 }
 
 void MyMoneyStorageMgrTest::testAddPayee()
 {
   MyMoneyPayee p;
 
   p.setName("THB");
   m->d_func()->m_dirty = false;
   try {
     QCOMPARE(m->d_func()->m_nextPayeeID, 0ul);
     m->addPayee(p);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->d_func()->m_nextPayeeID, 1ul);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
 }
 
 void MyMoneyStorageMgrTest::testSetAccountName()
 {
   try {
     m->setAccountName(stdAccNames[stdAccLiability], "Verbindlichkeiten");
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   try {
     m->setAccountName(stdAccNames[stdAccAsset], QString("Vermögen"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   try {
     m->setAccountName(stdAccNames[stdAccExpense], "Ausgaben");
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   try {
     m->setAccountName(stdAccNames[stdAccIncome], "Einnahmen");
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   QCOMPARE(m->liability().name(), QLatin1String("Verbindlichkeiten"));
   QCOMPARE(m->asset().name(), QString("Vermögen"));
   QCOMPARE(m->expense().name(), QLatin1String("Ausgaben"));
   QCOMPARE(m->income().name(), QLatin1String("Einnahmen"));
 
   try {
     m->setAccountName("A000001", "New account name");
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testModifyPayee()
 {
   MyMoneyPayee p;
 
   testAddPayee();
 
   p = m->payee("P000001");
   p.setName("New name");
   m->d_func()->m_dirty = false;
   try {
     m->modifyPayee(p);
     m->commitTransaction();
     m->startTransaction();
     p = m->payee("P000001");
     QCOMPARE(p.name(), QLatin1String("New name"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testRemovePayee()
 {
   testAddPayee();
   m->d_func()->m_dirty = false;
 
   // check that we can remove an unreferenced payee
   MyMoneyPayee p = m->payee("P000001");
   try {
     QCOMPARE(m->d_func()->m_payeeList.count(), 1);
     m->removePayee(p);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_payeeList.count(), 0);
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   // add transaction
   testAddTransactions();
 
   MyMoneyTransaction tr = m->transaction("T000000000000000001");
   MyMoneySplit sp;
   sp = tr.splits()[0];
   sp.setPayeeId("P000001");
   tr.modifySplit(sp);
 
   // check that we cannot add a transaction referencing
   // an unknown payee
   try {
     m->modifyTransaction(tr);
     QFAIL("Expected exception");
   } catch (const MyMoneyException &) {
   }
 
   m->d_func()->m_nextPayeeID = 0;  // reset here, so that the
   // testAddPayee will not fail
   testAddPayee();
 
   // check that it works when the payee exists
   try {
     m->modifyTransaction(tr);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
 
   // now check, that we cannot remove the payee
   try {
     m->removePayee(p);
     QFAIL("Expected exception");
   } catch (const MyMoneyException &) {
   }
   QCOMPARE(m->d_func()->m_payeeList.count(), 1);
 }
 
 void MyMoneyStorageMgrTest::testAddTag()
 {
   MyMoneyTag ta;
 
   ta.setName("THB");
   m->d_func()->m_dirty = false;
   try {
     QCOMPARE(m->d_func()->m_nextTagID, 0ul);
     m->addTag(ta);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->d_func()->m_nextTagID, 1ul);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testModifyTag()
 {
   MyMoneyTag ta;
 
   testAddTag();
 
   ta = m->tag("G000001");
   ta.setName("New name");
   m->d_func()->m_dirty = false;
   try {
     m->modifyTag(ta);
     m->commitTransaction();
     m->startTransaction();
     ta = m->tag("G000001");
     QCOMPARE(ta.name(), QLatin1String("New name"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testRemoveTag()
 {
   testAddTag();
   m->d_func()->m_dirty = false;
 
   // check that we can remove an unreferenced tag
   MyMoneyTag ta = m->tag("G000001");
   try {
     QCOMPARE(m->d_func()->m_tagList.count(), 1);
     m->removeTag(ta);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_tagList.count(), 0);
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   // add transaction
   testAddTransactions();
 
   MyMoneyTransaction tr = m->transaction("T000000000000000001");
   MyMoneySplit sp;
   sp = tr.splits()[0];
   QList<QString> tagIdList;
   tagIdList << "G000001";
   sp.setTagIdList(tagIdList);
   tr.modifySplit(sp);
 
   // check that we cannot add a transaction referencing
   // an unknown tag
   try {
     m->modifyTransaction(tr);
     QFAIL("Expected exception");
   } catch (const MyMoneyException &) {
   }
 
   m->d_func()->m_nextTagID = 0;  // reset here, so that the
   // testAddTag will not fail
   testAddTag();
 
   // check that it works when the tag exists
   try {
     m->modifyTransaction(tr);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
 
   // now check, that we cannot remove the tag
   try {
     m->removeTag(ta);
     QFAIL("Expected exception");
   } catch (const MyMoneyException &) {
   }
   QCOMPARE(m->d_func()->m_tagList.count(), 1);
 }
 
 void MyMoneyStorageMgrTest::testRemoveAccountFromTree()
 {
   MyMoneyAccount a, b, c;
   a.setName("Acc A");
   b.setName("Acc B");
   c.setName("Acc C");
 
   // build a tree A -> B -> C, remove B and see if A -> C
   // remains in the storag manager
 
   try {
     m->addAccount(a);
     m->addAccount(b);
     m->addAccount(c);
     m->reparentAccount(b, a);
     m->reparentAccount(c, b);
 
     QCOMPARE(a.accountList().count(), 1);
     QCOMPARE(m->account(a.accountList()[0]).name(), QLatin1String("Acc B"));
 
     QCOMPARE(b.accountList().count(), 1);
     QCOMPARE(m->account(b.accountList()[0]).name(), QLatin1String("Acc C"));
 
     QCOMPARE(c.accountList().count(), 0);
 
     m->removeAccount(b);
 
     // reload account info from titutionIDtorage
     a = m->account(a.id());
     c = m->account(c.id());
 
     try {
       b = m->account(b.id());
       QFAIL("Exception expected");
     } catch (const MyMoneyException &) {
     }
     QCOMPARE(a.accountList().count(), 1);
     QCOMPARE(m->account(a.accountList()[0]).name(), QLatin1String("Acc C"));
 
     QCOMPARE(c.accountList().count(), 0);
 
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyStorageMgrTest::testPayeeName()
 {
   testAddPayee();
 
   MyMoneyPayee p;
   QString name("THB");
 
   // OK case
   try {
     p = m->payeeByName(name);
     QCOMPARE(p.name(), QLatin1String("THB"));
     QCOMPARE(p.id(), QLatin1String("P000001"));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // Not OK case
   name = "Thb";
   try {
     p = m->payeeByName(name);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testTagName()
 {
   testAddTag();
 
   MyMoneyTag ta;
   QString name("THB");
 
   // OK case
   try {
     ta = m->tagByName(name);
     QCOMPARE(ta.name(), QLatin1String("THB"));
     QCOMPARE(ta.id(), QLatin1String("G000001"));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // Not OK case
   name = "Thb";
   try {
     ta = m->tagByName(name);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 // disabled because of no real world use case
 //void MyMoneyStorageMgrTest::testAssignment()
 //{
 //  testAddTransactions();
 
 //  MyMoneyPayee user;
 //  user.setName("Thomas");
 //  m->setUser(user);
 
 //  MyMoneyStorageMgr test = *m;
 //  testEquality(&test);
 //}
 
 void MyMoneyStorageMgrTest::testEquality(const MyMoneyStorageMgr *t)
 {
   QCOMPARE(m->user().name(), t->user().name());
   QCOMPARE(m->user().address(), t->user().address());
   QCOMPARE(m->user().city(), t->user().city());
   QCOMPARE(m->user().state(), t->user().state());
   QCOMPARE(m->user().postcode(), t->user().postcode());
   QCOMPARE(m->user().telephone(), t->user().telephone());
   QCOMPARE(m->user().email(), t->user().email());
   QCOMPARE(m->d_func()->m_nextInstitutionID, t->d_func()->m_nextInstitutionID);
   QCOMPARE(m->d_func()->m_nextAccountID, t->d_func()->m_nextAccountID);
   QCOMPARE(m->d_func()->m_nextTransactionID, t->d_func()->m_nextTransactionID);
   QCOMPARE(m->d_func()->m_nextPayeeID, t->d_func()->m_nextPayeeID);
   QCOMPARE(m->d_func()->m_nextTagID, t->d_func()->m_nextTagID);
   QCOMPARE(m->d_func()->m_nextScheduleID, t->d_func()->m_nextScheduleID);
   QCOMPARE(m->dirty(), t->dirty());
   QCOMPARE(m->creationDate(), t->creationDate());
   QCOMPARE(m->lastModificationDate(), t->lastModificationDate());
 
   /*
    * make sure, that the keys and values are the same
    * on the left and the right side
    */
   QCOMPARE(m->d_func()->m_payeeList.keys(), t->d_func()->m_payeeList.keys());
   QCOMPARE(m->d_func()->m_payeeList.values(), t->d_func()->m_payeeList.values());
   QCOMPARE(m->d_func()->m_tagList.keys(), t->d_func()->m_tagList.keys());
   QCOMPARE(m->d_func()->m_tagList.values(), t->d_func()->m_tagList.values());
   QCOMPARE(m->d_func()->m_transactionKeys.keys(), t->d_func()->m_transactionKeys.keys());
   QCOMPARE(m->d_func()->m_transactionKeys.values(), t->d_func()->m_transactionKeys.values());
   QCOMPARE(m->d_func()->m_institutionList.keys(), t->d_func()->m_institutionList.keys());
   QCOMPARE(m->d_func()->m_institutionList.values(), t->d_func()->m_institutionList.values());
   QCOMPARE(m->d_func()->m_accountList.keys(), t->d_func()->m_accountList.keys());
   QCOMPARE(m->d_func()->m_accountList.values(), t->d_func()->m_accountList.values());
   QCOMPARE(m->d_func()->m_transactionList.keys(), t->d_func()->m_transactionList.keys());
   QCOMPARE(m->d_func()->m_transactionList.values(), t->d_func()->m_transactionList.values());
 
 // QCOMPARE(m->d_func()->m_scheduleList.keys(), t->m_scheduleList.keys());
 // QCOMPARE(m->d_func()->m_scheduleList.values(), t->m_scheduleList.values());
 }
 
 // disabled because of no real world use case
 //void MyMoneyStorageMgrTest::testDuplicate()
 //{
 //  const MyMoneyStorageMgr* t;
 
 //  testModifyTransaction();
 
 //  t = m->duplicate();
 //  testEquality(t);
 //  delete t;
 //}
 
 void MyMoneyStorageMgrTest::testAddSchedule()
 {
   /* Note addSchedule() now calls validate as it should
    * so we need an account id.  Later this will
    * be checked to make sure its a valid account id.  The
    * tests currently fail because no splits are defined
    * for the schedules transaction.
   */
 
 
   try {
     QCOMPARE(m->d_func()->m_scheduleList.count(), 0);
     MyMoneyTransaction t1;
     MyMoneySplit s1, s2;
     s1.setAccountId("A000001");
     t1.addSplit(s1);
     s2.setAccountId("A000002");
     t1.addSplit(s2);
     MyMoneyAccount a1("A000001", MyMoneyAccount());
     MyMoneyAccount a2("A000002", MyMoneyAccount());
     m->addAccount(a1);
     m->addAccount(a2);
 
     MyMoneySchedule schedule("Sched-Name",
                              Schedule::Type::Deposit,
                              Schedule::Occurrence::Daily, 1,
                              Schedule::PaymentType::ManualDeposit,
                              QDate(),
                              QDate(),
                              true,
                              false);
     t1.setPostDate(QDate(2003, 7, 10));
     schedule.setTransaction(t1);
     m->addSchedule(schedule);
 
     QCOMPARE(m->d_func()->m_scheduleList.count(), 1);
     QCOMPARE(schedule.id(), QLatin1String("SCH000001"));
     QCOMPARE(m->d_func()->m_scheduleList["SCH000001"].id(), QLatin1String("SCH000001"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   try {
     MyMoneySchedule schedule("Sched-Name",
                              Schedule::Type::Deposit,
                              Schedule::Occurrence::Daily, 1,
                              Schedule::PaymentType::ManualDeposit,
                              QDate(),
                              QDate(),
                              true,
                              false);
     m->addSchedule(schedule);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testSchedule()
 {
   testAddSchedule();
   MyMoneySchedule sched;
 
   sched = m->schedule("SCH000001");
   QCOMPARE(sched.name(), QLatin1String("Sched-Name"));
   QCOMPARE(sched.id(), QLatin1String("SCH000001"));
 
   try {
     m->schedule("SCH000002");
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyStorageMgrTest::testModifySchedule()
 {
   testAddSchedule();
   MyMoneySchedule sched;
 
   sched = m->schedule("SCH000001");
   sched.d_func()->setId("SCH000002");
   try {
     m->modifySchedule(sched);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   sched = m->schedule("SCH000001");
   sched.setName("New Sched-Name");
   try {
     m->modifySchedule(sched);
     QCOMPARE(m->d_func()->m_scheduleList.count(), 1);
     QCOMPARE(m->d_func()->m_scheduleList["SCH000001"].name(), QLatin1String("New Sched-Name"));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
 }
 
 void MyMoneyStorageMgrTest::testRemoveSchedule()
 {
   testAddSchedule();
   m->commitTransaction();
   m->startTransaction();
   MyMoneySchedule sched;
 
   sched = m->schedule("SCH000001");
   sched.d_func()->setId("SCH000002");
   try {
     m->removeSchedule(sched);
     m->commitTransaction();
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
     m->rollbackTransaction();
   }
   m->startTransaction();
 
   sched = m->schedule("SCH000001");
   try {
     m->removeSchedule(sched);
     m->commitTransaction();
     QCOMPARE(m->d_func()->m_scheduleList.count(), 0);
 
   } catch (const MyMoneyException &) {
     m->rollbackTransaction();
     QFAIL("Unexpected exception");
   }
   m->startTransaction();
 }
 
 void MyMoneyStorageMgrTest::testScheduleList()
 {
   QDate testDate = QDate::currentDate();
   QDate notOverdue = testDate.addDays(2);
   QDate overdue = testDate.addDays(-2);
 
 
   MyMoneyTransaction t1;
   MyMoneySplit s1, s2;
   s1.setAccountId("A000001");
   t1.addSplit(s1);
   s2.setAccountId("A000002");
   t1.addSplit(s2);
   MyMoneyAccount a1("A000001", MyMoneyAccount());
   MyMoneyAccount a2("A000002", MyMoneyAccount());
   m->addAccount(a1);
   m->addAccount(a2);
   MyMoneySchedule schedule1("Schedule 1",
                             Schedule::Type::Bill,
                             Schedule::Occurrence::Once, 1,
                             Schedule::PaymentType::DirectDebit,
                             QDate(),
                             QDate(),
                             false,
                             false);
   t1.setPostDate(notOverdue);
   schedule1.setTransaction(t1);
   schedule1.setLastPayment(notOverdue);
 
   MyMoneyTransaction t2;
   MyMoneySplit s3, s4;
   s3.setAccountId("A000001");
   t2.addSplit(s3);
   s4.setAccountId("A000003");
   t2.addSplit(s4);
   MyMoneyAccount a3("A000003", MyMoneyAccount());
   m->addAccount(a3);
   MyMoneySchedule schedule2("Schedule 2",
                             Schedule::Type::Deposit,
                             Schedule::Occurrence::Daily, 1,
                             Schedule::PaymentType::DirectDeposit,
                             QDate(),
                             QDate(),
                             false,
                             false);
   t2.setPostDate(notOverdue.addDays(1));
   schedule2.setTransaction(t2);
   schedule2.setLastPayment(notOverdue.addDays(1));
 
   MyMoneyTransaction t3;
   MyMoneySplit s5, s6;
   s5.setAccountId("A000005");
   t3.addSplit(s5);
   s6.setAccountId("A000006");
   t3.addSplit(s6);
   MyMoneyAccount a5("A000005", MyMoneyAccount());
   MyMoneyAccount a6("A000006", MyMoneyAccount());
   MyMoneyAccount a7("A000007", MyMoneyAccount());
   m->addAccount(a5);
   m->addAccount(a6);
   m->addAccount(a7);
   MyMoneySchedule schedule3("Schedule 3",
                             Schedule::Type::Transfer,
                             Schedule::Occurrence::Weekly, 1,
                             Schedule::PaymentType::Other,
                             QDate(),
                             QDate(),
                             false,
                             false);
   t3.setPostDate(notOverdue.addDays(2));
   schedule3.setTransaction(t3);
   schedule3.setLastPayment(notOverdue.addDays(2));
 
   MyMoneyTransaction t4;
   MyMoneySplit s7, s8;
   s7.setAccountId("A000005");
   t4.addSplit(s7);
   s8.setAccountId("A000006");
   t4.addSplit(s8);
   MyMoneySchedule schedule4("Schedule 4",
                             Schedule::Type::Bill,
                             Schedule::Occurrence::Weekly, 1,
                             Schedule::PaymentType::WriteChecque,
                             QDate(),
                             notOverdue.addDays(31),
                             false,
                             false);
   t4.setPostDate(overdue.addDays(-7));
   schedule4.setTransaction(t4);
 
   try {
     m->addSchedule(schedule1);
     m->addSchedule(schedule2);
     m->addSchedule(schedule3);
     m->addSchedule(schedule4);
   } catch (const MyMoneyException &e) {
-    qDebug("Error: %s", qPrintable(e.what()));
+    qDebug("Error: %s", e.what());
     QFAIL("Unexpected exception");
   }
 
   QList<MyMoneySchedule> list;
 
   // no filter
   list = m->scheduleList(QString(), Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 4);
 
   // filter by type
   list = m->scheduleList("", Schedule::Type::Bill, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 2);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 1"));
   QCOMPARE(list[1].name(), QLatin1String("Schedule 4"));
 
   // filter by occurrence
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Daily, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 1);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 2"));
 
   // filter by payment type
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Any,
                          Schedule::PaymentType::DirectDeposit,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 1);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 2"));
 
   // filter by account
   list = m->scheduleList("A01", Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 0);
   list = m->scheduleList("A000001", Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 2);
   list = m->scheduleList("A000002", Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                          QDate(), QDate(), false);
   QCOMPARE(list.count(), 1);
 
   // filter by start date
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Any,
                          Schedule::PaymentType::Any,
                          notOverdue.addDays(31),
                          QDate(), false);
   QCOMPARE(list.count(), 3);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 2"));
   QCOMPARE(list[1].name(), QLatin1String("Schedule 3"));
   QCOMPARE(list[2].name(), QLatin1String("Schedule 4"));
 
   // filter by end date
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Any,
                          Schedule::PaymentType::Any,
                          QDate(),
                          notOverdue.addDays(1),
                          false);
   QCOMPARE(list.count(), 3);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 1"));
   QCOMPARE(list[1].name(), QLatin1String("Schedule 2"));
   QCOMPARE(list[2].name(), QLatin1String("Schedule 4"));
 
   // filter by start and end date
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Any,
                          Schedule::PaymentType::Any,
                          notOverdue.addDays(-1),
                          notOverdue.addDays(1),
                          false);
   QCOMPARE(list.count(), 2);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 1"));
   QCOMPARE(list[1].name(), QLatin1String("Schedule 2"));
 
   // filter by overdue status
   list = m->scheduleList("", Schedule::Type::Any,
                          Schedule::Occurrence::Any,
                          Schedule::PaymentType::Any,
                          QDate(),
                          QDate(),
                          true);
   QCOMPARE(list.count(), 1);
   QCOMPARE(list[0].name(), QLatin1String("Schedule 4"));
 }
 
 void MyMoneyStorageMgrTest::testAddCurrency()
 {
   MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
   QCOMPARE(m->d_func()->m_currencyList.count(), 0);
   m->d_func()->m_dirty = false;
   try {
     m->addCurrency(curr);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_currencyList.count(), 1);
     QCOMPARE(m->d_func()->m_currencyList["EUR"].name(), QLatin1String("Euro"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
   try {
     m->addCurrency(curr);
     QFAIL("Expected exception missing");
   } catch (const MyMoneyException &) {
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), false);
   }
 }
 
 void MyMoneyStorageMgrTest::testModifyCurrency()
 {
   MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
   testAddCurrency();
   m->d_func()->m_dirty = false;
   curr.setName("EURO");
   try {
     m->modifyCurrency(curr);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_currencyList.count(), 1);
     QCOMPARE(m->d_func()->m_currencyList["EUR"].name(), QLatin1String("EURO"));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
 
   MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
   try {
     m->modifyCurrency(unknownCurr);
     QFAIL("Expected exception missing");
   } catch (const MyMoneyException &) {
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), false);
   }
 }
 
 void MyMoneyStorageMgrTest::testRemoveCurrency()
 {
   MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
   testAddCurrency();
   m->d_func()->m_dirty = false;
   try {
     m->removeCurrency(curr);
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->d_func()->m_currencyList.count(), 0);
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   m->d_func()->m_dirty = false;
 
   MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
   try {
     m->removeCurrency(unknownCurr);
     QFAIL("Expected exception missing");
   } catch (const MyMoneyException &) {
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), false);
   }
 }
 
 void MyMoneyStorageMgrTest::testCurrency()
 {
   MyMoneySecurity curr("EUR", "Euro", "?", 100, 100);
   MyMoneySecurity newCurr;
   testAddCurrency();
   m->d_func()->m_dirty = false;
   try {
     newCurr = m->currency("EUR");
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), false);
     QCOMPARE(newCurr.id(), curr.id());
     QCOMPARE(newCurr.name(), curr.name());
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   try {
     m->currency("DEM");
     QFAIL("Expected exception missing");
   } catch (const MyMoneyException &) {
     m->commitTransaction();
     m->startTransaction();
     QCOMPARE(m->dirty(), false);
   }
 }
 
 void MyMoneyStorageMgrTest::testCurrencyList()
 {
   QCOMPARE(m->currencyList().count(), 0);
 
   testAddCurrency();
   QCOMPARE(m->currencyList().count(), 1);
 
   MyMoneySecurity unknownCurr("DEM", "Deutsche Mark", "DM", 100, 100);
   try {
     m->addCurrency(unknownCurr);
     m->d_func()->m_dirty = false;
     QCOMPARE(m->d_func()->m_currencyList.count(), 2);
     QCOMPARE(m->currencyList().count(), 2);
     QCOMPARE(m->dirty(), false);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyStorageMgrTest::testAccountList()
 {
   QList<MyMoneyAccount> accounts;
   m->accountList(accounts);
   QCOMPARE(accounts.count(), 0);
   testAddNewAccount();
   accounts.clear();
   m->accountList(accounts);
   QCOMPARE(accounts.count(), 2);
 
   MyMoneyAccount a = m->account("A000001");
   MyMoneyAccount b = m->account("A000002");
   m->reparentAccount(b, a);
   accounts.clear();
   m->accountList(accounts);
   QCOMPARE(accounts.count(), 2);
 }
 
 void MyMoneyStorageMgrTest::testLoaderFunctions()
 {
   // we don't need the transaction started by setup() here
   m->rollbackTransaction();
 
   // account loader
   QMap<QString, MyMoneyAccount> amap;
   MyMoneyAccount acc("A0000176", MyMoneyAccount());
   amap[acc.id()] = acc;
   m->loadAccounts(amap);
   QCOMPARE(m->d_func()->m_accountList.values(), amap.values());
   QCOMPARE(m->d_func()->m_accountList.keys(), amap.keys());
   QCOMPARE(m->d_func()->m_nextAccountID, 176ul);
 
   // transaction loader
   QMap<QString, MyMoneyTransaction> tmap;
   MyMoneyTransaction t("T000000108", MyMoneyTransaction());
   tmap[t.id()] = t;
   m->loadTransactions(tmap);
   QCOMPARE(m->d_func()->m_transactionList.values(), tmap.values());
   QCOMPARE(m->d_func()->m_transactionList.keys(), tmap.keys());
   QCOMPARE(m->d_func()->m_nextTransactionID, 108ul);
 
   // institution loader
   QMap<QString, MyMoneyInstitution> imap;
   MyMoneyInstitution inst("I000028", MyMoneyInstitution());
   imap[inst.id()] = inst;
   m->loadInstitutions(imap);
   QCOMPARE(m->d_func()->m_institutionList.values(), imap.values());
   QCOMPARE(m->d_func()->m_institutionList.keys(), imap.keys());
   QCOMPARE(m->d_func()->m_nextInstitutionID, 28ul);
 
   // payee loader
   QMap<QString, MyMoneyPayee> pmap;
   MyMoneyPayee p("P1234", MyMoneyPayee());
   pmap[p.id()] = p;
   m->loadPayees(pmap);
   QCOMPARE(m->d_func()->m_payeeList.values(), pmap.values());
   QCOMPARE(m->d_func()->m_payeeList.keys(), pmap.keys());
   QCOMPARE(m->d_func()->m_nextPayeeID, 1234ul);
 
   // tag loader
   QMap<QString, MyMoneyTag> tamap;
   MyMoneyTag ta("G1234", MyMoneyTag());
   tamap[ta.id()] = ta;
   m->loadTags(tamap);
   QCOMPARE(m->d_func()->m_tagList.values(), tamap.values());
   QCOMPARE(m->d_func()->m_tagList.keys(), tamap.keys());
   QCOMPARE(m->d_func()->m_nextTagID, 1234ul);
 
   // security loader
   QMap<QString, MyMoneySecurity> smap;
   MyMoneySecurity s("S54321", MyMoneySecurity());
   smap[s.id()] = s;
   m->loadSecurities(smap);
   QCOMPARE(m->d_func()->m_securitiesList.values(), smap.values());
   QCOMPARE(m->d_func()->m_securitiesList.keys(), smap.keys());
   QCOMPARE(m->d_func()->m_nextSecurityID, 54321ul);
 
   // schedule loader
   QMap<QString, MyMoneySchedule> schmap;
   MyMoneySchedule sch("SCH6789", MyMoneySchedule());
   schmap[sch.id()] = sch;
   m->loadSchedules(schmap);
   QCOMPARE(m->d_func()->m_scheduleList.values(), schmap.values());
   QCOMPARE(m->d_func()->m_scheduleList.keys(), schmap.keys());
   QCOMPARE(m->d_func()->m_nextScheduleID, 6789ul);
 
   // report loader
   QMap<QString, MyMoneyReport> rmap;
   MyMoneyReport r("R1298", MyMoneyReport());
   rmap[r.id()] = r;
   m->loadReports(rmap);
   QCOMPARE(m->d_func()->m_reportList.values(), rmap.values());
   QCOMPARE(m->d_func()->m_reportList.keys(), rmap.keys());
   QCOMPARE(m->d_func()->m_nextReportID, 1298ul);
 
   // budget loader
   QMap<QString, MyMoneyBudget> bmap;
   MyMoneyBudget b("B89765", MyMoneyBudget());
   bmap[b.id()] = b;
   m->loadBudgets(bmap);
   QCOMPARE(m->d_func()->m_budgetList.values(), bmap.values());
   QCOMPARE(m->d_func()->m_budgetList.keys(), bmap.keys());
   QCOMPARE(m->d_func()->m_nextBudgetID, 89765ul);
 
   // restart a transaction so that teardown() is happy
   m->startTransaction();
 }
 
 void MyMoneyStorageMgrTest::testAddOnlineJob()
 {
   // Add a onlineJob
   onlineJob job(new dummyTask());
 
   m->addOnlineJob(job);
   QCOMPARE(job.id(), QString("O000001"));
 
   m->commitTransaction();
   m->startTransaction();
 
   QCOMPARE(m->d_func()->m_nextOnlineJobID, 1ul);
   QCOMPARE(m->dirty(), true);
   QCOMPARE(m->d_func()->m_onlineJobList.count(), 1);
   QVERIFY(! m->d_func()->m_onlineJobList["O000001"].isNull());
 
 }
diff --git a/kmymoney/mymoney/tests/mymoneyexception-test.cpp b/kmymoney/mymoney/tests/mymoneyexception-test.cpp
index 768e36b54..46611e6a0 100644
--- a/kmymoney/mymoney/tests/mymoneyexception-test.cpp
+++ b/kmymoney/mymoney/tests/mymoneyexception-test.cpp
@@ -1,46 +1,38 @@
 
 /***************************************************************************
                           mymoneyexceptiontest.cpp
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : 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 "mymoneyexception-test.h"
 
 #include <QtTest>
 
 QTEST_GUILESS_MAIN(MyMoneyExceptionTest)
 
 void MyMoneyExceptionTest::init()
 {
 }
 
 void MyMoneyExceptionTest::cleanup()
 {
 }
 
 void MyMoneyExceptionTest::testDefaultConstructor()
 {
-  const MyMoneyException &e = MYMONEYEXCEPTION("Message");
-  QVERIFY(e.what() == "Message");
-  QVERIFY(e.line() == __LINE__ - 2);
-  QVERIFY(e.file() == __FILE__);
-}
-
-void MyMoneyExceptionTest::testConstructor()
-{
-  MyMoneyException e("New message", "Joe's file", 1234);
-  QVERIFY(e.what() == "New message");
-  QVERIFY(e.line() == 1234);
-  QVERIFY(e.file() == "Joe's file");
+  const MyMoneyException &e = MYMONEYEXCEPTION_CSTRING("Message");
+  QVERIFY(QString::fromLatin1(e.what()).startsWith("Message"));
+  QVERIFY(QString::fromLatin1(e.what()).contains(QString::number(__LINE__ - 2)));
+  QVERIFY(QString::fromLatin1(e.what()).contains(QString::fromLatin1(__FILE__)));
 }
diff --git a/kmymoney/mymoney/tests/mymoneyexception-test.h b/kmymoney/mymoney/tests/mymoneyexception-test.h
index b9bd077d6..c30f2bb5b 100644
--- a/kmymoney/mymoney/tests/mymoneyexception-test.h
+++ b/kmymoney/mymoney/tests/mymoneyexception-test.h
@@ -1,38 +1,34 @@
 /***************************************************************************
                           mymoneyexceptiontest.h
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : 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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYEXCEPTIONTEST_H
 #define MYMONEYEXCEPTIONTEST_H
 
 #include <QObject>
 
-#include "mymoneyutils.h"
 #include "mymoneyexception.h"
 
 class MyMoneyExceptionTest : public QObject
 {
   Q_OBJECT
 
 private Q_SLOTS:
   void init();
   void cleanup();
 
   void testDefaultConstructor();
-
-  void testConstructor();
-
 };
 #endif
diff --git a/kmymoney/mymoney/tests/mymoneyfile-test.cpp b/kmymoney/mymoney/tests/mymoneyfile-test.cpp
index 0c203d670..799a347d2 100644
--- a/kmymoney/mymoney/tests/mymoneyfile-test.cpp
+++ b/kmymoney/mymoney/tests/mymoneyfile-test.cpp
@@ -1,2836 +1,2836 @@
 /***************************************************************************
                           mymoneyfiletest.cpp
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : 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 "mymoneyfile-test.h"
 #include <iostream>
 
 #include <memory>
 #include <QFile>
 #include <QDataStream>
 #include <QList>
 #include <QtTest>
 
 #include "mymoneystoragemgr_p.h"
 #include "mymoneytestutils.h"
 #include "mymoneymoney.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneysplit.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneyenums.h"
 #include "onlinejob.h"
 
 #include "payeeidentifier/ibanandbic/ibanbic.h"
 #include "payeeidentifier/payeeidentifierloader.h"
 #include "payeeidentifiertyped.h"
 
 #include "mymoneystoragenames.h"
 using namespace MyMoneyStandardAccounts;
 
 QTEST_GUILESS_MAIN(MyMoneyFileTest)
 
 MyMoneyFileTest::MyMoneyFileTest() :
   m(nullptr),
   storage(nullptr)
 {
 }
 
 void MyMoneyFileTest::objectAdded(eMyMoney::File::Object type, const QString& id)
 {
   Q_UNUSED(type);
   m_objectsAdded += id;
 }
 
 void MyMoneyFileTest::objectRemoved(eMyMoney::File::Object type, const QString& id)
 {
   Q_UNUSED(type);
   m_objectsRemoved += id;
 }
 
 void MyMoneyFileTest::objectModified(eMyMoney::File::Object type, const QString& id)
 {
   Q_UNUSED(type);
   m_objectsModified += id;
 }
 
 void MyMoneyFileTest::clearObjectLists()
 {
   m_objectsAdded.clear();
   m_objectsModified.clear();
   m_objectsRemoved.clear();
   m_balanceChanged.clear();
   m_valueChanged.clear();
 }
 
 void MyMoneyFileTest::balanceChanged(const MyMoneyAccount& account)
 {
   m_balanceChanged += account.id();
 }
 
 void MyMoneyFileTest::valueChanged(const MyMoneyAccount& account)
 {
   m_valueChanged += account.id();
 }
 
 // this method will be called once at the beginning of the test
 void MyMoneyFileTest::initTestCase()
 {
   m = MyMoneyFile::instance();
 
   connect(m, &MyMoneyFile::objectAdded, this, &MyMoneyFileTest::objectAdded);
   connect(m, &MyMoneyFile::objectRemoved, this, &MyMoneyFileTest::objectRemoved);
   connect(m, &MyMoneyFile::objectModified, this, &MyMoneyFileTest::objectModified);
   connect(m, &MyMoneyFile::balanceChanged, this, &MyMoneyFileTest::balanceChanged);
   connect(m, &MyMoneyFile::valueChanged, this, &MyMoneyFileTest::valueChanged);
 }
 
 // this method will be called before each testfunction
 void MyMoneyFileTest::init()
 {
   storage = new MyMoneyStorageMgr;
   m->attachStorage(storage);
   clearObjectLists();
 }
 
 // this method will be called after each testfunction
 void MyMoneyFileTest::cleanup()
 {
   m->detachStorage(storage);
   delete storage;
 }
 
 void MyMoneyFileTest::testEmptyConstructor()
 {
   MyMoneyPayee user = m->user();
 
   QCOMPARE(user.name(), QString());
   QCOMPARE(user.address(), QString());
   QCOMPARE(user.city(), QString());
   QCOMPARE(user.state(), QString());
   QCOMPARE(user.postcode(), QString());
   QCOMPARE(user.telephone(), QString());
   QCOMPARE(user.email(), QString());
 
   QCOMPARE(m->institutionCount(), static_cast<unsigned>(0));
   QCOMPARE(m->dirty(), false);
   QCOMPARE(m->accountCount(), static_cast<unsigned>(5));
 }
 
 void MyMoneyFileTest::testAddOneInstitution()
 {
   MyMoneyInstitution institution;
 
   institution.setName("institution1");
   institution.setTown("town");
   institution.setStreet("street");
   institution.setPostcode("postcode");
   institution.setTelephone("telephone");
   institution.setManager("manager");
   institution.setSortcode("sortcode");
 
   // MyMoneyInstitution institution_file("", institution);
   MyMoneyInstitution institution_id("I000002", institution);
   MyMoneyInstitution institution_noname(institution);
   institution_noname.setName(QString());
 
   QString id;
 
   QCOMPARE(m->institutionCount(), static_cast<unsigned>(0));
   storage->d_func()->m_dirty = false;
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     m->addInstitution(institution);
     ft.commit();
     QCOMPARE(institution.id(), QLatin1String("I000001"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
     QCOMPARE(m->dirty(), true);
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(m_objectsAdded[0], QLatin1String("I000001"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   clearObjectLists();
   ft.restart();
   try {
     m->addInstitution(institution_id);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     ft.commit();
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
   }
 
   ft.restart();
   try {
     m->addInstitution(institution_noname);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     ft.commit();
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
   }
   QCOMPARE(m_objectsRemoved.count(), 0);
   QCOMPARE(m_objectsAdded.count(), 0);
   QCOMPARE(m_objectsModified.count(), 0);
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 0);
 }
 
 void MyMoneyFileTest::testAddTwoInstitutions()
 {
   testAddOneInstitution();
   MyMoneyInstitution institution;
   institution.setName("institution2");
   institution.setTown("town");
   institution.setStreet("street");
   institution.setPostcode("postcode");
   institution.setTelephone("telephone");
   institution.setManager("manager");
   institution.setSortcode("sortcode");
 
   QString id;
 
   storage->d_func()->m_dirty = false;
   MyMoneyFileTransaction ft;
   try {
     m->addInstitution(institution);
     ft.commit();
 
     QCOMPARE(institution.id(), QLatin1String("I000002"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
     QCOMPARE(m->dirty(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   storage->d_func()->m_dirty = false;
 
   try {
     institution = m->institution("I000001");
     QCOMPARE(institution.id(), QLatin1String("I000001"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
     QCOMPARE(m->dirty(), false);
 
     institution = m->institution("I000002");
     QCOMPARE(institution.id(), QLatin1String("I000002"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
     QCOMPARE(m->dirty(), false);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyFileTest::testRemoveInstitution()
 {
   testAddTwoInstitutions();
 
   MyMoneyInstitution i;
 
   QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
 
   i = m->institution("I000001");
   QCOMPARE(i.id(), QLatin1String("I000001"));
   QCOMPARE(i.accountCount(), static_cast<unsigned>(0));
 
   clearObjectLists();
 
   storage->d_func()->m_dirty = false;
   MyMoneyFileTransaction ft;
   try {
     m->removeInstitution(i);
     QCOMPARE(m_objectsRemoved.count(), 0);
     ft.commit();
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m_objectsRemoved.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(m_objectsRemoved[0], QLatin1String("I000001"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   storage->d_func()->m_dirty = false;
 
   try {
     m->institution("I000001");
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
     QCOMPARE(m->dirty(), false);
   }
 
   clearObjectLists();
   ft.restart();
   try {
     m->removeInstitution(i);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     ft.commit();
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
     QCOMPARE(m->dirty(), false);
     QCOMPARE(m_objectsRemoved.count(), 0);
   }
 }
 
 void MyMoneyFileTest::testInstitutionRetrieval()
 {
 
   testAddOneInstitution();
 
   storage->d_func()->m_dirty = false;
 
   MyMoneyInstitution institution;
 
   QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
 
   try {
     institution = m->institution("I000001");
     QCOMPARE(institution.id(), QLatin1String("I000001"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   try {
     institution = m->institution("I000002");
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(1));
   }
 
   QCOMPARE(m->dirty(), false);
 }
 
 void MyMoneyFileTest::testInstitutionListRetrieval()
 {
   QList<MyMoneyInstitution> list;
 
   storage->d_func()->m_dirty = false;
   list = m->institutionList();
   QCOMPARE(m->dirty(), false);
   QCOMPARE(list.count(), 0);
 
   testAddTwoInstitutions();
 
   storage->d_func()->m_dirty = false;
   list = m->institutionList();
   QCOMPARE(m->dirty(), false);
   QCOMPARE(list.count(), 2);
 
   QList<MyMoneyInstitution>::ConstIterator it;
   it = list.constBegin();
 
   QVERIFY((*it).name() == "institution1" || (*it).name() == "institution2");
   ++it;
   QVERIFY((*it).name() == "institution2"  || (*it).name() == "institution1");
   ++it;
   QVERIFY(it == list.constEnd());
 }
 
 void MyMoneyFileTest::testInstitutionModify()
 {
   testAddTwoInstitutions();
   MyMoneyInstitution institution;
 
   institution = m->institution("I000001");
   institution.setStreet("new street");
   institution.setTown("new town");
   institution.setPostcode("new postcode");
   institution.setTelephone("new telephone");
   institution.setManager("new manager");
   institution.setName("new name");
   institution.setSortcode("new sortcode");
 
   storage->d_func()->m_dirty = false;
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     m->modifyInstitution(institution);
     ft.commit();
     QCOMPARE(institution.id(), QLatin1String("I000001"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
     QCOMPARE(m->dirty(), true);
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(m_objectsModified[0], QLatin1String("I000001"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   MyMoneyInstitution newInstitution;
   newInstitution = m->institution("I000001");
 
   QCOMPARE(newInstitution.id(), QLatin1String("I000001"));
   QCOMPARE(newInstitution.street(), QLatin1String("new street"));
   QCOMPARE(newInstitution.town(), QLatin1String("new town"));
   QCOMPARE(newInstitution.postcode(), QLatin1String("new postcode"));
   QCOMPARE(newInstitution.telephone(), QLatin1String("new telephone"));
   QCOMPARE(newInstitution.manager(), QLatin1String("new manager"));
   QCOMPARE(newInstitution.name(), QLatin1String("new name"));
   QCOMPARE(newInstitution.sortcode(), QLatin1String("new sortcode"));
 
   storage->d_func()->m_dirty = false;
 
   ft.restart();
   MyMoneyInstitution failInstitution2("I000003", newInstitution);
   try {
     m->modifyInstitution(failInstitution2);
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
     ft.commit();
     QCOMPARE(failInstitution2.id(), QLatin1String("I000003"));
     QCOMPARE(m->institutionCount(), static_cast<unsigned>(2));
     QCOMPARE(m->dirty(), false);
   }
 }
 
 void MyMoneyFileTest::testSetFunctions()
 {
   MyMoneyPayee user = m->user();
 
   QCOMPARE(user.name(), QString());
   QCOMPARE(user.address(), QString());
   QCOMPARE(user.city(), QString());
   QCOMPARE(user.state(), QString());
   QCOMPARE(user.postcode(), QString());
   QCOMPARE(user.telephone(), QString());
   QCOMPARE(user.email(), QString());
 
   MyMoneyFileTransaction ft;
   storage->d_func()->m_dirty = false;
   user.setName("Name");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setAddress("Street");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setCity("Town");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setState("County");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setPostcode("Postcode");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setTelephone("Telephone");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
   user.setEmail("Email");
   m->setUser(user);
   QCOMPARE(m->dirty(), true);
   storage->d_func()->m_dirty = false;
 
   ft.commit();
   user = m->user();
   QCOMPARE(user.name(), QLatin1String("Name"));
   QCOMPARE(user.address(), QLatin1String("Street"));
   QCOMPARE(user.city(), QLatin1String("Town"));
   QCOMPARE(user.state(), QLatin1String("County"));
   QCOMPARE(user.postcode(), QLatin1String("Postcode"));
   QCOMPARE(user.telephone(), QLatin1String("Telephone"));
   QCOMPARE(user.email(), QLatin1String("Email"));
 }
 
 void MyMoneyFileTest::testAddAccounts()
 {
   testAddTwoInstitutions();
   MyMoneyAccount  a, b, c;
   a.setAccountType(eMyMoney::Account::Type::Checkings);
   b.setAccountType(eMyMoney::Account::Type::Checkings);
 
   MyMoneyInstitution institution;
 
   storage->d_func()->m_dirty = false;
 
   QCOMPARE(m->accountCount(), static_cast<unsigned>(5));
 
   institution = m->institution("I000001");
   QCOMPARE(institution.id(), QLatin1String("I000001"));
 
   a.setName("Account1");
   a.setInstitutionId(institution.id());
   a.setCurrencyId("EUR");
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->asset();
     m->addAccount(a, parent);
     ft.commit();
     QCOMPARE(m->accountCount(), static_cast<unsigned>(6));
     QCOMPARE(a.parentAccountId(), QLatin1String("AStd::Asset"));
     QCOMPARE(a.id(), QLatin1String("A000001"));
     QCOMPARE(a.institutionId(), QLatin1String("I000001"));
     QCOMPARE(a.currencyId(), QLatin1String("EUR"));
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->asset().accountList().count(), 1);
     QCOMPARE(m->asset().accountList()[0], QLatin1String("A000001"));
 
     institution = m->institution("I000001");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(1));
     QCOMPARE(institution.accountList()[0], QLatin1String("A000001"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_objectsModified.count(), 2);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsAdded.contains(QLatin1String("A000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // try to add this account again, should not work
   ft.restart();
   try {
     MyMoneyAccount parent = m->asset();
     m->addAccount(a, parent);
     QFAIL("Expecting exception!");
   } catch (const MyMoneyException &) {
     ft.commit();
   }
 
   // check that we can modify the local object and
   // reload it from the file
   a.setName("AccountX");
   a = m->account("A000001");
   QCOMPARE(a.name(), QLatin1String("Account1"));
 
   storage->d_func()->m_dirty = false;
 
   // check if we can get the same info to a different object
   c = m->account("A000001");
   QCOMPARE(c.accountType(), eMyMoney::Account::Type::Checkings);
   QCOMPARE(c.id(), QLatin1String("A000001"));
   QCOMPARE(c.name(), QLatin1String("Account1"));
   QCOMPARE(c.institutionId(), QLatin1String("I000001"));
 
   QCOMPARE(m->dirty(), false);
 
   // add a second account
   institution = m->institution("I000002");
   b.setName("Account2");
   b.setInstitutionId(institution.id());
   b.setCurrencyId("EUR");
   clearObjectLists();
   ft.restart();
   try {
     MyMoneyAccount parent = m->asset();
     m->addAccount(b, parent);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(b.id(), QLatin1String("A000002"));
     QCOMPARE(b.currencyId(), QLatin1String("EUR"));
     QCOMPARE(b.parentAccountId(), QLatin1String("AStd::Asset"));
     QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
 
     institution = m->institution("I000001");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(1));
     QCOMPARE(institution.accountList()[0], QLatin1String("A000001"));
 
     institution = m->institution("I000002");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(1));
     QCOMPARE(institution.accountList()[0], QLatin1String("A000002"));
 
     QCOMPARE(m->asset().accountList().count(), 2);
     QCOMPARE(m->asset().accountList()[0], QLatin1String("A000001"));
     QCOMPARE(m->asset().accountList()[1], QLatin1String("A000002"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_objectsModified.count(), 2);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsAdded.contains(QLatin1String("A000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   MyMoneyAccount p;
 
   p = m->account("A000002");
   QCOMPARE(p.accountType(), eMyMoney::Account::Type::Checkings);
   QCOMPARE(p.id(), QLatin1String("A000002"));
   QCOMPARE(p.name(), QLatin1String("Account2"));
   QCOMPARE(p.institutionId(), QLatin1String("I000002"));
   QCOMPARE(p.currencyId(), QLatin1String("EUR"));
 }
 
 void MyMoneyFileTest::testAddCategories()
 {
   MyMoneyAccount  a, b, c;
   a.setAccountType(eMyMoney::Account::Type::Income);
   a.setOpeningDate(QDate::currentDate());
   b.setAccountType(eMyMoney::Account::Type::Expense);
 
   storage->d_func()->m_dirty = false;
 
   QCOMPARE(m->accountCount(), static_cast<unsigned>(5));
   QCOMPARE(a.openingDate(), QDate::currentDate());
   QVERIFY(!b.openingDate().isValid());
 
   a.setName("Account1");
   a.setCurrencyId("EUR");
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->income();
     m->addAccount(a, parent);
     ft.commit();
     QCOMPARE(m->accountCount(), static_cast<unsigned>(6));
     QCOMPARE(a.parentAccountId(), QLatin1String("AStd::Income"));
     QCOMPARE(a.id(), QLatin1String("A000001"));
     QCOMPARE(a.institutionId(), QString());
     QCOMPARE(a.currencyId(), QLatin1String("EUR"));
     QCOMPARE(a.openingDate(), QDate(1900, 1, 1));
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->income().accountList().count(), 1);
     QCOMPARE(m->income().accountList()[0], QLatin1String("A000001"));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // add a second category, expense this time
   b.setName("Account2");
   b.setCurrencyId("EUR");
   clearObjectLists();
   ft.restart();
   try {
     MyMoneyAccount parent = m->expense();
     m->addAccount(b, parent);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(b.id(), QLatin1String("A000002"));
     QCOMPARE(a.institutionId(), QString());
     QCOMPARE(b.currencyId(), QLatin1String("EUR"));
     QCOMPARE(b.openingDate(), QDate(1900, 1, 1));
     QCOMPARE(b.parentAccountId(), QLatin1String("AStd::Expense"));
     QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
 
     QCOMPARE(m->income().accountList().count(), 1);
     QCOMPARE(m->expense().accountList().count(), 1);
     QCOMPARE(m->income().accountList()[0], QLatin1String("A000001"));
     QCOMPARE(m->expense().accountList()[0], QLatin1String("A000002"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsAdded.contains(QLatin1String("A000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Expense")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testModifyAccount()
 {
   testAddAccounts();
   storage->d_func()->m_dirty = false;
 
   MyMoneyAccount p = m->account("A000001");
   MyMoneyInstitution institution;
 
   QCOMPARE(p.accountType(), eMyMoney::Account::Type::Checkings);
   QCOMPARE(p.name(), QLatin1String("Account1"));
 
   p.setName("New account name");
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     m->modifyAccount(p);
     ft.commit();
 
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
     QCOMPARE(p.accountType(), eMyMoney::Account::Type::Checkings);
     QCOMPARE(p.name(), QLatin1String("New account name"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("A000001")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   storage->d_func()->m_dirty = false;
 
   // try to move account to new institution
   p.setInstitutionId("I000002");
   ft.restart();
   clearObjectLists();
   try {
     m->modifyAccount(p);
     ft.commit();
 
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
     QCOMPARE(p.accountType(), eMyMoney::Account::Type::Checkings);
     QCOMPARE(p.name(), QLatin1String("New account name"));
     QCOMPARE(p.institutionId(), QLatin1String("I000002"));
 
     institution = m->institution("I000001");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(0));
 
     institution = m->institution("I000002");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(2));
     QCOMPARE(institution.accountList()[0], QLatin1String("A000002"));
     QCOMPARE(institution.accountList()[1], QLatin1String("A000001"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 3);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("A000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000002")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   storage->d_func()->m_dirty = false;
 
   // try to change to an account type that is allowed
   p.setAccountType(eMyMoney::Account::Type::Savings);
   ft.restart();
   try {
     m->modifyAccount(p);
     ft.commit();
 
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
     QCOMPARE(p.accountType(), eMyMoney::Account::Type::Savings);
     QCOMPARE(p.name(), QLatin1String("New account name"));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   storage->d_func()->m_dirty = false;
 
   // try to change to an account type that is not allowed
   p.setAccountType(eMyMoney::Account::Type::CreditCard);
   ft.restart();
   try {
     m->modifyAccount(p);
     QFAIL("Expecting exception!");
   } catch (const MyMoneyException &) {
     ft.commit();
   }
   storage->d_func()->m_dirty = false;
 
   // try to fool engine a bit
   p.setParentAccountId("A000001");
   ft.restart();
   try {
     m->modifyAccount(p);
     QFAIL("Expecting exception!");
   } catch (const MyMoneyException &) {
     ft.commit();
   }
 }
 
 void MyMoneyFileTest::testReparentAccount()
 {
   testAddAccounts();
   storage->d_func()->m_dirty = false;
 
   MyMoneyAccount p = m->account("A000001");
   MyMoneyAccount q = m->account("A000002");
   MyMoneyAccount o = m->account(p.parentAccountId());
 
   // make A000001 a child of A000002
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     QVERIFY(p.parentAccountId() != q.id());
     QCOMPARE(o.accountCount(), 2);
     QCOMPARE(q.accountCount(), 0);
     m->reparentAccount(p, q);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(p.parentAccountId(), q.id());
     QCOMPARE(q.accountCount(), 1);
     QCOMPARE(q.id(), QLatin1String("A000002"));
     QCOMPARE(p.id(), QLatin1String("A000001"));
     QCOMPARE(q.accountList()[0], p.id());
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 3);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("A000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("A000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
     o = m->account(o.id());
     QCOMPARE(o.accountCount(), 1);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testRemoveStdAccount(const MyMoneyAccount& acc)
 {
   QString txt("Exception expected while removing account ");
   txt += acc.id();
   MyMoneyFileTransaction ft;
   try {
     m->removeAccount(acc);
     QFAIL(qPrintable(txt));
   } catch (const MyMoneyException &) {
     ft.commit();
   }
 }
 
 void MyMoneyFileTest::testRemoveAccount()
 {
   MyMoneyInstitution institution;
 
   testAddAccounts();
   QCOMPARE(m->accountCount(), static_cast<unsigned>(7));
   storage->d_func()->m_dirty = false;
 
   QString id;
   MyMoneyAccount p = m->account("A000001");
 
   clearObjectLists();
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount q("Ainvalid", p);
     m->removeAccount(q);
     QFAIL("Exception expected!");
   } catch (const MyMoneyException &) {
     ft.commit();
   }
 
   ft.restart();
   try {
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_objectsModified.count(), 0);
 
     m->removeAccount(p);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->accountCount(), static_cast<unsigned>(6));
     institution = m->institution("I000001");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(0));
     QCOMPARE(m->asset().accountList().count(), 1);
 
     QCOMPARE(m_objectsRemoved.count(), 1);
     QCOMPARE(m_objectsModified.count(), 2);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
 
     QVERIFY(m_objectsRemoved.contains(QLatin1String("A000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
     institution = m->institution("I000002");
     QCOMPARE(institution.accountCount(), static_cast<unsigned>(1));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // Check that the standard account-groups cannot be removed
   testRemoveStdAccount(m->liability());
   testRemoveStdAccount(m->asset());
   testRemoveStdAccount(m->expense());
   testRemoveStdAccount(m->income());
 }
 
 void MyMoneyFileTest::testRemoveAccountTree()
 {
   testReparentAccount();
   MyMoneyAccount a = m->account("A000002");
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   // remove the account
   try {
     m->removeAccount(a);
     ft.commit();
 
     QCOMPARE(m_objectsRemoved.count(), 1);
     QCOMPARE(m_objectsModified.count(), 3);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
 
     QVERIFY(m_objectsRemoved.contains(QLatin1String("A000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("A000001")));
     QVERIFY(m_objectsModified.contains(QLatin1String("I000002")));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   QCOMPARE(m->accountCount(), static_cast<unsigned>(6));
 
   // make sure it's gone
   try {
     m->account("A000002");
     QFAIL("Exception expected!");
   } catch (const MyMoneyException &) {
   }
 
   // make sure that children are re-parented to parent account
   try {
     a = m->account("A000001");
     QCOMPARE(a.parentAccountId(), m->asset().id());
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testAccountListRetrieval()
 {
   QList<MyMoneyAccount> list;
 
   storage->d_func()->m_dirty = false;
   m->accountList(list);
   QCOMPARE(m->dirty(), false);
   QCOMPARE(list.count(), 0);
 
   testAddAccounts();
 
   storage->d_func()->m_dirty = false;
   list.clear();
   m->accountList(list);
   QCOMPARE(m->dirty(), false);
   QCOMPARE(list.count(), 2);
 
   QCOMPARE(list[0].accountType(), eMyMoney::Account::Type::Checkings);
   QCOMPARE(list[1].accountType(), eMyMoney::Account::Type::Checkings);
 }
 
 void MyMoneyFileTest::testAddTransaction()
 {
   testAddAccounts();
   MyMoneyTransaction t, p;
 
   MyMoneyAccount exp1;
   exp1.setAccountType(eMyMoney::Account::Type::Expense);
   exp1.setName("Expense1");
   MyMoneyAccount exp2;
   exp2.setAccountType(eMyMoney::Account::Type::Expense);
   exp2.setName("Expense2");
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->expense();
     m->addAccount(exp1, parent);
     m->addAccount(exp2, parent);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // fake the last modified flag to check that the
   // date is updated when we add the transaction
   MyMoneyAccount a = m->account("A000001");
   a.setLastModified(QDate(1, 2, 3));
   ft.restart();
   try {
     m->modifyAccount(a);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   ft.restart();
 
   QCOMPARE(m->accountCount(), static_cast<unsigned>(9));
   a = m->account("A000001");
   QCOMPARE(a.lastModified(), QDate(1, 2, 3));
 
   // construct a transaction and add it to the pool
   t.setPostDate(QDate(2002, 2, 1));
   t.setMemo("Memotext");
 
   MyMoneySplit split1;
   MyMoneySplit split2;
 
   split1.setAccountId("A000001");
   split1.setShares(MyMoneyMoney(-1000, 100));
   split1.setValue(MyMoneyMoney(-1000, 100));
   split2.setAccountId("A000003");
   split2.setValue(MyMoneyMoney(1000, 100));
   split2.setShares(MyMoneyMoney(1000, 100));
   try {
     t.addSplit(split1);
     t.addSplit(split2);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   /*
           // FIXME: we don't have a payee and a number field right now
           // guess we should have a number field per split, don't know
           // about the payee
           t.setMethod(MyMoneyCheckingTransaction::Withdrawal);
           t.setPayee("Thomas Baumgart");
           t.setNumber("1234");
           t.setState(MyMoneyCheckingTransaction::Cleared);
   */
   storage->d_func()->m_dirty = false;
 
   ft.restart();
   clearObjectLists();
   try {
     m->addTransaction(t);
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 2);
     QCOMPARE(m_balanceChanged.count("A000001"), 1);
     QCOMPARE(m_balanceChanged.count("A000003"), 1);
     QCOMPARE(m_valueChanged.count(), 0);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
   ft.restart();
   clearObjectLists();
 
   QCOMPARE(t.id(), QLatin1String("T000000000000000001"));
   QCOMPARE(t.postDate(), QDate(2002, 2, 1));
   QCOMPARE(t.entryDate(), QDate::currentDate());
   QCOMPARE(m->dirty(), true);
 
   // check the balance of the accounts
   a = m->account("A000001");
   QCOMPARE(a.lastModified(), QDate::currentDate());
   QCOMPARE(a.balance(), MyMoneyMoney(-1000, 100));
 
   MyMoneyAccount b = m->account("A000003");
   QCOMPARE(b.lastModified(), QDate::currentDate());
   QCOMPARE(b.balance(), MyMoneyMoney(1000, 100));
 
   storage->d_func()->m_dirty = false;
 
   // locate transaction in MyMoneyFile via id
 
   try {
     p = m->transaction("T000000000000000001");
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(p.splitCount(), static_cast<unsigned>(2));
     QCOMPARE(p.memo(), QLatin1String("Memotext"));
     QCOMPARE(p.splits()[0].accountId(), QLatin1String("A000001"));
     QCOMPARE(p.splits()[1].accountId(), QLatin1String("A000003"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // check if it's in the account(s) as well
 
   try {
     p = m->transaction("A000001", 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(p.id(), QLatin1String("T000000000000000001"));
     QCOMPARE(p.splitCount(), static_cast<unsigned>(2));
     QCOMPARE(p.memo(), QLatin1String("Memotext"));
     QCOMPARE(p.splits()[0].accountId(), QLatin1String("A000001"));
     QCOMPARE(p.splits()[1].accountId(), QLatin1String("A000003"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   try {
     p = m->transaction("A000003", 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QCOMPARE(p.id(), QLatin1String("T000000000000000001"));
     QCOMPARE(p.splitCount(), static_cast<unsigned>(2));
     QCOMPARE(p.memo(), QLatin1String("Memotext"));
     QCOMPARE(p.splits()[0].accountId(), QLatin1String("A000001"));
     QCOMPARE(p.splits()[1].accountId(), QLatin1String("A000003"));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testIsStandardAccount()
 {
   QCOMPARE(m->isStandardAccount(m->liability().id()), true);
   QCOMPARE(m->isStandardAccount(m->asset().id()), true);
   QCOMPARE(m->isStandardAccount(m->expense().id()), true);
   QCOMPARE(m->isStandardAccount(m->income().id()), true);
   QCOMPARE(m->isStandardAccount("A00001"), false);
 }
 
 void MyMoneyFileTest::testHasActiveSplits()
 {
   testAddTransaction();
 
   QCOMPARE(m->hasActiveSplits("A000001"), true);
   QCOMPARE(m->hasActiveSplits("A000002"), false);
 }
 
 void MyMoneyFileTest::testModifyTransactionSimple()
 {
   // this will test that we can modify the basic attributes
   // of a transaction
   testAddTransaction();
 
   MyMoneyTransaction t = m->transaction("T000000000000000001");
   t.setMemo("New Memotext");
   storage->d_func()->m_dirty = false;
 
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     m->modifyTransaction(t);
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 2);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000001")), 1);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000003")), 1);
     QCOMPARE(m_valueChanged.count(), 0);
     t = m->transaction("T000000000000000001");
     QCOMPARE(t.memo(), QLatin1String("New Memotext"));
     QCOMPARE(m->dirty(), true);
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testModifyTransactionNewPostDate()
 {
   // this will test that we can modify the basic attributes
   // of a transaction
   testAddTransaction();
 
   MyMoneyTransaction t = m->transaction("T000000000000000001");
   t.setPostDate(QDate(2004, 2, 1));
   storage->d_func()->m_dirty = false;
 
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     m->modifyTransaction(t);
     ft.commit();
     t = m->transaction("T000000000000000001");
     QCOMPARE(t.postDate(), QDate(2004, 2, 1));
     t = m->transaction("A000001", 0);
     QCOMPARE(t.id(), QLatin1String("T000000000000000001"));
     QCOMPARE(m->dirty(), true);
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 2);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000001")), 1);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000003")), 1);
     QCOMPARE(m_valueChanged.count(), 0);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testModifyTransactionNewAccount()
 {
   // this will test that we can modify the basic attributes
   // of a transaction
   testAddTransaction();
 
   MyMoneyTransaction t = m->transaction("T000000000000000001");
   MyMoneySplit s;
   s = t.splits()[0];
   s.setAccountId("A000002");
   t.modifySplit(s);
 
   storage->d_func()->m_dirty = false;
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     MyMoneyTransactionFilter f1("A000001");
     MyMoneyTransactionFilter f2("A000002");
     MyMoneyTransactionFilter f3("A000003");
     QCOMPARE(m->transactionList(f1).count(), 1);
     QCOMPARE(m->transactionList(f2).count(), 0);
     QCOMPARE(m->transactionList(f3).count(), 1);
 
     m->modifyTransaction(t);
     ft.commit();
     t = m->transaction("T000000000000000001");
     QCOMPARE(t.postDate(), QDate(2002, 2, 1));
     t = m->transaction("A000002", 0);
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->transactionList(f1).count(), 0);
     QCOMPARE(m->transactionList(f2).count(), 1);
     QCOMPARE(m->transactionList(f3).count(), 1);
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 3);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000001")), 1);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000002")), 1);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000003")), 1);
     QCOMPARE(m_valueChanged.count(), 0);
 
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testRemoveTransaction()
 {
   testModifyTransactionNewPostDate();
 
   MyMoneyTransaction t;
   t = m->transaction("T000000000000000001");
 
   storage->d_func()->m_dirty = false;
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     m->removeTransaction(t);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->transactionCount(), static_cast<unsigned>(0));
     MyMoneyTransactionFilter f1("A000001");
     MyMoneyTransactionFilter f2("A000002");
     MyMoneyTransactionFilter f3("A000003");
     QCOMPARE(m->transactionList(f1).count(), 0);
     QCOMPARE(m->transactionList(f2).count(), 0);
     QCOMPARE(m->transactionList(f3).count(), 0);
 
     QCOMPARE(m_objectsRemoved.count(), 1);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 2);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000001")), 1);
     QCOMPARE(m_balanceChanged.count(QLatin1String("A000003")), 1);
     QCOMPARE(m_valueChanged.count(), 0);
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 /*
  * This function is currently not implemented. It's kind of tricky
  * because it modifies a lot of objects in a single call. This might
  * be a problem for the undo/redo stuff. That's why I left it out in
  * the first run. We migh add it, if we need it.
  * /
 void testMoveSplits() {
         testModifyTransactionNewPostDate();
 
         QCOMPARE(m->account("A000001").transactionCount(), 1);
         QCOMPARE(m->account("A000002").transactionCount(), 0);
         QCOMPARE(m->account("A000003").transactionCount(), 1);
 
         try {
                 m->moveSplits("A000001", "A000002");
                 QCOMPARE(m->account("A000001").transactionCount(), 0);
                 QCOMPARE(m->account("A000002").transactionCount(), 1);
                 QCOMPARE(m->account("A000003").transactionCount(), 1);
-        } catch(const MyMoneyException &e) {
+        } catch (const MyMoneyException &e) {
                 QFAIL("Unexpected exception!");
         }
 }
 */
 
 void MyMoneyFileTest::testBalanceTotal()
 {
   testAddTransaction();
   MyMoneyTransaction t;
 
   // construct a transaction and add it to the pool
   t.setPostDate(QDate(2002, 2, 1));
   t.setMemo("Memotext");
 
   MyMoneySplit split1;
   MyMoneySplit split2;
 
   MyMoneyFileTransaction ft;
   try {
     split1.setAccountId("A000002");
     split1.setShares(MyMoneyMoney(-1000, 100));
     split1.setValue(MyMoneyMoney(-1000, 100));
     split2.setAccountId("A000004");
     split2.setValue(MyMoneyMoney(1000, 100));
     split2.setShares(MyMoneyMoney(1000, 100));
     t.addSplit(split1);
     t.addSplit(split2);
     m->addTransaction(t);
     ft.commit();
     ft.restart();
     QCOMPARE(t.id(), QLatin1String("T000000000000000002"));
     QCOMPARE(m->totalBalance("A000001"), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->totalBalance("A000002"), MyMoneyMoney(-1000, 100));
 
     MyMoneyAccount p = m->account("A000001");
     MyMoneyAccount q = m->account("A000002");
     m->reparentAccount(p, q);
     ft.commit();
     // check totalBalance() and balance() with combinations of parameters
     QCOMPARE(m->totalBalance("A000001"), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->totalBalance("A000002"), MyMoneyMoney(-2000, 100));
     QVERIFY(m->totalBalance("A000002", QDate(2002, 1, 15)).isZero());
 
     QCOMPARE(m->balance("A000001"), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->balance("A000002"), MyMoneyMoney(-1000, 100));
     // Date of a transaction
     QCOMPARE(m->balance("A000001", QDate(2002, 2, 1)), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->balance("A000002", QDate(2002, 2, 1)), MyMoneyMoney(-1000, 100));
     // Date after last transaction
     QCOMPARE(m->balance("A000001", QDate(2002, 2, 1)), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->balance("A000002", QDate(2002, 2, 1)), MyMoneyMoney(-1000, 100));
     // Date before first transaction
     QVERIFY(m->balance("A000001", QDate(2002, 1, 15)).isZero());
     QVERIFY(m->balance("A000002", QDate(2002, 1, 15)).isZero());
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // Now check for exceptions
   try {
     // Account not found for balance()
     QVERIFY(m->balance("A000005").isZero());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
   try {
     // Account not found for totalBalance()
     QVERIFY(m->totalBalance("A000005").isZero());
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 
 }
 
 void MyMoneyFileTest::testSetAccountName()
 {
   MyMoneyFileTransaction ft;
   clearObjectLists();
   try {
     m->setAccountName(stdAccNames[stdAccLiability], "Verbindlichkeiten");
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Liability")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   ft.restart();
   clearObjectLists();
   try {
     m->setAccountName(stdAccNames[stdAccAsset], QString::fromUtf8("Vermögen"));
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   ft.restart();
   clearObjectLists();
   try {
     m->setAccountName(stdAccNames[stdAccExpense], "Ausgaben");
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Expense")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   ft.restart();
   clearObjectLists();
   try {
     m->setAccountName(stdAccNames[stdAccIncome], "Einnahmen");
     ft.commit();
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Income")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
   ft.restart();
 
   QCOMPARE(m->liability().name(), QLatin1String("Verbindlichkeiten"));
   QCOMPARE(m->asset().name(), QString::fromUtf8("Vermögen"));
   QCOMPARE(m->expense().name(), QLatin1String("Ausgaben"));
   QCOMPARE(m->income().name(), QLatin1String("Einnahmen"));
 
   try {
     m->setAccountName("A000001", "New account name");
     ft.commit();
     QFAIL("Exception expected");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyFileTest::testAddPayee()
 {
   MyMoneyPayee p;
 
   p.setName("THB");
   QCOMPARE(m->dirty(), false);
   MyMoneyFileTransaction ft;
   try {
     m->addPayee(p);
     ft.commit();
     QCOMPARE(m->dirty(), true);
     QCOMPARE(p.id(), QLatin1String("P000001"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
 
     QVERIFY(m_objectsAdded.contains(QLatin1String("P000001")));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyFileTest::testModifyPayee()
 {
   MyMoneyPayee p;
 
   testAddPayee();
   clearObjectLists();
 
   p = m->payee("P000001");
   p.setName("New name");
   MyMoneyFileTransaction ft;
   try {
     m->modifyPayee(p);
     ft.commit();
     p = m->payee("P000001");
     QCOMPARE(p.name(), QLatin1String("New name"));
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
 
     QVERIFY(m_objectsModified.contains(QLatin1String("P000001")));
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyFileTest::testRemovePayee()
 {
   MyMoneyPayee p;
 
   testAddPayee();
   clearObjectLists();
   QCOMPARE(m->payeeList().count(), 1);
 
   p = m->payee("P000001");
   MyMoneyFileTransaction ft;
   try {
     m->removePayee(p);
     ft.commit();
     QCOMPARE(m->payeeList().count(), 0);
 
     QCOMPARE(m_objectsRemoved.count(), 1);
     QCOMPARE(m_objectsModified.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 0);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
 
     QVERIFY(m_objectsRemoved.contains(QLatin1String("P000001")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 }
 
 void MyMoneyFileTest::testPayeeWithIdentifier()
 {
   MyMoneyPayee p;
   try {
     MyMoneyFileTransaction ft;
     m->addPayee(p);
     ft.commit();
 
     p = m->payee(p.id());
 
     payeeIdentifier ident = payeeIdentifierLoader::instance()->createPayeeIdentifier(payeeIdentifiers::ibanBic::staticPayeeIdentifierIid());
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> iban(ident);
     iban->setIban(QLatin1String("DE82 2007 0024 0066 6446 00"));
 
     ft.restart();
     p.addPayeeIdentifier(iban);
     m->modifyPayee(p);
     ft.commit();
 
     p = m->payee(p.id());
     QCOMPARE(p.payeeIdentifiers().count(), 1);
 
     ident = p.payeeIdentifiers().first();
     try {
       iban = payeeIdentifierTyped<payeeIdentifiers::ibanBic>(ident);
     } catch (...) {
       QFAIL("Unexpected exception");
     }
     QCOMPARE(iban->electronicIban(), QLatin1String("DE82200700240066644600"));
-  } catch (const MyMoneyException& e) {
+  } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testAddTransactionStd()
 {
   testAddAccounts();
   MyMoneyTransaction t, p;
   MyMoneyAccount a;
 
   a = m->account("A000001");
 
   // construct a transaction and add it to the pool
   t.setPostDate(QDate(2002, 2, 1));
   t.setMemo("Memotext");
 
   MyMoneySplit split1;
   MyMoneySplit split2;
 
   split1.setAccountId("A000001");
   split1.setShares(MyMoneyMoney(-1000, 100));
   split1.setValue(MyMoneyMoney(-1000, 100));
   split2.setAccountId(stdAccNames[stdAccExpense]);
   split2.setValue(MyMoneyMoney(1000, 100));
   split2.setShares(MyMoneyMoney(1000, 100));
   try {
     t.addSplit(split1);
     t.addSplit(split2);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   /*
           // FIXME: we don't have a payee and a number field right now
           // guess we should have a number field per split, don't know
           // about the payee
           t.setMethod(MyMoneyCheckingTransaction::Withdrawal);
           t.setPayee("Thomas Baumgart");
           t.setNumber("1234");
           t.setState(MyMoneyCheckingTransaction::Cleared);
   */
   storage->d_func()->m_dirty = false;
 
   MyMoneyFileTransaction ft;
   try {
     m->addTransaction(t);
     ft.commit();
     QFAIL("Missing expected exception!");
   } catch (const MyMoneyException &) {
   }
 
   QCOMPARE(m->dirty(), false);
 }
 
 void MyMoneyFileTest::testAttachStorage()
 {
   MyMoneyStorageMgr *store = new MyMoneyStorageMgr;
   MyMoneyFile *file = new MyMoneyFile;
 
   QCOMPARE(file->storageAttached(), false);
   try {
     file->attachStorage(store);
     QCOMPARE(file->storageAttached(), true);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   try {
     file->attachStorage(store);
     QFAIL("Exception expected!");
   } catch (const MyMoneyException &) {
   }
 
   try {
     file->attachStorage(0);
     QFAIL("Exception expected!");
   } catch (const MyMoneyException &) {
   }
 
   try {
     file->detachStorage(store);
     QCOMPARE(file->storageAttached(), false);
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   delete store;
   delete file;
 }
 
 
 void MyMoneyFileTest::testAccount2Category()
 {
   testReparentAccount();
   QCOMPARE(m->accountToCategory("A000001"), QLatin1String("Account2:Account1"));
   QCOMPARE(m->accountToCategory("A000002"), QLatin1String("Account2"));
 }
 
 void MyMoneyFileTest::testCategory2Account()
 {
   testAddTransaction();
   MyMoneyAccount a = m->account("A000003");
   MyMoneyAccount b = m->account("A000004");
 
   MyMoneyFileTransaction ft;
   try {
     m->reparentAccount(b, a);
     ft.commit();
     QCOMPARE(m->categoryToAccount("Expense1"), QLatin1String("A000003"));
     QCOMPARE(m->categoryToAccount("Expense1:Expense2"), QLatin1String("A000004"));
     QVERIFY(m->categoryToAccount("Acc2").isEmpty());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testAttachedStorage()
 {
   QCOMPARE(m->storageAttached(), true);
   QVERIFY(m->storage() != 0);
   MyMoneyStorageMgr *p = m->storage();
   m->detachStorage(p);
   QCOMPARE(m->storageAttached(), false);
   QCOMPARE(m->storage(), static_cast<MyMoneyStorageMgr*>(0));
   m->attachStorage(p);
   QCOMPARE(m->storageAttached(), true);
   QVERIFY(m->storage() != 0);
 }
 
 void MyMoneyFileTest::testHasAccount()
 {
   testAddAccounts();
 
   MyMoneyAccount a, b;
   a.setAccountType(eMyMoney::Account::Type::Checkings);
   a.setName("Account3");
   b = m->account("A000001");
   MyMoneyFileTransaction ft;
   try {
     m->addAccount(a, b);
     ft.commit();
     QCOMPARE(m->accountCount(), static_cast<unsigned>(8));
     QCOMPARE(a.parentAccountId(), QLatin1String("A000001"));
     QCOMPARE(m->hasAccount("A000001", "Account3"), true);
     QCOMPARE(m->hasAccount("A000001", "Account2"), false);
     QCOMPARE(m->hasAccount("A000002", "Account3"), false);
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testAddEquityAccount()
 {
   MyMoneyAccount i;
   i.setName("Investment");
   i.setAccountType(eMyMoney::Account::Type::Investment);
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->asset();
     m->addAccount(i, parent);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
   // keep a copy for later use
   m_inv = i;
 
   // make sure, that only equity accounts can be children to it
   MyMoneyAccount a;
   a.setName("Testaccount");
   QList<eMyMoney::Account::Type> list;
   list << eMyMoney::Account::Type::Checkings;
   list << eMyMoney::Account::Type::Savings;
   list << eMyMoney::Account::Type::Cash;
   list << eMyMoney::Account::Type::CreditCard;
   list << eMyMoney::Account::Type::Loan;
   list << eMyMoney::Account::Type::CertificateDep;
   list << eMyMoney::Account::Type::Investment;
   list << eMyMoney::Account::Type::MoneyMarket;
   list << eMyMoney::Account::Type::Asset;
   list << eMyMoney::Account::Type::Liability;
   list << eMyMoney::Account::Type::Currency;
   list << eMyMoney::Account::Type::Income;
   list << eMyMoney::Account::Type::Expense;
   list << eMyMoney::Account::Type::AssetLoan;
 
   QList<eMyMoney::Account::Type>::Iterator it;
   for (it = list.begin(); it != list.end(); ++it) {
     a.setAccountType(*it);
     ft.restart();
     try {
       char    msg[100];
       m->addAccount(a, i);
       sprintf(msg, "Can add non-equity type %d to investment", (int)*it);
       QFAIL(msg);
     } catch (const MyMoneyException &) {
       ft.commit();
     }
   }
   ft.restart();
   try {
     a.setName("Teststock");
     a.setAccountType(eMyMoney::Account::Type::Stock);
     m->addAccount(a, i);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testReparentEquity()
 {
   testAddEquityAccount();
   testAddEquityAccount();
   MyMoneyAccount parent;
 
   // check the bad cases
   QList<eMyMoney::Account::Type> list;
   list << eMyMoney::Account::Type::Checkings;
   list << eMyMoney::Account::Type::Savings;
   list << eMyMoney::Account::Type::Cash;
   list << eMyMoney::Account::Type::CertificateDep;
   list << eMyMoney::Account::Type::MoneyMarket;
   list << eMyMoney::Account::Type::Asset;
   list << eMyMoney::Account::Type::AssetLoan;
   list << eMyMoney::Account::Type::Currency;
   parent = m->asset();
   testReparentEquity(list, parent);
 
   list.clear();
   list << eMyMoney::Account::Type::CreditCard;
   list << eMyMoney::Account::Type::Loan;
   list << eMyMoney::Account::Type::Liability;
   parent = m->liability();
   testReparentEquity(list, parent);
 
   list.clear();
   list << eMyMoney::Account::Type::Income;
   parent = m->income();
   testReparentEquity(list, parent);
 
   list.clear();
   list << eMyMoney::Account::Type::Expense;
   parent = m->expense();
   testReparentEquity(list, parent);
 
   // now check the good case
   MyMoneyAccount stock = m->account("A000002");
   MyMoneyAccount inv = m->account(m_inv.id());
   MyMoneyFileTransaction ft;
   try {
     m->reparentAccount(stock, inv);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testReparentEquity(QList<eMyMoney::Account::Type>& list, MyMoneyAccount& parent)
 {
   MyMoneyAccount a;
   MyMoneyAccount stock = m->account("A000002");
 
   QList<eMyMoney::Account::Type>::Iterator it;
   MyMoneyFileTransaction ft;
   for (it = list.begin(); it != list.end(); ++it) {
     a.setName(QString("Testaccount %1").arg((int)*it));
     a.setAccountType(*it);
     try {
       m->addAccount(a, parent);
       char    msg[100];
       m->reparentAccount(stock, a);
       sprintf(msg, "Can reparent stock to non-investment type %d account", (int)*it);
       QFAIL(msg);
     } catch (const MyMoneyException &) {
       ft.commit();
     }
     ft.restart();
   }
 }
 
 void MyMoneyFileTest::testBaseCurrency()
 {
   MyMoneySecurity base("EUR", "Euro", QChar(0x20ac));
   MyMoneySecurity ref;
 
   // make sure, no base currency is set
   try {
     ref = m->baseCurrency();
     QVERIFY(ref.id().isEmpty());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // make sure, we cannot assign an unknown currency
   try {
     m->setBaseCurrency(base);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
   }
 
   MyMoneyFileTransaction ft;
   // add the currency and try again
   try {
     m->addCurrency(base);
     m->setBaseCurrency(base);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
   ft.restart();
 
   // make sure, the base currency is set
   try {
     ref = m->baseCurrency();
     QCOMPARE(ref.id(), QLatin1String("EUR"));
     QCOMPARE(ref.name(), QLatin1String("Euro"));
     QVERIFY(ref.tradingSymbol() == QChar(0x20ac));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // check if it gets reset when attaching a new storage
   m->detachStorage(storage);
 
   MyMoneyStorageMgr* newStorage = new MyMoneyStorageMgr;
   m->attachStorage(newStorage);
 
   ref = m->baseCurrency();
   QVERIFY(ref.id().isEmpty());
 
   m->detachStorage(newStorage);
   delete newStorage;
 
   m->attachStorage(storage);
   ref = m->baseCurrency();
   QCOMPARE(ref.id(), QLatin1String("EUR"));
   QCOMPARE(ref.name(), QLatin1String("Euro"));
   QVERIFY(ref.tradingSymbol() == QChar(0x20ac));
 }
 
 void MyMoneyFileTest::testOpeningBalanceNoBase()
 {
   MyMoneyAccount openingAcc;
   MyMoneySecurity base;
 
   try {
     base = m->baseCurrency();
     openingAcc = m->openingBalanceAccount(base);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
   }
 }
 
 void MyMoneyFileTest::testOpeningBalance()
 {
   MyMoneyAccount openingAcc;
   MyMoneySecurity second("USD", "US Dollar", "$");
   testBaseCurrency();
 
   try {
     openingAcc = m->openingBalanceAccount(m->baseCurrency());
     QCOMPARE(openingAcc.parentAccountId(), m->equity().id());
     QCOMPARE(openingAcc.name(), MyMoneyFile::openingBalancesPrefix());
     QCOMPARE(openingAcc.openingDate(), QDate::currentDate());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // add a second currency
   MyMoneyFileTransaction ft;
   try {
     m->addCurrency(second);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   QString refName = QString("%1 (%2)").arg(MyMoneyFile::openingBalancesPrefix()).arg("USD");
   try {
     openingAcc = m->openingBalanceAccount(second);
     QCOMPARE(openingAcc.parentAccountId(), m->equity().id());
     QCOMPARE(openingAcc.name(), refName);
     QCOMPARE(openingAcc.openingDate(), QDate::currentDate());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testModifyStdAccount()
 {
   QVERIFY(m->asset().currencyId().isEmpty());
   QCOMPARE(m->asset().name(), QLatin1String("Asset"));
   testBaseCurrency();
   QVERIFY(m->asset().currencyId().isEmpty());
   QVERIFY(!m->baseCurrency().id().isEmpty());
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount acc = m->asset();
     acc.setName("Anlagen");
     acc.setCurrencyId(m->baseCurrency().id());
     m->modifyAccount(acc);
     ft.commit();
 
     QCOMPARE(m->asset().name(), QLatin1String("Anlagen"));
     QCOMPARE(m->asset().currencyId(), m->baseCurrency().id());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   ft.restart();
   try {
     MyMoneyAccount acc = m->asset();
     acc.setNumber("Test");
     m->modifyAccount(acc);
     QFAIL("Missing expected exception");
   } catch (const MyMoneyException &) {
     ft.rollback();
   }
 
 }
 
 void MyMoneyFileTest::testAddPrice()
 {
   testAddAccounts();
   testBaseCurrency();
   MyMoneyAccount p;
 
   MyMoneyFileTransaction ft;
   try {
     p = m->account("A000002");
     p.setCurrencyId("RON");
     m->modifyAccount(p);
     ft.commit();
 
     QCOMPARE(m->account("A000002").currencyId(), QLatin1String("RON"));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   clearObjectLists();
   ft.restart();
   MyMoneyPrice price("EUR", "RON", QDate::currentDate(), MyMoneyMoney(4.1), "Test source");
   m->addPrice(price);
   ft.commit();
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 1);
   QCOMPARE(m_valueChanged.count("A000002"), 1);
 
   clearObjectLists();
   ft.restart();
   MyMoneyPrice priceReciprocal("RON", "EUR", QDate::currentDate(), MyMoneyMoney(1 / 4.1), "Test source reciprocal price");
   m->addPrice(priceReciprocal);
   ft.commit();
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 1);
   QCOMPARE(m_valueChanged.count("A000002"), 1);
 }
 
 void MyMoneyFileTest::testRemovePrice()
 {
   testAddPrice();
   clearObjectLists();
   MyMoneyFileTransaction ft;
   MyMoneyPrice price("EUR", "RON", QDate::currentDate(), MyMoneyMoney(4.1), "Test source");
   m->removePrice(price);
   ft.commit();
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 1);
   QCOMPARE(m_valueChanged.count("A000002"), 1);
 }
 
 void MyMoneyFileTest::testGetPrice()
 {
   testAddPrice();
   // the price for the current date is found
   QVERIFY(m->price("EUR", "RON", QDate::currentDate()).isValid());
   // the price for the current date is returned when asking for the next day with exact date set to false
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(1), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate());
   }
   // no price is returned while asking for the next day with exact date set to true
   QVERIFY(!m->price("EUR", "RON", QDate::currentDate().addDays(1), true).isValid());
 
   // no price is returned while asking for the previous day with exact date set to true/false because all prices are newer
   QVERIFY(!m->price("EUR", "RON", QDate::currentDate().addDays(-1), false).isValid());
   QVERIFY(!m->price("EUR", "RON", QDate::currentDate().addDays(-1), true).isValid());
 
   // add two more prices
   MyMoneyFileTransaction ft;
   m->addPrice(MyMoneyPrice("EUR", "RON", QDate::currentDate().addDays(3), MyMoneyMoney(4.1), "Test source"));
   m->addPrice(MyMoneyPrice("EUR", "RON", QDate::currentDate().addDays(5), MyMoneyMoney(4.1), "Test source"));
   ft.commit();
   clearObjectLists();
 
   // extra tests for the exactDate=false behavior
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(2), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate());
   }
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(3), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate().addDays(3));
   }
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(4), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate().addDays(3));
   }
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(5), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate().addDays(5));
   }
   {
     const MyMoneyPrice &price = m->price("EUR", "RON", QDate::currentDate().addDays(6), false);
     QVERIFY(price.isValid() && price.date() == QDate::currentDate().addDays(5));
   }
 }
 
 void MyMoneyFileTest::testAddAccountMissingCurrency()
 {
   testAddTwoInstitutions();
   MyMoneySecurity base("EUR", "Euro", QChar(0x20ac));
   MyMoneyAccount  a;
   a.setAccountType(eMyMoney::Account::Type::Checkings);
 
   MyMoneyInstitution institution;
 
   storage->d_func()->m_dirty = false;
 
   QCOMPARE(m->accountCount(), static_cast<unsigned>(5));
 
   institution = m->institution("I000001");
   QCOMPARE(institution.id(), QLatin1String("I000001"));
 
   a.setName("Account1");
   a.setInstitutionId(institution.id());
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     m->addCurrency(base);
     m->setBaseCurrency(base);
     MyMoneyAccount parent = m->asset();
     m->addAccount(a, parent);
     ft.commit();
     QCOMPARE(m->account("A000001").currencyId(), QLatin1String("EUR"));
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testAddTransactionToClosedAccount()
 {
   QSKIP("Test not implemented yet", SkipAll);
 }
 
 void MyMoneyFileTest::testRemoveTransactionFromClosedAccount()
 {
   QSKIP("Test not implemented yet", SkipAll);
 }
 
 void MyMoneyFileTest::testModifyTransactionInClosedAccount()
 {
   QSKIP("Test not implemented yet", SkipAll);
 }
 
 void MyMoneyFileTest::testStorageId()
 {
   QString id;
 
   // make sure id will be setup if it does not exist
   MyMoneyFileTransaction ft;
   try {
     m->setValue("kmm-id", "");
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   try {
     // check for a new id
     id = m->storageId();
     QVERIFY(!id.isEmpty());
     // check that it is the same if we ask again
     QCOMPARE(id, m->storageId());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
 
 void MyMoneyFileTest::testHasMatchingOnlineBalance_emptyAccountWithoutImportedBalance()
 {
   AddOneAccount();
 
   MyMoneyAccount a = m->account("A000001");
 
   QCOMPARE(m->hasMatchingOnlineBalance(a), false);
 }
 
 void MyMoneyFileTest::testHasMatchingOnlineBalance_emptyAccountWithEqualImportedBalance()
 {
   AddOneAccount();
 
   MyMoneyAccount a = m->account("A000001");
 
   a.setValue("lastImportedTransactionDate", QDate(2011, 12, 1).toString(Qt::ISODate));
   a.setValue("lastStatementBalance", MyMoneyMoney().toString());
 
   MyMoneyFileTransaction ft;
   m->modifyAccount(a);
   ft.commit();
 
   QCOMPARE(m->hasMatchingOnlineBalance(a), true);
 }
 
 void MyMoneyFileTest::testHasMatchingOnlineBalance_emptyAccountWithUnequalImportedBalance()
 {
   AddOneAccount();
 
   MyMoneyAccount a = m->account("A000001");
 
   a.setValue("lastImportedTransactionDate", QDate(2011, 12, 1).toString(Qt::ISODate));
   a.setValue("lastStatementBalance", MyMoneyMoney::ONE.toString());
 
   MyMoneyFileTransaction ft;
   m->modifyAccount(a);
   ft.commit();
 
   QCOMPARE(m->hasMatchingOnlineBalance(a), false);
 }
 
 void MyMoneyFileTest::testHasNewerTransaction_withoutAnyTransaction_afterLastImportedTransaction()
 {
   AddOneAccount();
 
   MyMoneyAccount a = m->account("A000001");
 
   QDate dateOfLastTransactionImport(2011, 12, 1);
 
   // There are no transactions at all:
   QCOMPARE(m->hasNewerTransaction(a.id(), dateOfLastTransactionImport), false);
 }
 
 void MyMoneyFileTest::testHasNewerTransaction_withoutNewerTransaction_afterLastImportedTransaction()
 {
 
   AddOneAccount();
 
   QString accId("A000001");
   QDate dateOfLastTransactionImport(2011, 12, 1);
 
   MyMoneyFileTransaction ft;
   MyMoneyTransaction t;
 
   // construct a transaction at the day of the last transaction import and add it to the pool
   t.setPostDate(dateOfLastTransactionImport);
 
   MyMoneySplit split1;
 
   split1.setAccountId(accId);
   split1.setShares(MyMoneyMoney(-1000, 100));
   split1.setValue(MyMoneyMoney(-1000, 100));
   t.addSplit(split1);
 
   ft.restart();
   m->addTransaction(t);
   ft.commit();
 
   QCOMPARE(m->hasNewerTransaction(accId, dateOfLastTransactionImport), false);
 }
 
 void MyMoneyFileTest::testHasNewerTransaction_withNewerTransaction_afterLastImportedTransaction()
 {
 
   AddOneAccount();
 
   QString accId("A000001");
   QDate dateOfLastTransactionImport(2011, 12, 1);
   QDate dateOfDayAfterLastTransactionImport(dateOfLastTransactionImport.addDays(1));
 
   MyMoneyFileTransaction ft;
   MyMoneyTransaction t;
 
   // construct a transaction a day after the last transaction import and add it to the pool
   t.setPostDate(dateOfDayAfterLastTransactionImport);
 
   MyMoneySplit split1;
 
   split1.setAccountId(accId);
   split1.setShares(MyMoneyMoney(-1000, 100));
   split1.setValue(MyMoneyMoney(-1000, 100));
   t.addSplit(split1);
 
   ft.restart();
   m->addTransaction(t);
   ft.commit();
 
   QCOMPARE(m->hasNewerTransaction(accId, dateOfLastTransactionImport), true);
 }
 
 void MyMoneyFileTest::AddOneAccount()
 {
   QString accountId = "A000001";
   MyMoneyAccount  a;
   a.setAccountType(eMyMoney::Account::Type::Checkings);
 
   storage->d_func()->m_dirty = false;
 
   QCOMPARE(m->accountCount(), static_cast<unsigned>(5));
 
   a.setName("Account1");
   a.setCurrencyId("EUR");
 
   clearObjectLists();
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->asset();
     m->addAccount(a, parent);
     ft.commit();
     QCOMPARE(m->accountCount(), static_cast<unsigned>(6));
     QCOMPARE(a.parentAccountId(), QLatin1String("AStd::Asset"));
     QCOMPARE(a.id(), accountId);
     QCOMPARE(a.currencyId(), QLatin1String("EUR"));
     QCOMPARE(m->dirty(), true);
     QCOMPARE(m->asset().accountList().count(), 1);
     QCOMPARE(m->asset().accountList()[0], accountId);
 
     QCOMPARE(m_objectsRemoved.count(), 0);
     QCOMPARE(m_objectsAdded.count(), 1);
     QCOMPARE(m_objectsModified.count(), 1);
     QCOMPARE(m_balanceChanged.count(), 0);
     QCOMPARE(m_valueChanged.count(), 0);
     QVERIFY(m_objectsAdded.contains(accountId.toLatin1()));
     QVERIFY(m_objectsModified.contains(QLatin1String("AStd::Asset")));
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testCountTransactionsWithSpecificReconciliationState_noTransactions()
 {
   AddOneAccount();
   QString accountId = "A000001";
 
   QCOMPARE(m->countTransactionsWithSpecificReconciliationState(accountId, eMyMoney::TransactionFilter::State::NotReconciled), 0);
 }
 
 void MyMoneyFileTest::testCountTransactionsWithSpecificReconciliationState_transactionWithWantedReconcileState()
 {
   AddOneAccount();
   QString accountId = "A000001";
 
   // construct split & transaction
   MyMoneySplit split;
   split.setAccountId(accountId);
   split.setShares(MyMoneyMoney(-1000, 100));
   split.setValue(MyMoneyMoney(-1000, 100));
 
   MyMoneyTransaction transaction;
   transaction.setPostDate(QDate(2013, 1, 1));
   transaction.addSplit(split);
 
   // add transaction
   MyMoneyFileTransaction ft;
   m->addTransaction(transaction);
   ft.commit();
 
   QCOMPARE(m->countTransactionsWithSpecificReconciliationState(accountId, eMyMoney::TransactionFilter::State::NotReconciled), 1);
 }
 
 void MyMoneyFileTest::testCountTransactionsWithSpecificReconciliationState_transactionWithUnwantedReconcileState()
 {
   AddOneAccount();
   QString accountId = "A000001";
 
   // construct split & transaction
   MyMoneySplit split;
   split.setAccountId(accountId);
   split.setShares(MyMoneyMoney(-1000, 100));
   split.setValue(MyMoneyMoney(-1000, 100));
   split.setReconcileFlag(eMyMoney::Split::State::Reconciled);
 
   MyMoneyTransaction transaction;
   transaction.setPostDate(QDate(2013, 1, 1));
   transaction.addSplit(split);
 
   // add transaction
   MyMoneyFileTransaction ft;
   m->addTransaction(transaction);
   ft.commit();
 
   QCOMPARE(m->countTransactionsWithSpecificReconciliationState(accountId, eMyMoney::TransactionFilter::State::NotReconciled), 0);
 }
 
 void MyMoneyFileTest::testAddOnlineJob()
 {
   QSKIP("Need dummy task for this test", SkipAll);
 #if 0
   // Add a onlineJob
   onlineJob job(new germanOnlineTransfer());
 
   MyMoneyFileTransaction ft;
   m->addOnlineJob(job);
   QCOMPARE(job.id(), QString("O000001"));
   ft.commit();
 
   QCOMPARE(m_objectsRemoved.count(), 0);
   QCOMPARE(m_objectsAdded.count(), 1);
   QCOMPARE(m_objectsModified.count(), 0);
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 0);
 #endif
 }
 
 void MyMoneyFileTest::testGetOnlineJob()
 {
   QSKIP("Need dummy task for this test", SkipAll);
   #if 0
   testAddOnlineJob();
 
   const onlineJob requestedJob = m->getOnlineJob("O000001");
   QVERIFY(!requestedJob.isNull());
   QCOMPARE(requestedJob.id(), QString("O000001"));
   #endif
 }
 
 void MyMoneyFileTest::testRemoveOnlineJob()
 {
   QSKIP("Need dummy task for this test", SkipAll);
 #if 0
   // Add a onlineJob
   onlineJob job(new germanOnlineTransfer());
   onlineJob job2(new germanOnlineTransfer());
   onlineJob job3(new germanOnlineTransfer());
 
 
   MyMoneyFileTransaction ft;
   m->addOnlineJob(job);
   m->addOnlineJob(job2);
   m->addOnlineJob(job3);
   ft.commit();
 
   clearObjectLists();
 
   ft.restart();
   m->removeOnlineJob(job);
   m->removeOnlineJob(job2);
   ft.commit();
 
   QCOMPARE(m_objectsRemoved.count(), 2);
   QCOMPARE(m_objectsAdded.count(), 0);
   QCOMPARE(m_objectsModified.count(), 0);
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 0);
 #endif
 }
 
 void MyMoneyFileTest::testOnlineJobRollback()
 {
   QSKIP("Need dummy task for this test", SkipAll);
 #if 0
   // Add a onlineJob
   onlineJob job(new germanOnlineTransfer());
   onlineJob job2(new germanOnlineTransfer());
   onlineJob job3(new germanOnlineTransfer());
 
   MyMoneyFileTransaction ft;
   m->addOnlineJob(job);
   m->addOnlineJob(job2);
   m->addOnlineJob(job3);
   ft.rollback();
 
   QCOMPARE(m_objectsRemoved.count(), 0);
   QCOMPARE(m_objectsAdded.count(), 0);
   QCOMPARE(m_objectsModified.count(), 0);
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 0);
 #endif
 }
 
 void MyMoneyFileTest::testRemoveLockedOnlineJob()
 {
   QSKIP("Need dummy task for this test", SkipAll);
 #if 0
   // Add a onlineJob
   onlineJob job(new germanOnlineTransfer());
   job.setLock(true);
   QVERIFY(job.isLocked());
 
   MyMoneyFileTransaction ft;
   m->addOnlineJob(job);
   ft.commit();
 
   clearObjectLists();
 
   // Try removing locked transfer
   ft.restart();
   m->removeOnlineJob(job);
   ft.commit();
   QVERIFY2(m_objectsRemoved.count() == 0, "Online Job was locked, removing is not allowed");
   QVERIFY(m_objectsAdded.count() == 0);
   QVERIFY(m_objectsModified.count() == 0);
   QVERIFY(m_balanceChanged.count() == 0);
   QVERIFY(m_valueChanged.count() == 0);
 
 #endif
 }
 
 /** @todo */
 void MyMoneyFileTest::testModifyOnlineJob()
 {
   QSKIP("Need dummy task for this test", SkipAll);
 #if 0
   // Add a onlineJob
   onlineJob job(new germanOnlineTransfer());
   MyMoneyFileTransaction ft;
   m->addOnlineJob(job);
   ft.commit();
 
   clearObjectLists();
 
   // Modify online job
   job.setJobSend();
   ft.restart();
   m->modifyOnlineJob(job);
   ft.commit();
 
   QCOMPARE(m_objectsRemoved.count(), 0);
   QCOMPARE(m_objectsAdded.count(), 0);
   QCOMPARE(m_objectsModified.count(), 1);
   QCOMPARE(m_balanceChanged.count(), 0);
   QCOMPARE(m_valueChanged.count(), 0);
 
   //onlineJob modifiedJob = m->getOnlineJob( job.id() );
   //QCOMPARE(modifiedJob.responsibleAccount(), QString("Std::Assert"));
 #endif
 }
 
 void MyMoneyFileTest::testClearedBalance()
 {
   testAddTransaction();
   MyMoneyTransaction t1;
   MyMoneyTransaction t2;
 
   // construct a transaction and add it to the pool
   t1.setPostDate(QDate(2002, 2, 1));
   t1.setMemo("Memotext");
 
   t2.setPostDate(QDate(2002, 2, 4));
   t2.setMemo("Memotext");
 
   MyMoneySplit split1;
   MyMoneySplit split2;
   MyMoneySplit split3;
   MyMoneySplit split4;
 
   MyMoneyFileTransaction ft;
   try {
     split1.setAccountId("A000002");
     split1.setShares(MyMoneyMoney(-1000, 100));
     split1.setValue(MyMoneyMoney(-1000, 100));
     split1.setReconcileFlag(eMyMoney::Split::State::Cleared);
     split2.setAccountId("A000004");
     split2.setValue(MyMoneyMoney(1000, 100));
     split2.setShares(MyMoneyMoney(1000, 100));
     split2.setReconcileFlag(eMyMoney::Split::State::Cleared);
     t1.addSplit(split1);
     t1.addSplit(split2);
     m->addTransaction(t1);
     ft.commit();
     ft.restart();
     QCOMPARE(t1.id(), QLatin1String("T000000000000000002"));
     split3.setAccountId("A000002");
     split3.setShares(MyMoneyMoney(-2000, 100));
     split3.setValue(MyMoneyMoney(-2000, 100));
     split3.setReconcileFlag(eMyMoney::Split::State::Cleared);
     split4.setAccountId("A000004");
     split4.setValue(MyMoneyMoney(2000, 100));
     split4.setShares(MyMoneyMoney(2000, 100));
     split4.setReconcileFlag(eMyMoney::Split::State::Cleared);
     t2.addSplit(split3);
     t2.addSplit(split4);
     m->addTransaction(t2);
     ft.commit();
     ft.restart();
 
     QCOMPARE(m->balance("A000001", QDate(2002, 2, 4)), MyMoneyMoney(-1000, 100));
     QCOMPARE(m->balance("A000002", QDate(2002, 2, 4)), MyMoneyMoney(-3000, 100));
     // Date of last cleared transaction
     QCOMPARE(m->clearedBalance("A000002", QDate(2002, 2, 1)), MyMoneyMoney(-1000, 100));
 
     // Date of last transaction
     QCOMPARE(m->balance("A000002", QDate(2002, 2, 4)), MyMoneyMoney(-3000, 100));
 
     // Date before first transaction
     QVERIFY(m->clearedBalance("A000002", QDate(2002, 1, 15)).isZero());
 
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testAdjustedValues()
 {
   // create a checking account, an expeense, an investment account and a stock
   AddOneAccount();
 
   MyMoneyAccount exp1;
   exp1.setAccountType(eMyMoney::Account::Type::Expense);
   exp1.setName("Expense1");
   exp1.setCurrencyId("EUR");
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->expense();
     m->addAccount(exp1, parent);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   testAddEquityAccount();
 
   testBaseCurrency();
   MyMoneySecurity stockSecurity(QLatin1String("Blubber"), QLatin1String("TestsockSecurity"), QLatin1String("BLUB"), 1000, 1000, 1000);
   stockSecurity.setTradingCurrency(QLatin1String("BLUB"));
   // add the security
   ft.restart();
   try {
     m->addSecurity(stockSecurity);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   MyMoneyAccount i = m->accountByName("Investment");
   MyMoneyAccount stock;
   ft.restart();
   try {
     stock.setName("Teststock");
     stock.setCurrencyId(stockSecurity.id());
     stock.setAccountType(eMyMoney::Account::Type::Stock);
     m->addAccount(stock, i);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // values taken from real example on https://bugs.kde.org/show_bug.cgi?id=345655
   MyMoneySplit s1, s2, s3;
   s1.setAccountId(QLatin1String("A000001"));
   s1.setShares(MyMoneyMoney(QLatin1String("-99901/1000")));
   s1.setValue(MyMoneyMoney(QLatin1String("-999/10")));
 
   s2.setAccountId(exp1.id());
   s2.setShares(MyMoneyMoney(QLatin1String("-611/250")));
   s2.setValue(MyMoneyMoney(QLatin1String("-61/25")));
 
   s3.setAccountId(stock.id());
   s3.setAction(eMyMoney::Split::InvestmentTransactionType::BuyShares);
   s3.setShares(MyMoneyMoney(QLatin1String("64901/100000")));
   s3.setPrice(MyMoneyMoney(QLatin1String("157689/1000")));
   s3.setValue(MyMoneyMoney(QLatin1String("102340161/1000000")));
 
   MyMoneyTransaction t;
   t.setCommodity(QLatin1String("EUR"));
   t.setPostDate(QDate::currentDate());
   t.addSplit(s1);
   t.addSplit(s2);
   t.addSplit(s3);
 
   // make sure the split sum is not zero
   QVERIFY(!t.splitSum().isZero());
 
   ft.restart();
   try {
     m->addTransaction(t);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   QCOMPARE(t.splitById(s1.id()).shares(), MyMoneyMoney(QLatin1String("-999/10")));
   QCOMPARE(t.splitById(s1.id()).value(), MyMoneyMoney(QLatin1String("-999/10")));
 
   QCOMPARE(t.splitById(s2.id()).shares(), MyMoneyMoney(QLatin1String("-61/25")));
   QCOMPARE(t.splitById(s2.id()).value(), MyMoneyMoney(QLatin1String("-61/25")));
 
   QCOMPARE(t.splitById(s3.id()).shares(), MyMoneyMoney(QLatin1String("649/1000")));
   QCOMPARE(t.splitById(s3.id()).value(), MyMoneyMoney(QLatin1String("10234/100")));
   QCOMPARE(t.splitById(s3.id()).price(), MyMoneyMoney(QLatin1String("157689/1000")));
   QCOMPARE(t.splitSum(), MyMoneyMoney());
 
   // now reset and check if modify also works
   s1.setShares(MyMoneyMoney(QLatin1String("-999/10")));
   s1.setValue(MyMoneyMoney(QLatin1String("-999/10")));
 
   s2.setShares(MyMoneyMoney(QLatin1String("-61/25")));
   s2.setValue(MyMoneyMoney(QLatin1String("-61/25")));
 
   s3.setShares(MyMoneyMoney(QLatin1String("649/1000")));
   s3.setPrice(MyMoneyMoney(QLatin1String("157689/1000")));
   s3.setValue(MyMoneyMoney(QLatin1String("102340161/1000000")));
 
   t.modifySplit(s1);
   t.modifySplit(s2);
   t.modifySplit(s3);
 
   // make sure the split sum is not zero
   QVERIFY(!t.splitSum().isZero());
 
   ft.restart();
   try {
     m->modifyTransaction(t);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // we need to get the transaction from the engine, as modifyTransaction does
   // not return the modified values
   MyMoneyTransaction t2 = m->transaction(t.id());
 
   QCOMPARE(t2.splitById(s3.id()).shares(), MyMoneyMoney(QLatin1String("649/1000")));
   QCOMPARE(t2.splitById(s3.id()).value(), MyMoneyMoney(QLatin1String("10234/100")));
   QCOMPARE(t2.splitById(s3.id()).price(), MyMoneyMoney(QLatin1String("157689/1000")));
   QCOMPARE(t2.splitSum(), MyMoneyMoney());
 }
 
 void MyMoneyFileTest::testVatAssignment()
 {
   MyMoneyAccount acc;
   MyMoneyAccount vat;
   MyMoneyAccount expense;
 
   testAddTransaction();
 
   vat.setName("VAT");
   vat.setCurrencyId("EUR");
   vat.setAccountType(eMyMoney::Account::Type::Expense);
   // make it a VAT account
   vat.setValue(QLatin1String("VatRate"), QLatin1String("20/100"));
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->expense();
     m->addAccount(vat, parent);
     QVERIFY(!vat.id().isEmpty());
     acc = m->account(QLatin1String("A000001"));
     expense = m->account(QLatin1String("A000003"));
     QCOMPARE(acc.name(), QLatin1String("Account1"));
     QCOMPARE(expense.name(), QLatin1String("Expense1"));
     expense.setValue(QLatin1String("VatAccount"), vat.id());
     m->modifyAccount(expense);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // the categories are setup now for gross value entry
   MyMoneyTransaction tr;
   MyMoneySplit sp;
   MyMoneyMoney amount(1707, 100);
 
   // setup the transaction
   sp.setShares(amount);
   sp.setValue(amount);
   sp.setAccountId(acc.id());
   tr.addSplit(sp);
   sp.clearId();
   sp.setShares(-amount);
   sp.setValue(-amount);
   sp.setAccountId(expense.id());
   tr.addSplit(sp);
 
   QCOMPARE(m->addVATSplit(tr, acc, expense, amount), true);
   QCOMPARE(tr.splits().count(), 3);
   QCOMPARE(tr.splitByAccount(acc.id()).shares().toString(), MyMoneyMoney(1707, 100).toString());
   QCOMPARE(tr.splitByAccount(expense.id()).shares().toString(), MyMoneyMoney(-1422, 100).toString());
   QCOMPARE(tr.splitByAccount(vat.id()).shares().toString(), MyMoneyMoney(-285, 100).toString());
   QCOMPARE(tr.splitSum().toString(), MyMoneyMoney().toString());
 
   tr.removeSplits();
   ft.restart();
   try {
     expense.setValue(QLatin1String("VatAmount"), QLatin1String("net"));
     m->modifyAccount(expense);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   // the categories are setup now for net value entry
   amount = MyMoneyMoney(1422, 100);
   sp.clearId();
   sp.setShares(amount);
   sp.setValue(amount);
   sp.setAccountId(acc.id());
   tr.addSplit(sp);
   sp.clearId();
   sp.setShares(-amount);
   sp.setValue(-amount);
   sp.setAccountId(expense.id());
   tr.addSplit(sp);
 
   QCOMPARE(m->addVATSplit(tr, acc, expense, amount), true);
   QCOMPARE(tr.splits().count(), 3);
   QCOMPARE(tr.splitByAccount(acc.id()).shares().toString(), MyMoneyMoney(1706, 100).toString());
   QCOMPARE(tr.splitByAccount(expense.id()).shares().toString(), MyMoneyMoney(-1422, 100).toString());
   QCOMPARE(tr.splitByAccount(vat.id()).shares().toString(), MyMoneyMoney(-284, 100).toString());
   QCOMPARE(tr.splitSum().toString(), MyMoneyMoney().toString());
 }
 
 void MyMoneyFileTest::testEmptyFilter()
 {
   testAddTransaction();
 
   try {
     QList<QPair<MyMoneyTransaction, MyMoneySplit> > tList;
     MyMoneyTransactionFilter filter;
     MyMoneyFile::instance()->transactionList(tList, filter);
     QCOMPARE(tList.count(), 2);
 
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 }
 
 void MyMoneyFileTest::testAddSecurity()
 {
   // create a checking account, an expeense, an investment account and a stock
   AddOneAccount();
 
   MyMoneyAccount exp1;
   exp1.setAccountType(eMyMoney::Account::Type::Expense);
   exp1.setName("Expense1");
   exp1.setCurrencyId("EUR");
 
   MyMoneyFileTransaction ft;
   try {
     MyMoneyAccount parent = m->expense();
     m->addAccount(exp1, parent);
     ft.commit();
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception!");
   }
 
   testAddEquityAccount();
 
   testBaseCurrency();
   MyMoneySecurity stockSecurity(QLatin1String("Blubber"), QLatin1String("TestsockSecurity"), QLatin1String("BLUB"), 1000, 1000, 1000);
   stockSecurity.setTradingCurrency(QLatin1String("BLUB"));
   // add the security
   ft.restart();
   try {
     m->addSecurity(stockSecurity);
     ft.commit();
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // check that we can get it via the security method
   try {
     MyMoneySecurity sec = m->security(stockSecurity.id());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 
   // and also via the currency method
   try {
     MyMoneySecurity sec = m->currency(stockSecurity.id());
   } catch (const MyMoneyException &e) {
     unexpectedException(e);
   }
 }
diff --git a/kmymoney/mymoney/tests/mymoneyforecast-test.cpp b/kmymoney/mymoney/tests/mymoneyforecast-test.cpp
index 3e950c73d..04348459c 100644
--- a/kmymoney/mymoney/tests/mymoneyforecast-test.cpp
+++ b/kmymoney/mymoney/tests/mymoneyforecast-test.cpp
@@ -1,990 +1,990 @@
 /***************************************************************************
                           mymoneyforecasttest.cpp
                           -------------------
     copyright            : (C) 2007 by Alvaro Soliverez
     email                : asoliverez@gmail.com
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyforecast-test.h"
 
 #include <iostream>
 #include <QList>
 #include <QtTest>
 
 #include "mymoneybudget.h"
 
 #include "mymoneyexception.h"
 
 #include "mymoneystoragedump.h"
 #include "mymoneystoragexml.h"
 #include "reportstestcommon.h"
 
 #include "mymoneyinstitution.h"
 #include "mymoneysecurity.h"
 #include "mymoneymoney.h"
 #include "mymoneysplit.h"
 #include "mymoneyschedule.h"
 #include "mymoneypayee.h"
 #include "mymoneyenums.h"
 
 using namespace eMyMoney;
 using namespace test;
 
 QTEST_GUILESS_MAIN(MyMoneyForecastTest)
 
 MyMoneyForecastTest::MyMoneyForecastTest() :
   m(nullptr),
   storage(nullptr),
   file(nullptr)
 {
   try {
     this->moT1 = MyMoneyMoney(57, 1);
     this->moT2 = MyMoneyMoney(63, 1);
     this->moT3 = MyMoneyMoney(84, 1);
     this->moT4 = MyMoneyMoney(62, 1);
     this->moT5 = MyMoneyMoney(104, 1);
-  } catch (const MyMoneyException & e) {
+  } catch (const MyMoneyException &e) {
     qDebug() << e.what();
   }
 }
 
 void MyMoneyForecastTest::init()
 {
 
   //all this has been taken from pivottabletest.cpp, by Thomas Baumgart and Ace Jones
 
   storage = new MyMoneyStorageMgr;
   file = MyMoneyFile::instance();
   file->attachStorage(storage);
 
   MyMoneyFileTransaction ft;
   file->addCurrency(MyMoneySecurity("CAD", "Canadian Dollar",        "C$"));
   file->addCurrency(MyMoneySecurity("USD", "US Dollar",              "$"));
   file->addCurrency(MyMoneySecurity("JPY", "Japanese Yen",           QChar(0x00A5), 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2("Alvaro Soliverez");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount(QString("Checking Account"), Account::Type::Checkings, moCheckingOpen, QDate(2004, 5, 15), acAsset, "USD");
   acCredit = makeAccount(QString("Credit Card"), Account::Type::CreditCard, moCreditOpen, QDate(2004, 7, 15), acLiability, "USD");
   acSolo = makeAccount(QString("Solo"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense, "USD");
   acParent = makeAccount(QString("Parent"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense, "USD");
   acChild = makeAccount(QString("Child"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent, "USD");
   acForeign = makeAccount(QString("Foreign"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense, "USD");
   acInvestment = makeAccount("Investment", Account::Type::Investment, moZero, QDate(2004, 1, 1), acAsset, "USD");
 
   acSecondChild = makeAccount(QString("Second Child"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent, "USD");
   acGrandChild1 = makeAccount(QString("Grand Child 1"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild, "USD");
   acGrandChild2 = makeAccount(QString("Grand Child 2"), Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild, "USD");
 
   //this account added to have an account to test opening date calculations
   acCash = makeAccount(QString("Cash"), Account::Type::Cash, moCreditOpen, QDate::currentDate().addDays(-2), acAsset, "USD");
 
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 
 }
 
 void MyMoneyForecastTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void MyMoneyForecastTest::testEmptyConstructor()
 {
   MyMoneyForecast a;
   MyMoneyAccount b;
 
   QVERIFY(a.forecastBalance(b, QDate::currentDate()).isZero());
   QVERIFY(!a.isForecastAccount(b));
   QVERIFY(a.forecastBalance(b, QDate::currentDate()) == MyMoneyMoney());
   QVERIFY(a.daysToMinimumBalance(b) == -1);
   QVERIFY(a.daysToZeroBalance(b) == -2);
   QVERIFY(a.forecastDays() == 90);
   QVERIFY(a.accountsCycle() == 30);
   QVERIFY(a.forecastCycles() == 3);
   QVERIFY(a.historyStartDate() == QDate::currentDate().addDays(-3*30));
   QVERIFY(a.historyEndDate() == QDate::currentDate().addDays(-1));
   QVERIFY(a.historyDays() == 30 * 3);
 }
 
 
 void MyMoneyForecastTest::testDoForecastInit()
 {
   MyMoneyForecast a;
 
   a.doForecast();
   /*
   //check the illegal argument validation
   try {
     KMyMoneySettings::setForecastDays(-10);
     a.doForecast();
   }
   catch (const MyMoneyException &e)
   {
     QFAIL("Unexpected exception");
   }
   try {
     KMyMoneySettings::setForecastAccountCycle(-20);
       a.doForecast();
     }
     catch (const MyMoneyException &e) {
       QFAIL("Unexpected exception");
   }
   try {
     KMyMoneySettings::setForecastCycles(-10);
     a.doForecast();
   }
   catch (const MyMoneyException &e) {
     QFAIL("Unexpected exception");
   }
 
   try {
     KMyMoneySettings::setForecastAccountCycle(0);
     a.doForecast();
   }
   catch (const MyMoneyException &e) {
     QFAIL("Unexpected exception");
   }
   try {
     KMyMoneySettings::setForecastDays(0);
     KMyMoneySettings::setForecastCycles(0);
     KMyMoneySettings::setForecastAccountCycle(0);
     a.doForecast();
   }
   catch (const MyMoneyException &e) {
     QVERIFY("Unexpected exception");
   }*/
 }
 
 //test that it forecasts correctly with transactions in the period of forecast
 void MyMoneyForecastTest::testDoForecast()
 {
   //set up environment
   MyMoneyForecast a;
 
   MyMoneyAccount a_checking = file->account(acChecking);
   MyMoneyAccount a_credit = file->account(acCredit);
 
   //test empty forecast
   a.doForecast(); //this is just to check nothing goes wrong if forecast is run agains an empty template
 
   //setup some transactions
   TransactionHelper t1(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acChecking, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -(this->moT2), acCredit, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer), this->moT1, acCredit, acChecking);
 
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.setBeginForecastDay(0);
   a.setHistoryMethod(0); //moving average
   a.doForecast();
 
   //checking didn't have balance variations, so the forecast should be equal to the current balance
   MyMoneyMoney b_checking = file->balance(a_checking.id(), QDate::currentDate());
 
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(1)) == b_checking);
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(2)) == b_checking);
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(3)) == b_checking);
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate()) == b_checking);
   //credit had a variation so the forecast should be different for each day
   MyMoneyMoney b_credit = file->balance(a_credit.id(), QDate::currentDate());
 
   QVERIFY(a.forecastBalance(a_credit, 0) == b_credit);
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(1)) == (b_credit + (moT2 - moT1)));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(2)) == (b_credit + ((moT2 - moT1)*2)));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(3)) == b_credit + ((moT2 - moT1)*3));
 
   a.setHistoryMethod(1); //weighted moving average
   a.doForecast();
 
   QVERIFY(a.forecastBalance(a_credit, 0) == b_credit);
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(1)) == (b_credit + (moT2 - moT1)));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(2)) == (b_credit + ((moT2 - moT1)*2)));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(3)) == b_credit + ((moT2 - moT1)*3));
 
   //insert transactions outside the forecast period. The calculation should be the same.
   TransactionHelper t4(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT2, acCredit, acParent);
   TransactionHelper t5(QDate::currentDate().addDays(-10), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT2, acCredit, acParent);
   TransactionHelper t6(QDate::currentDate().addDays(-3), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT2, acCredit, acParent);
 
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.setBeginForecastDay(0);
   a.setHistoryMethod(0); //moving average
   a.doForecast();
   //check forecast
   b_credit = file->balance(a_credit.id(), QDate::currentDate());
   MyMoneyMoney b_credit_1_exp = (b_credit + ((moT2 - moT1)));
   MyMoneyMoney b_credit_2 = a.forecastBalance(a_credit, QDate::currentDate().addDays(2));
   MyMoneyMoney b_credit_2_exp = (b_credit + ((moT2 - moT1) * 2));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate()) == file->balance(a_credit.id(), QDate::currentDate()));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(1)) == b_credit + (moT2 - moT1));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(2)) == b_credit + ((moT2 - moT1)*2));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(3)) == b_credit + ((moT2 - moT1)*3));
 
   //test weighted moving average
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(3);
   a.setBeginForecastDay(0);
   a.setHistoryMethod(1);
   a.doForecast();
 
   QVERIFY(a.forecastBalance(a_credit, 0) == b_credit);
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(1)) == (b_credit + (((moT2 - moT1)*3 + moT2*2 + moT2) / MyMoneyMoney(6, 1))));
 
 }
 
 void MyMoneyForecastTest::testGetForecastAccountList()
 {
   MyMoneyForecast a;
   MyMoneyAccount a_checking = file->account(acChecking);
   MyMoneyAccount a_parent = file->account(acParent);
   QList<MyMoneyAccount> b;
 
   b = a.forecastAccountList();
   //check that it contains asset account, but not expense accounts
   QVERIFY(b.contains(a_checking));
   QVERIFY(!b.contains(a_parent));
 
 }
 
 void MyMoneyForecastTest::testCalculateAccountTrend()
 {
   //set up environment
   TransactionHelper t1(QDate::currentDate().addDays(-3), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT2, acChecking, acSolo);
   MyMoneyAccount a_checking = file->account(acChecking);
 
   //test invalid arguments
 
   try {
     MyMoneyForecast::calculateAccountTrend(a_checking, 0);
   } catch (const MyMoneyException &e) {
-    QVERIFY(e.what().compare("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0") == 0);
+    QVERIFY(QString::fromLatin1(e.what()).startsWith("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0"));
   }
   try {
     MyMoneyForecast::calculateAccountTrend(a_checking, -10);
   } catch (const MyMoneyException &e) {
-    QVERIFY(e.what().compare("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0") == 0);
+    QVERIFY(QString::fromLatin1(e.what()).startsWith("Illegal arguments when calling calculateAccountTrend. trendDays must be higher than 0"));
   }
 
   //test that it calculates correctly
   QVERIFY(MyMoneyForecast::calculateAccountTrend(a_checking , 3) == moT2 / MyMoneyMoney(3, 1));
 
   //test that it works for all kind of accounts
   MyMoneyAccount a_solo = file->account(acSolo);
   MyMoneyMoney soloTrend = MyMoneyForecast::calculateAccountTrend(a_solo, 3);
   MyMoneyMoney soloTrendExp = -moT2 / MyMoneyMoney(3, 1);
   QVERIFY(MyMoneyForecast::calculateAccountTrend(a_solo, 3) == -moT2 / MyMoneyMoney(3, 1));
 
   //test that it does not take into account the transactions of the opening date of the account
   MyMoneyAccount a_cash = file->account(acCash);
   TransactionHelper t2(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), moT2, acCash, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), moT1, acCash, acParent);
   QVERIFY(MyMoneyForecast::calculateAccountTrend(a_cash, 3) == -moT1);
 
 }
 
 void MyMoneyForecastTest::testGetForecastBalance()
 {
   //set up environment
   MyMoneyForecast a;
 
   TransactionHelper t1(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acChecking, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -(this->moT2), acCredit, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer), this->moT1, acCredit, acChecking);
 
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.setHistoryMethod(0);
   a.doForecast();
 
   MyMoneyAccount a_checking = file->account(acChecking);
   MyMoneyAccount a_credit = file->account(acCredit);
 
   //test invalid arguments
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(-1)) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(-10)) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, -1) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, -100) == MyMoneyMoney());
 
   //test a date outside the forecast days
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(4)) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, 4) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, QDate::currentDate().addDays(10)) == MyMoneyMoney());
   QVERIFY(a.forecastBalance(a_checking, 10) == MyMoneyMoney());
 
   //test it returns valid results
   MyMoneyMoney b_credit = file->balance(a_credit.id(), QDate::currentDate());
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate()) == file->balance(a_credit.id(), QDate::currentDate()));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(1)) == b_credit + (moT2 - moT1));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(2)) == b_credit + ((moT2 - moT1)*2));
   QVERIFY(a.forecastBalance(a_credit, QDate::currentDate().addDays(3)) == b_credit + ((moT2 - moT1)*3));
 }
 
 void MyMoneyForecastTest::testIsForecastAccount()
 {
   MyMoneyForecast a;
 
   MyMoneyAccount a_checking = file->account(acChecking);
   MyMoneyAccount a_solo = file->account(acSolo);
   MyMoneyAccount a_investment = file->account(acInvestment);
 
   //test an invalid account
   QVERIFY(a.isForecastAccount(a_solo) == false);
   QVERIFY(a.isForecastAccount(a_investment) == true);
 
   //test a valid account
   QVERIFY(a.isForecastAccount(a_checking) == true);
 
 }
 
 void MyMoneyForecastTest::testDoFutureScheduledForecast()
 {
   //set up future transactions
   MyMoneyForecast a;
 
   MyMoneyAccount a_cash = file->account(acCash);
   TransactionHelper t1(QDate::currentDate().addDays(1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT1, acCash, acParent);
   TransactionHelper t2(QDate::currentDate().addDays(2), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT2, acCash, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(3), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT3, acCash, acParent);
   TransactionHelper t4(QDate::currentDate().addDays(10), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT4, acCash, acParent);
 
   a.setForecastMethod(0);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.doForecast();
 
   MyMoneyMoney b_cash = file->balance(a_cash.id(), QDate::currentDate());
 
   //test valid results
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate()) == b_cash);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(1)) == b_cash + moT1);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(2)) == b_cash + moT1 + moT2);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(3)) == b_cash + moT1 + moT2 + moT3);
 }
 
 void MyMoneyForecastTest::testScheduleForecast()
 {
   //set up schedule environment for testing
   MyMoneyAccount a_cash = file->account(acCash);
   MyMoneyAccount a_parent = file->account(acParent);
 
   MyMoneyFileTransaction ft;
   MyMoneySchedule sch("A Name",
                       Schedule::Type::Bill,
                       Schedule::Occurrence::Weekly, 1,
                       Schedule::PaymentType::DirectDebit,
                       QDate::currentDate().addDays(1),
                       QDate(),
                       true,
                       true);
 
   MyMoneyTransaction t;
   t.setPostDate(QDate::currentDate().addDays(1));
   t.setEntryDate(QDate::currentDate().addDays(1));
   //t.setId("T000000000000000001");
   t.setBankID("BID");
   t.setMemo("Wohnung:Miete");
   t.setCommodity("USD");
   t.setValue("key", "value");
 
   MyMoneySplit s;
   s.setPayeeId("P000001");
   s.setShares(moT2);
   s.setValue(moT2);
   s.setAccountId(a_parent.id());
   s.setBankID("SPID1");
   s.setReconcileFlag(eMyMoney::Split::State::Reconciled);
   t.addSplit(s);
 
   s.setPayeeId("P000001");
   s.setShares(-moT2);
   s.setValue(-moT2);
   s.setAccountId(a_cash.id());
   s.setBankID("SPID2");
   s.setReconcileFlag(eMyMoney::Split::State::Cleared);
   s.clearId();
   t.addSplit(s);
 
   sch.setTransaction(t);
 
   file->addSchedule(sch);
   ft.commit();
 
   MyMoneyFileTransaction ft3;
   MyMoneySchedule sch3("A Name1",
                        Schedule::Type::Bill,
                        Schedule::Occurrence::Weekly, 1,
                        Schedule::PaymentType::DirectDebit,
                        QDate::currentDate().addDays(5),
                        QDate(),
                        true,
                        true);
 
   //sch.setLastPayment(QDate::currentDate());
   //sch.recordPayment(QDate::currentDate().addDays(1));
   //sch.setId("SCH0001");
 
   MyMoneyTransaction t3;
   t3.setPostDate(QDate::currentDate().addDays(5));
   t3.setEntryDate(QDate::currentDate().addDays(5));
   //t.setId("T000000000000000001");
   t3.setBankID("BID");
   t3.setMemo("Wohnung:Miete");
   t3.setCommodity("USD");
   t3.setValue("key", "value");
 
   MyMoneySplit s3;
   s3.setPayeeId("P000001");
   s3.setShares(moT2);
   s3.setValue(moT2);
   s3.setAccountId(a_parent.id());
   s3.setBankID("SPID1");
   s3.setReconcileFlag(eMyMoney::Split::State::Reconciled);
   t3.addSplit(s3);
 
   s3.setPayeeId("P000001");
   s3.setShares(-moT2);
   s3.setValue(-moT2);
   s3.setAccountId(a_cash.id());
   s3.setBankID("SPID2");
   s3.setReconcileFlag(eMyMoney::Split::State::Cleared);
   s3.clearId();
   t3.addSplit(s3);
 
   sch3.setTransaction(t3);
 
   file->addSchedule(sch3);
   ft3.commit();
 
 
   MyMoneyFileTransaction ft2;
   MyMoneySchedule sch2("A Name2",
                        Schedule::Type::Bill,
                        Schedule::Occurrence::Weekly, 1,
                        Schedule::PaymentType::DirectDebit,
                        QDate::currentDate().addDays(2),
                        QDate(),
                        true,
                        true);
 
   //sch.setLastPayment(QDate::currentDate());
   //sch.recordPayment(QDate::currentDate().addDays(1));
   //sch.setId("SCH0001");
 
   MyMoneyTransaction t2;
   t2.setPostDate(QDate::currentDate().addDays(2));
   t2.setEntryDate(QDate::currentDate().addDays(2));
   //t.setId("T000000000000000001");
   t2.setBankID("BID");
   t2.setMemo("Wohnung:Miete");
   t2.setCommodity("USD");
   t2.setValue("key", "value");
 
   MyMoneySplit s2;
   s2.setPayeeId("P000001");
   s2.setShares(moT1);
   s2.setValue(moT1);
   s2.setAccountId(a_parent.id());
   s2.setBankID("SPID1");
   s2.setReconcileFlag(eMyMoney::Split::State::Reconciled);
   t2.addSplit(s2);
 
   s2.setPayeeId("P000001");
   s2.setShares(-moT1);
   s2.setValue(-moT1);
   s2.setAccountId(a_cash.id());
   s2.setBankID("SPID2");
   s2.setReconcileFlag(eMyMoney::Split::State::Cleared);
   s2.clearId();
   t2.addSplit(s2);
 
   sch2.setTransaction(t2);
 
   file->addSchedule(sch2);
 
   ft2.commit();
 
   //run forecast
   MyMoneyForecast a;
   a.setForecastMethod(0);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.doForecast();
 
   //check result for single schedule
   MyMoneyMoney b_cash = file->balance(a_cash.id(), QDate::currentDate());
   MyMoneyMoney b_cash1 = a.forecastBalance(a_cash, QDate::currentDate().addDays(1));
 
   //test valid results
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate()) == b_cash);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(1)) == b_cash - moT2);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(2)) == b_cash - moT2 - moT1);
 }
 
 
 void MyMoneyForecastTest::testDaysToMinimumBalance()
 {
   //setup environment
   MyMoneyForecast a;
 
   MyMoneyAccount a_cash = file->account(acCash);
   MyMoneyAccount a_credit = file->account(acCredit);
   MyMoneyAccount a_parent = file->account(acParent);
   a_cash.setValue("minBalanceAbsolute", "50");
   a_credit.setValue("minBalanceAbsolute", "50");
   TransactionHelper t1(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moT1, acCash, acParent);
   TransactionHelper t2(QDate::currentDate().addDays(2), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), moT2, acCash, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), -moT1, acCredit, acParent);
   TransactionHelper t4(QDate::currentDate().addDays(4), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moT5, acCredit, acParent);
 
   a.setForecastMethod(0);
   a.setForecastDays(3);
   a.setAccountsCycle(1);
   a.setForecastCycles(1);
   a.setBeginForecastDay(0);
   a.doForecast();
 
   //test invalid arguments
   MyMoneyAccount nullAcc;
   QVERIFY(a.daysToMinimumBalance(nullAcc) == -1);
 
   //test when not a forecast account
   QVERIFY(a.daysToMinimumBalance(a_parent) == -1);
 
   //test it warns when inside the forecast period
   QVERIFY(a.daysToMinimumBalance(a_cash) == 2);
 
   //test it does not warn when it will be outside of the forecast period
   QVERIFY(a.daysToMinimumBalance(a_credit) == -1);
 }
 void MyMoneyForecastTest::testDaysToZeroBalance()
 {
   //set up environment
   MyMoneyAccount a_Solo = file->account(acSolo);
   MyMoneyAccount a_Cash = file->account(acCash);
   MyMoneyAccount a_Credit = file->account(acCredit);
 
   //MyMoneyFileTransaction ft;
   TransactionHelper t1(QDate::currentDate().addDays(2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), -moT1, acChecking, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(2), MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer), (moT5), acCash, acCredit);
   TransactionHelper t3(QDate::currentDate().addDays(2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), (moT5*100), acCredit, acParent);
   //ft.commit();
 
   MyMoneyForecast a;
   a.setForecastMethod(0);
   a.setForecastDays(30);
   a.setAccountsCycle(1);
   a.setForecastCycles(3);
   a.doForecast();
 
   //test invalid arguments
   MyMoneyAccount nullAcc;
   try {
     auto days = a.daysToZeroBalance(nullAcc);
     Q_UNUSED(days)
   } catch (const MyMoneyException &) {
     QFAIL("Unexpected exception");
   }
 
   //test when not a forecast account
   MyMoneyAccount a_solo = file->account(acSolo);
   int iSolo = a.daysToZeroBalance(a_Solo);
 
   QVERIFY(iSolo == -2);
 
   //test it warns when inside the forecast period
 
   MyMoneyMoney fCash = a.forecastBalance(a_Cash, QDate::currentDate().addDays(2));
 
   QVERIFY(a.daysToZeroBalance(a_Cash) == 2);
 
   //test it does not warn when it will be outside of the forecast period
 
 }
 
 void MyMoneyForecastTest::testSkipOpeningDate()
 {
   //set up environment
   MyMoneyForecast a;
 
   TransactionHelper t1(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acSolo);
 
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(2);
   a.setForecastCycles(1);
   a.setHistoryMethod(0);
   a.doForecast();
 
   MyMoneyAccount a_cash = file->account(acCash);
 
   //test it has no variation because it skipped the variation of the opening date
   MyMoneyMoney b_cash = file->balance(a_cash.id(), QDate::currentDate());
   QVERIFY(a.skipOpeningDate() == true);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate()) == b_cash);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(1)) == b_cash);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(2)) == b_cash - moT2);
   QVERIFY(a.forecastBalance(a_cash, QDate::currentDate().addDays(3)) == b_cash - moT2);
 }
 
 void MyMoneyForecastTest::testAccountMinimumBalanceDateList()
 {
 
   //set up environment
   MyMoneyForecast a;
 
   TransactionHelper t1(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acSolo);
 
   a.setForecastMethod(1);
   a.setForecastDays(6);
   a.setAccountsCycle(2);
   a.setForecastCycles(3);
   a.setHistoryMethod(0);
   a.setBeginForecastDay(QDate::currentDate().addDays(1).day());
   a.doForecast();
 
   MyMoneyAccount a_cash = file->account(acCash);
 
   //test
   QList<QDate> dateList;
   dateList = a.accountMinimumBalanceDateList(a_cash);
 
   QList<QDate>::iterator it = dateList.begin();
 
   QDate minDate = *it;
 
   QVERIFY(minDate == QDate::currentDate().addDays(2));
   it++;
   minDate = *it;
   QVERIFY(minDate == QDate::currentDate().addDays(4));
   it++;
   minDate = *it;
   QVERIFY(minDate == QDate::currentDate().addDays(6));
 
 }
 
 void MyMoneyForecastTest::testAccountMaximumBalanceDateList()
 {
   //set up environment
   MyMoneyForecast a;
 
   TransactionHelper t1(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acSolo);
 
   a.setForecastMethod(1);
   a.setForecastDays(6);
   a.setAccountsCycle(2);
   a.setForecastCycles(3);
   a.setHistoryMethod(0);
   a.setBeginForecastDay(QDate::currentDate().addDays(1).day());
   a.doForecast();
 
   MyMoneyAccount a_cash = file->account(acCash);
 
   //test
   QList<QDate> dateList;
   dateList = a.accountMaximumBalanceDateList(a_cash);
 
   QList<QDate>::iterator it = dateList.begin();
 
   QDate maxDate = *it;
 
   QVERIFY(maxDate == QDate::currentDate().addDays(1));
   it++;
   maxDate = *it;
   QVERIFY(maxDate == QDate::currentDate().addDays(3));
   it++;
   maxDate = *it;
   QVERIFY(maxDate == QDate::currentDate().addDays(5));
 
 
 }
 
 void MyMoneyForecastTest::testAccountAverageBalance()
 {
   //set up environment
   MyMoneyForecast a;
 
   TransactionHelper t1(QDate::currentDate().addDays(-2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acSolo);
 
   a.setForecastMethod(1);
   a.setForecastDays(3);
   a.setAccountsCycle(2);
   a.setForecastCycles(1);
   a.setBeginForecastDay(0);
   a.doForecast();
 
   MyMoneyAccount a_cash = file->account(acCash);
 
   //test
   MyMoneyMoney b_cash1 = a.forecastBalance(a_cash, QDate::currentDate().addDays(1));
   MyMoneyMoney b_cash2 = a.forecastBalance(a_cash, QDate::currentDate().addDays(2));
   MyMoneyMoney b_cash3 = a.forecastBalance(a_cash, QDate::currentDate().addDays(3));
 
   MyMoneyMoney average = (b_cash1 + b_cash2 + b_cash3) / MyMoneyMoney(3, 1);
 
 
   QVERIFY(a.accountAverageBalance(a_cash) == average);
 }
 
 void MyMoneyForecastTest::testBeginForecastDate()
 {
   //set up environment
   MyMoneyForecast a;
   QDate beginDate;
   int beginDay;
 
   a.setForecastMethod(1);
   a.setForecastDays(90);
   a.setAccountsCycle(14);
   a.setForecastCycles(3);
   a.setBeginForecastDay(0);
   a.doForecast();
 
   //test when using old method without begin day
   QVERIFY(QDate::currentDate() == a.beginForecastDate());
 
   //setup begin to last day of month
   a.setBeginForecastDay(31);
   beginDay = a.beginForecastDay();
   a.doForecast();
 
   //test
   if (QDate::currentDate().day() < beginDay) {
     if (QDate::currentDate().daysInMonth() < beginDay)
       beginDay = QDate::currentDate().daysInMonth();
 
     beginDate = QDate(QDate::currentDate().year(), QDate::currentDate().month(), beginDay);
 
     QVERIFY(beginDate == a.beginForecastDate());
   }
 
   //setup begin day to same date
   a.setBeginForecastDay(QDate::currentDate().day());
   beginDay = a.beginForecastDay();
   a.doForecast();
 
   QVERIFY(QDate::currentDate() == a.beginForecastDate());
 
   //setup to first day of month with small interval
   a.setBeginForecastDay(1);
   a.setAccountsCycle(1);
   beginDay = a.beginForecastDay();
   a.doForecast();
 
   //test
   if (QDate::currentDate() == a.beginForecastDate()) {
     QVERIFY(QDate::currentDate() == a.beginForecastDate());
   } else {
     beginDay = ((((QDate::currentDate().day() - beginDay) / a.accountsCycle()) + 1) * a.accountsCycle()) + beginDay;
     if (beginDay > QDate::currentDate().daysInMonth())
       beginDay = QDate::currentDate().daysInMonth();
     beginDate = QDate(QDate::currentDate().year(), QDate::currentDate().month(), beginDay);
     if (QDate::currentDate().day() == QDate::currentDate().daysInMonth()) {
       std::cout << std::endl << "testBeginForecastDate(): test of first day of month with small interval skipped because it is the last day of month" << std::endl;
     } else {
       QVERIFY(beginDate == a.beginForecastDate());
     }
   }
 
   //setup to test when current date plus cycle equals begin day
   a.setAccountsCycle(14);
   beginDay = QDate::currentDate().addDays(14).day();
   a.setBeginForecastDay(beginDay);
   beginDate = QDate::currentDate().addDays(14);
   a.doForecast();
 
   //test
   QVERIFY(beginDate == a.beginForecastDate());
 
   //setup to test when the begin day will be next month
   a.setBeginForecastDay(1);
   a.setAccountsCycle(40);
   a.doForecast();
 
   beginDate = QDate(QDate::currentDate().addMonths(1).year(), QDate::currentDate().addMonths(1).month(), 1);
 
   //test
   if (QDate::currentDate().day() > 1) {
     QVERIFY(beginDate == a.beginForecastDate());
   } else {
     //test is not valid if today is 1st of month
     std::cout << std::endl << "testBeginForecastDate(): test of first day of month skipped because current day is 1st of month" << std::endl;
   }
 }
 
 void MyMoneyForecastTest::testHistoryDays()
 {
   MyMoneyForecast a;
 
   QVERIFY(a.historyStartDate() == QDate::currentDate().addDays(-a.forecastCycles()*a.accountsCycle()));
   QVERIFY(a.historyEndDate() == QDate::currentDate().addDays(-1));
   QVERIFY(a.historyDays() == a.forecastCycles()*a.accountsCycle());
 
   a.setForecastMethod(1);
   a.setForecastDays(90);
   a.setAccountsCycle(14);
   a.setForecastCycles(3);
   a.setBeginForecastDay(0);
   a.doForecast();
 
   QVERIFY(a.historyStartDate() == QDate::currentDate().addDays(-14*3));
   QVERIFY(a.historyDays() == (14*3));
   QVERIFY(a.historyEndDate() == (QDate::currentDate().addDays(-1)));
 }
 
 void MyMoneyForecastTest::testCreateBudget()
 {
   //set up environment
   MyMoneyForecast a;
   MyMoneyForecast b;
   MyMoneyBudget budget;
 
   TransactionHelper t1(QDate(2005, 1, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t2(QDate(2005, 1, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acParent);
   TransactionHelper t3(QDate(2005, 1, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT3, acCash, acSolo);
   TransactionHelper t4(QDate(2006, 1, 25), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT4, acCash, acParent);
   TransactionHelper t5(QDate(2005, 4, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acCash, acSolo);
   TransactionHelper t6(QDate(2006, 5, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT2, acCash, acParent);
   TransactionHelper t7(QDate(2005, 8, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT3, acCash, acSolo);
   TransactionHelper t8(QDate(2006, 9, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT4, acCash, acParent);
 
   a.setHistoryMethod(0);
   a.setForecastMethod(1);
   a.createBudget(budget, QDate(2005, 1, 1), QDate(2006, 12, 31), QDate(2007, 1, 1), QDate(2007, 12, 31), true);
 
   //test
   MyMoneyAccount a_solo = file->account(acSolo);
   MyMoneyAccount a_parent = file->account(acParent);
 
   //test it has no variation because it skipped the variation of the opening date
   QVERIFY(a.forecastBalance(a_solo, QDate(2007, 1, 1)) == ((moT1 + moT3) / MyMoneyMoney(2, 1)));
   QVERIFY(a.forecastBalance(a_parent, QDate(2007, 1, 1)) == ((moT2 + moT4) / MyMoneyMoney(2, 1)));
   QVERIFY(a.forecastBalance(a_solo, QDate(2007, 4, 1)) == ((moT1) / MyMoneyMoney(2, 1)));
   QVERIFY(a.forecastBalance(a_parent, QDate(2007, 5, 1)) == ((moT2) / MyMoneyMoney(2, 1)));
   QVERIFY(a.forecastBalance(a_solo, QDate(2007, 8, 1)) == ((moT3) / MyMoneyMoney(2, 1)));
   QVERIFY(a.forecastBalance(a_parent, QDate(2007, 9, 1)) == ((moT4) / MyMoneyMoney(2, 1)));
   //test the budget object returned by the method
   QVERIFY(budget.account(a_parent.id()).period(QDate(2007, 9, 1)).amount() == ((moT4) / MyMoneyMoney(2, 1)));
 
   //setup test for a length lower than a year
   b.setForecastMethod(1);
   b.setHistoryMethod(0);
   b.createBudget(budget, QDate(2005, 1, 1), QDate(2005, 6, 30), QDate(2007, 1, 1), QDate(2007, 6, 30), true);
 
   //test
   QVERIFY(b.forecastBalance(a_solo, QDate(2007, 1, 1)) == (moT1 + moT3));
   QVERIFY(b.forecastBalance(a_parent, QDate(2007, 1, 1)) == (moT2));
   QVERIFY(b.forecastBalance(a_solo, QDate(2007, 4, 1)) == (moT1));
   QVERIFY(b.forecastBalance(a_parent, QDate(2007, 5, 1)) == (MyMoneyMoney()));
 
   //set up schedule environment for testing
   MyMoneyAccount a_cash = file->account(acCash);
 
   MyMoneyFileTransaction ft;
   MyMoneySchedule sch("A Name",
                       Schedule::Type::Bill,
                       Schedule::Occurrence::Monthly, 1,
                       Schedule::PaymentType::DirectDebit,
                       QDate::currentDate(),
                       QDate(),
                       true,
                       true);
 
   MyMoneyTransaction t10;
   t10.setPostDate(QDate::currentDate().addMonths(1));
   t10.setEntryDate(QDate::currentDate().addMonths(1));
   //t.setId("T000000000000000001");
   t10.setBankID("BID");
   t10.setMemo("Wohnung:Miete");
   t10.setCommodity("USD");
   t10.setValue("key", "value");
 
   MyMoneySplit s;
   s.setPayeeId("P000001");
   s.setShares(moT2);
   s.setValue(moT2);
   s.setAccountId(a_parent.id());
   s.setBankID("SPID1");
   s.setReconcileFlag(eMyMoney::Split::State::Reconciled);
   t10.addSplit(s);
 
   s.setPayeeId("P000001");
   s.setShares(-moT2);
   s.setValue(-moT2);
   s.setAccountId(a_cash.id());
   s.setBankID("SPID2");
   s.setReconcileFlag(eMyMoney::Split::State::Cleared);
   s.clearId();
   t10.addSplit(s);
 
   sch.setTransaction(t10);
 
   file->addSchedule(sch);
   ft.commit();
 
   //run forecast
   MyMoneyForecast c;
   c.setForecastMethod(0);
   c.setForecastCycles(1);
   c.createBudget(budget, QDate::currentDate().addYears(-2), QDate::currentDate().addYears(-1), QDate::currentDate().addMonths(-2), QDate::currentDate().addMonths(6), true);
 
   MyMoneyMoney c_parent = c.forecastBalance(a_parent, QDate(QDate::currentDate().addMonths(1).year(), QDate::currentDate().addMonths(1).month(), 1));
 
   //test valid results
   QVERIFY(c.forecastBalance(a_parent, QDate(QDate::currentDate().addMonths(1).year(), QDate::currentDate().addMonths(1).month(), 1)) == (moT2));
 }
 
 void MyMoneyForecastTest::testLinearRegression()
 {
   //set up environment
   MyMoneyForecast a;
 
   MyMoneyAccount a_checking = file->account(acChecking);
   MyMoneyAccount a_credit = file->account(acCredit);
 
   //setup some transactions
   TransactionHelper t1(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), this->moT1, acChecking, acSolo);
   TransactionHelper t2(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -(this->moT2), acCredit, acParent);
   TransactionHelper t3(QDate::currentDate().addDays(-1), MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer), this->moT1, acCredit, acChecking);
 
 //TODO Add tests specific for linear regression
 
 
 }
diff --git a/kmymoney/mymoney/tests/mymoneytestutils.cpp b/kmymoney/mymoney/tests/mymoneytestutils.cpp
index ecc5a7edc..32ffaf94f 100644
--- a/kmymoney/mymoney/tests/mymoneytestutils.cpp
+++ b/kmymoney/mymoney/tests/mymoneytestutils.cpp
@@ -1,28 +1,25 @@
 /***************************************************************************
                           mymoneytestutils.cpp
                              -------------------
     copyright            : (C) 2002 by 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 "mymoneyutils.h"
 
 #include "mymoneyexception.h"
 
 QString unexpectedExceptionString(const MyMoneyException &e)
 {
-  return QString("Unexpected exception: %1 thrown in %2:%3")
-         .arg(e.what())
-         .arg(e.file())
-         .arg(e.line());
+  return QString("Unexpected exception: %1").arg(e.what());
 }
 
diff --git a/kmymoney/mymoney/tests/onlinejobadministration-test.cpp b/kmymoney/mymoney/tests/onlinejobadministration-test.cpp
index 2907e3f04..3c25989d3 100644
--- a/kmymoney/mymoney/tests/onlinejobadministration-test.cpp
+++ b/kmymoney/mymoney/tests/onlinejobadministration-test.cpp
@@ -1,80 +1,80 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "onlinejobadministration-test.h"
 
 #include <QTest>
 
 #include "onlinejobadministration.h"
 #include "mymoney/mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoney/storage/mymoneystoragemgr.h"
 #include "onlinetasks/dummy/tasks/dummytask.h"
 #include "mymoneyenums.h"
 
 QTEST_GUILESS_MAIN(onlineJobAdministrationTest)
 
 onlineJobAdministrationTest::onlineJobAdministrationTest()
   : storage(nullptr)
   , file(nullptr)
 {
 }
 
 void onlineJobAdministrationTest::initTestCase()
 {
   file = MyMoneyFile::instance();
   storage = new MyMoneyStorageMgr;
   file->attachStorage(storage);
 
   try {
     MyMoneyAccount account = MyMoneyAccount();
     account.setName("Test Account");
     account.setAccountType(eMyMoney::Account::Type::Savings);
     MyMoneyAccount asset = file->asset();
     MyMoneyFileTransaction transaction;
     file->addAccount(account , asset);
     accountId = account.id();
     transaction.commit();
-  } catch (const MyMoneyException& ex) {
-    QFAIL(qPrintable("Unexpected exception " + ex.what()));
+  } catch (const MyMoneyException &ex) {
+    QFAIL(qPrintable(QString::fromLatin1("Unexpected exception %1").arg(ex.what())));
   }
 }
 
 void onlineJobAdministrationTest::cleanupTestCase()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void onlineJobAdministrationTest::init()
 {
   qDeleteAll(onlineJobAdministration::instance()->m_onlineTasks);
   onlineJobAdministration::instance()->m_onlineTasks.clear();
 }
 
 void onlineJobAdministrationTest::getSettings()
 {
 }
 
 void onlineJobAdministrationTest::registerOnlineTask()
 {
   dummyTask *task = new dummyTask;
   onlineJobAdministration::instance()->registerOnlineTask(task);
   QCOMPARE(onlineJobAdministration::instance()->m_onlineTasks.count(), 1);
   QVERIFY(onlineJobAdministration::instance()->m_onlineTasks.value(task->taskName()));
 }
diff --git a/kmymoney/payeeidentifier/ibanandbic/widgets/ibanbicitemedit.cpp b/kmymoney/payeeidentifier/ibanandbic/widgets/ibanbicitemedit.cpp
index 2e9de0022..3631044ee 100644
--- a/kmymoney/payeeidentifier/ibanandbic/widgets/ibanbicitemedit.cpp
+++ b/kmymoney/payeeidentifier/ibanandbic/widgets/ibanbicitemedit.cpp
@@ -1,115 +1,116 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "ibanbicitemedit.h"
 #include "ui_ibanbicitemedit.h"
 
 #include "payeeidentifier/ibanandbic/ibanbic.h"
 #include "payeeidentifier/payeeidentifiertyped.h"
 
 struct ibanBicItemEdit::Private {
   Ui::ibanBicItemEdit* ui;
   payeeIdentifier m_identifier;
 };
 
 ibanBicItemEdit::ibanBicItemEdit(QWidget* parent)
     : QWidget(parent),
     d(new Private)
 {
   d->ui = new Ui::ibanBicItemEdit;
   d->ui->setupUi(this);
   setFocusProxy(d->ui->ibanEdit);
 
   connect(d->ui->ibanEdit, SIGNAL(textChanged(QString)), this, SLOT(updateIdentifier()));
   connect(d->ui->bicEdit, SIGNAL(textChanged(QString)), this, SLOT(updateIdentifier()));
 
   connect(d->ui->ibanEdit, SIGNAL(textChanged(QString)), this, SIGNAL(ibanChanged(QString)));
   connect(d->ui->bicEdit, SIGNAL(textChanged(QString)), this, SIGNAL(bicChanged(QString)));
 
   connect(d->ui->ibanEdit, SIGNAL(returnPressed()), this, SLOT(editFinished()));
   connect(d->ui->bicEdit, SIGNAL(returnPressed()), this, SLOT(editFinished()));
 }
 
 void ibanBicItemEdit::editFinished()
 {
   emit commitData(this);
   emit closeEditor(this);
 }
 
 payeeIdentifier ibanBicItemEdit::identifier() const
 {
   return d->m_identifier;
 }
 
 QString ibanBicItemEdit::bic() const
 {
   return d->ui->bicEdit->text();
 }
 
 QString ibanBicItemEdit::iban() const
 {
   return d->ui->ibanEdit->text();
 }
 
 void ibanBicItemEdit::setIdentifier(const payeeIdentifier& ident)
 {
   try {
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> identTyped(ident);
     d->ui->bicEdit->setText(identTyped->storedBic());
     d->ui->ibanEdit->setText(identTyped->paperformatIban());
     d->m_identifier = ident;
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 }
 
 void ibanBicItemEdit::setBic(const QString& bic)
 {
   d->ui->bicEdit->setText(bic);
 }
 
 void ibanBicItemEdit::setIban(const QString& iban)
 {
   d->ui->ibanEdit->setText(payeeIdentifiers::ibanBic::ibanToPaperformat(iban));
 }
 
 void ibanBicItemEdit::updateIdentifier()
 {
   if (d->m_identifier.isNull())
     d->m_identifier = payeeIdentifier(d->m_identifier.id(), new payeeIdentifiers::ibanBic);
 
   const QString iban = payeeIdentifiers::ibanBic::ibanToElectronic(d->ui->ibanEdit->text());
   const QString bic = d->ui->bicEdit->text();
   bool changed = false;
 
   payeeIdentifierTyped<payeeIdentifiers::ibanBic> ident(d->m_identifier);
   if (ident->storedBic() != bic) {
     ident->setBic(bic);
     changed = true;
   }
 
   if (ident->electronicIban() != iban) {
     ident->setElectronicIban(iban);
     changed = true;
   }
   d->m_identifier = ident;
 
   if (changed) {
     emit identifierChanged(d->m_identifier);
     emit commitData(this);
   }
 }
diff --git a/kmymoney/payeeidentifier/nationalaccount/ui/nationalaccountedit.cpp b/kmymoney/payeeidentifier/nationalaccount/ui/nationalaccountedit.cpp
index fce7357e2..cd06ec2a9 100644
--- a/kmymoney/payeeidentifier/nationalaccount/ui/nationalaccountedit.cpp
+++ b/kmymoney/payeeidentifier/nationalaccount/ui/nationalaccountedit.cpp
@@ -1,93 +1,95 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "nationalaccountedit.h"
 
 #include "payeeidentifier/payeeidentifiertyped.h"
 #include "payeeidentifier/nationalaccount/nationalaccount.h"
 
 #include "ui_nationalaccountedit.h"
 
 struct nationalAccountEdit::Private {
   Ui::nationalAccountEdit ui;
   payeeIdentifier m_identifier;
 };
 
 nationalAccountEdit::nationalAccountEdit(QWidget* parent)
     : QWidget(parent),
     d(new Private)
 {
   d->ui.setupUi(this);
   setFocusProxy(d->ui.accountNumberEdit);
 
   connect(d->ui.accountNumberEdit, SIGNAL(textChanged(QString)), this, SIGNAL(accountNumberChannged(QString)));
   connect(d->ui.institutionCodeEdit, SIGNAL(textChanged(QString)), this, SIGNAL(institutionCodeChanged(QString)));
 
   connect(d->ui.accountNumberEdit, SIGNAL(returnPressed()), this, SLOT(editFinished()));
   connect(d->ui.institutionCodeEdit, SIGNAL(returnPressed()), this, SLOT(editFinished()));
 }
 
 payeeIdentifier nationalAccountEdit::identifier() const
 {
   if (!d->m_identifier.isNull()) {
     try {
       payeeIdentifierTyped<payeeIdentifiers::nationalAccount> ident(d->m_identifier);
       ident->setAccountNumber(d->ui.accountNumberEdit->text());
       ident->setBankCode(d->ui.institutionCodeEdit->text());
-    } catch (payeeIdentifier::exception&) {
+    } catch (const payeeIdentifier::empty &) {
+    } catch (const payeeIdentifier::badCast &) {
     }
   }
   return d->m_identifier;
 }
 
 void nationalAccountEdit::editFinished()
 {
   emit commitData(this);
   emit closeEditor(this);
 }
 
 QString nationalAccountEdit::accountNumber() const
 {
   return d->ui.accountNumberEdit->text();
 }
 
 QString nationalAccountEdit::institutionCode() const
 {
   return d->ui.institutionCodeEdit->text();
 }
 
 void nationalAccountEdit::setIdentifier(const payeeIdentifier& ident)
 {
   try {
     payeeIdentifierTyped<payeeIdentifiers::nationalAccount> identTyped(ident);
     d->ui.accountNumberEdit->setText(identTyped->accountNumber());
     d->ui.institutionCodeEdit->setText(identTyped->bankCode());
     d->m_identifier = ident;
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 }
 
 void nationalAccountEdit::setAccountNumber(const QString& accountNumber)
 {
   d->ui.accountNumberEdit->setText(accountNumber);
 }
 
 void nationalAccountEdit::setInstitutionCode(const QString& institutionCode)
 {
   d->ui.institutionCodeEdit->setText(institutionCode);
 }
diff --git a/kmymoney/plugins/csv/export/csvwriter.cpp b/kmymoney/plugins/csv/export/csvwriter.cpp
index ebdad64ff..2f3d9f0b9 100644
--- a/kmymoney/plugins/csv/export/csvwriter.cpp
+++ b/kmymoney/plugins/csv/export/csvwriter.cpp
@@ -1,459 +1,456 @@
 /*
  * Copyright 2013-2014  Allan Anderson <agander93@gmail.com>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "csvwriter.h"
 
 // ----------------------------------------------------------------------------
 // QT Headers
 
 #include <QFile>
 #include <QList>
 #include <QDebug>
 #include <QStringBuilder>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <KMessageBox>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Headers
 
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneysplit.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 #include "csvexportdlg.h"
 #include "csvexporter.h"
 #include "mymoneyenums.h"
 
 CsvWriter::CsvWriter() :
     m_plugin(0),
     m_firstSplit(false),
     m_highestSplitCount(0),
     m_noError(true)
 {
 }
 
 CsvWriter::~CsvWriter()
 {
 }
 
 void CsvWriter::write(const QString& filename,
                       const QString& accountId, const bool accountData,
                       const bool categoryData,
                       const QDate& startDate, const QDate& endDate,
                       const QString& separator)
 {
   m_separator = separator;
   QFile csvFile(filename);
   if (csvFile.open(QIODevice::WriteOnly)) {
     QTextStream s(&csvFile);
     s.setCodec("UTF-8");
 
     m_plugin->exporterDialog()->show();
     try {
       if (categoryData) {
         writeCategoryEntries(s);
       }
 
       if (accountData) {
         writeAccountEntry(s, accountId, startDate, endDate);
       }
       emit signalProgress(-1, -1);
 
     } catch (const MyMoneyException &e) {
-      QString errMsg = i18n("Unexpected exception '%1' thrown in %2, line %3 "
-                            "caught in MyMoneyCsvWriter::write()", e.what(), e.file(), e.line());
-
-      KMessageBox::error(0, errMsg);
+      KMessageBox::error(nullptr, i18n("Unexpected exception '%1'", QString::fromLatin1(e.what())));
     }
 
     csvFile.close();
     qDebug() << i18n("Export completed.\n");
     delete m_plugin->exporterDialog();  //  Can now delete as export finished
   } else {
     KMessageBox::error(0, i18n("Unable to open file '%1' for writing", filename));
   }
 }
 
 void CsvWriter::writeAccountEntry(QTextStream& stream, const QString& accountId, const QDate& startDate, const QDate& endDate)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount account;
   QString data;
 
   account = file->account(accountId);
   MyMoneyTransactionFilter filter(accountId);
 
   QString type = account.accountTypeToString(account.accountType());
   data = QString(i18n("Account Type:"));
 
   if (type == QLatin1String("Investment")) {
     data += QString("%1\n\n").arg(type);
     m_headerLine << QString(i18n("Date")) << QString(i18n("Security")) << QString(i18n("Action/Type")) << QString(i18n("Amount")) << QString(i18n("Quantity")) << QString(i18n("Price")) << QString(i18n("Interest")) << QString(i18n("Fees")) << QString(i18n("Account")) << QString(i18n("Memo")) << QString(i18n("Status"));
     data += m_headerLine.join(m_separator);
     extractInvestmentEntries(accountId, startDate, endDate);
   } else {
     data += QString("%1\n\n").arg(type);
     m_headerLine << QString(i18n("Date")) << QString(i18n("Payee")) << QString(i18n("Amount")) << QString(i18n("Account/Cat")) << QString(i18n("Memo")) << QString(i18n("Status")) << QString(i18n("Number"));
     filter.setDateFilter(startDate, endDate);
 
     QList<MyMoneyTransaction> trList = file->transactionList(filter);
     QList<MyMoneyTransaction>::ConstIterator it;
     signalProgress(0, trList.count());
     int count = 0;
     m_highestSplitCount = 0;
     for (it = trList.constBegin(); it != trList.constEnd(); ++it) {
       writeTransactionEntry(*it, accountId, ++count);
       if (m_noError)
         signalProgress(count, 0);
     }
     data += m_headerLine.join(m_separator);
   }
 
   QString result;
   QMap<QString, QString>::const_iterator it_map = m_map.constBegin();
   while (it_map != m_map.constEnd()) {
     result += it_map.value();
     ++it_map;
   }
 
   stream << data << result << QLatin1Char('\n');
 }
 
 void CsvWriter::writeCategoryEntries(QTextStream &s)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount income;
   MyMoneyAccount expense;
 
   income = file->income();
   expense = file->expense();
 
   QStringList list = income.accountList() + expense.accountList();
   emit signalProgress(0, list.count());
   QStringList::Iterator it_catList;
   int count = 0;
   for (it_catList = list.begin(); it_catList != list.end(); ++it_catList) {
     writeCategoryEntry(s, *it_catList, "");
     emit signalProgress(++count, 0);
   }
 }
 
 void CsvWriter::writeCategoryEntry(QTextStream &s, const QString& accountId, const QString& leadIn)
 {
   MyMoneyAccount acc = MyMoneyFile::instance()->account(accountId);
   QString name = acc.name();
 
   s << leadIn << name << m_separator;
   s << (acc.accountGroup() == eMyMoney::Account::Type::Expense ? QLatin1Char('E') : QLatin1Char('I'));
   s << endl;
 
   name += m_separator;
   foreach (const auto sAccount, acc.accountList())
     writeCategoryEntry(s, sAccount, name);
 }
 
 
 void CsvWriter::writeTransactionEntry(const MyMoneyTransaction& t, const QString& accountId, const int count)
 {
   m_firstSplit = true;
   m_noError = true;
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneySplit split = t.splitByAccount(accountId);
   QList<MyMoneySplit> splits = t.splits();
   if (splits.count() < 2) {
     KMessageBox::sorry(0, i18n("Transaction number '%1' is missing an account assignment.\n"
                                "Date '%2', Payee '%3'.\nTransaction dropped.\n", count, t.postDate().toString(Qt::ISODate), file->payee(split.payeeId()).name()),
                        i18n("Invalid transaction"));
     m_noError = false;
     return;
   }
 
   QString str;
   str += QLatin1Char('\n');
 
   str += QString("%1" + m_separator).arg(t.postDate().toString(Qt::ISODate));
   MyMoneyPayee payee = file->payee(split.payeeId());
   str += QString("%1" + m_separator).arg(payee.name());
 
   QString txt = split.value().formatMoney("", 2, false);
   str += QString("%1" + m_separator).arg(txt);
 
   if (splits.count() > 1) {
     MyMoneySplit sp = t.splitByAccount(accountId, false);
     QString tmp = QString("%1").arg(file->accountToCategory(sp.accountId()));
     str += tmp + m_separator;
   }
   QString memo = split.memo();
   memo.replace('\n', '~').remove('\'');
   QString localeThousands = QLocale().groupSeparator();  //  In case of clash with field separator
   if (m_separator == localeThousands) {
     memo.replace(localeThousands, QString());
   }
 
   str += QString("%1" + m_separator).arg(memo);
 
   switch (split.reconcileFlag()) {
     case eMyMoney::Split::State::Cleared:
       str += QLatin1String("C") + m_separator;
       break;
 
     case eMyMoney::Split::State::Reconciled:
     case eMyMoney::Split::State::Frozen:
       str += QLatin1String("R") + m_separator;
       break;
 
     default:
       str += m_separator;
       break;
   }
 
   str += split.number();
 
   if (splits.count() > 2) {
     QList<MyMoneySplit>::ConstIterator it;
     for (it = splits.constBegin(); it != splits.constEnd(); ++it) {
       if (!((*it) == split)) {
         writeSplitEntry(str, *it, splits.count() - 1);
       }
     }
   }
   QString date = t.postDate().toString(Qt::ISODate);
   m_map.insertMulti(date, str);
 }
 
 void CsvWriter::writeSplitEntry(QString &str, const MyMoneySplit& split, const int splitCount)
 {
   if (m_firstSplit) {
     m_firstSplit = false;
     str += m_separator;
   }
   MyMoneyFile* file = MyMoneyFile::instance();
   QString splt = QString("%1").arg(file->accountToCategory(split.accountId()));
   str += splt + m_separator;
 
   if (splitCount > m_highestSplitCount) {
     m_highestSplitCount++;
     m_headerLine << QString(i18n("splitCategory")) << QString(i18n("splitMemo")) << QString(i18n("splitAmount"));
     m_headerLine.join(m_separator);
   }
   QString m = split.memo();
   m.replace(QLatin1Char('\n'), QLatin1Char('~'));
   QString localeThousands = QLocale().groupSeparator();  //  In case of clash with field separator
   if (m_separator == localeThousands) {
     m.replace(localeThousands, QString());
   }
   str += QString("%1" + m_separator).arg(m);
 
   QString txt = QString("%1" + m_separator).arg(split.value().formatMoney("", 2, false));
   str += txt;
 }
 
 void CsvWriter::extractInvestmentEntries(const QString& accountId, const QDate& startDate, const QDate& endDate)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   foreach (const auto sAccount, file->account(accountId).accountList()) {
     MyMoneyTransactionFilter filter(sAccount);
     filter.setDateFilter(startDate, endDate);
     QList<MyMoneyTransaction> list = file->transactionList(filter);
     QList<MyMoneyTransaction>::ConstIterator itList;
     signalProgress(0, list.count());
     int count = 0;
     for (itList = list.constBegin(); itList != list.constEnd(); ++itList) {
       writeInvestmentEntry(*itList, ++count);
       signalProgress(count, 0);
     }
   }
 }
 
 void CsvWriter::writeInvestmentEntry(const MyMoneyTransaction& t, const int count)
 {
   QString strQuantity;
   QString strAmount;
   QString strPrice;
   QString strAccName;
   QString strCheckingAccountName;
   QString strMemo;
   QString strAction;
   QString strStatus;
   QString strInterest;
   QString strFees;
   MyMoneyFile* file = MyMoneyFile::instance();
   QString chkAccnt;
   QList<MyMoneySplit> lst = t.splits();
   QList<MyMoneySplit>::Iterator itSplit;
   eMyMoney::Account::Type typ;
   QString chkAccntId;
   MyMoneyMoney qty;
   MyMoneyMoney value;
   QMap<eMyMoney::Account::Type, QString> map;
 
   for (int i = 0; i < lst.count(); i++) {
     MyMoneyAccount acc = file->account(lst[i].accountId());
     QString accName = acc.name();
     typ = acc.accountType();
     map.insert(typ, lst[i].accountId());
 
     if (typ == eMyMoney::Account::Type::Stock) {
       switch (lst[i].reconcileFlag()) {
         case eMyMoney::Split::State::Cleared:
           strStatus =  QLatin1Char('C');
           break;
 
         case eMyMoney::Split::State::Reconciled:
         case eMyMoney::Split::State::Frozen:
           strStatus =  QLatin1Char('R');
           break;
 
         default:
           strStatus.clear();
           break;
       }
       strStatus += m_separator;
     }
   }
   //
   //  Add date.
   //
   QString str = QString("\n%1" + m_separator).arg(t.postDate().toString(Qt::ISODate));
   QString localeThousands = QLocale().groupSeparator();  //  In case of clash with field separator
   for (itSplit = lst.begin(); itSplit != lst.end(); ++itSplit) {
     MyMoneyAccount acc = file->account((*itSplit).accountId());
     //
     //  eMyMoney::Account::Type::Checkings.
     //
     if ((acc.accountType() == eMyMoney::Account::Type::Checkings) || (acc.accountType() == eMyMoney::Account::Type::Cash) || (acc.accountType() == eMyMoney::Account::Type::Savings)) {
       chkAccntId = (*itSplit).accountId();
       chkAccnt = file->account(chkAccntId).name();
       strCheckingAccountName = file->accountToCategory(chkAccntId) + m_separator;
       strAmount = (*itSplit).value().formatMoney("", 2).remove(localeThousands) + m_separator;
     } else if (acc.accountType() == eMyMoney::Account::Type::Income) {
       //
       //  eMyMoney::Account::Type::Income.
       //
       qty = (*itSplit).shares();
       value = (*itSplit).value();
       strInterest = value.formatMoney("", 2, false) + m_separator;
     } else if (acc.accountType() == eMyMoney::Account::Type::Expense) {
       //
       //  eMyMoney::Account::Type::Expense.
       //
       qty = (*itSplit).shares();
       value = (*itSplit).value();
       strFees = value.formatMoney("", 2, false) + m_separator;
     }  else if (acc.accountType() == eMyMoney::Account::Type::Stock) {
       //
       //  eMyMoney::Account::Type::Stock.
       //
       strMemo = QString("%1" + m_separator).arg((*itSplit).memo());
       strMemo.replace(QLatin1Char('\n'), QLatin1Char('~')).remove('\'');
       //
       //  Actions.
       //
       if ((*itSplit).action() == QLatin1String("Dividend")) {
         strAction = QLatin1String("DivX");
       } else if ((*itSplit).action() == QLatin1String("IntIncome")) {
         strAction = QLatin1String("IntIncX");
       }
       if ((strAction == QLatin1String("DivX")) || (strAction == QLatin1String("IntIncX"))) {
         if ((map.value(eMyMoney::Account::Type::Checkings).isEmpty()) && (map.value(eMyMoney::Account::Type::Cash).isEmpty())) {
           KMessageBox::sorry(0, i18n("Transaction number '%1' is missing an account assignment.\n"
                                      "Date '%2', Amount '%3'.\nTransaction dropped.\n", count, t.postDate().toString(Qt::ISODate), strAmount),
                              i18n("Invalid transaction"));
           return;
         }
       } else if ((*itSplit).action() == QLatin1String("Buy")) {
         qty = (*itSplit).shares();
         if (qty.isNegative()) {
           strAction = QLatin1String("Sell");
         } else {
           strAction = QLatin1String("Buy");
         }
       } else if ((*itSplit).action() == QLatin1String("Add")) {
         qty = (*itSplit).shares();
         if (qty.isNegative()) {
           strAction = QLatin1String("Shrsout");
         } else {
           strAction = QLatin1String("Shrsin");
         }
       } else if ((*itSplit).action() == QLatin1String("Reinvest")) {
         qty = (*itSplit).shares();
         strAmount = (*itSplit).value().formatMoney("", 2).remove(localeThousands) + m_separator;
         strAction = QLatin1String("ReinvDiv");
       } else {
         strAction = (*itSplit).action();
       }
       //
       //  Add action.
       //
       if ((strAction == QLatin1String("Buy")) || (strAction == QLatin1String("Sell")) || (strAction == QLatin1String("ReinvDiv"))) {
         //
         //  Add total.
         //
         if (strAction == QLatin1String("Sell")) {
           value = -value;
         }
         //
         //  Add price.
         //
         strPrice = (*itSplit).price().formatMoney("", 6, false);
         if (!qty.isZero()) {
           //
           //  Add quantity.
           //
           if (strAction == QLatin1String("Sell")) {
             qty = -qty;
           }
           strQuantity = qty.formatMoney("", 2, false);
         }
       } else if ((strAction == QLatin1String("Shrsin")) || (strAction == QLatin1String("Shrsout"))) {
         //
         //  Add quantity for "Shrsin" || "Shrsout".
         //
         if (strAction == QLatin1String("Shrsout")) {
           qty = -qty;
         }
         strQuantity = qty.formatMoney("", 2, false);
       }
       strAccName = acc.name();
       strAccName += m_separator;
       strAction += m_separator;
       strQuantity += m_separator;
       strPrice += m_separator;
     }
     if (strCheckingAccountName.isEmpty()) {
       strCheckingAccountName = m_separator;
     }
     if (strInterest.isEmpty()) {
       strInterest = m_separator;
     }
     if (strFees.isEmpty()) {
       strFees = m_separator;
     }
   }  //  end of itSplit loop
   str += strAccName + strAction + strAmount + strQuantity + strPrice + strInterest + strFees + strCheckingAccountName + strMemo + strStatus;
   QString date = t.postDate().toString(Qt::ISODate);
   m_map.insertMulti(date, str);
 }
diff --git a/kmymoney/plugins/gnc/import/mymoneygncreader.cpp b/kmymoney/plugins/gnc/import/mymoneygncreader.cpp
index 1ef37cbdd..59a2e25cc 100644
--- a/kmymoney/plugins/gnc/import/mymoneygncreader.cpp
+++ b/kmymoney/plugins/gnc/import/mymoneygncreader.cpp
@@ -1,2698 +1,2693 @@
 /***************************************************************************
                       mymoneygncreader  -  description
                          -------------------
 begin                : Wed Mar 3 2004
 copyright            : (C) 2000-2004 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>
                        (C) 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneygncreader.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QFile>
 #include <QMap>
 #include <QIcon>
 #include <QInputDialog>
 #include <QFileDialog>
 #include <QTextCodec>
 #include <QTextStream>
 #include <QDebug>
 #include <QXmlAttributes>
 #include <QXmlInputSource>
 #include <QXmlSimpleReader>
 #include <QPointer>
 #if QT_VERSION >= 0x051000
   #include <QRandomGenerator>
 #endif
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 #ifndef _GNCFILEANON
 #include <KConfig>
 #include <KMessageBox>
 #endif
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Third party Includes
 
 // ------------------------------------------------------------Box21----------------
 // Project Includes
 #include <config-kmymoney.h>
 #include "mymoneystoragemgr.h"
 #ifndef _GNCFILEANON
 #include "kmymoneyutils.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyschedule.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 #include "kgncimportoptionsdlg.h"
 #include "kgncpricesourcedlg.h"
 #include "keditscheduledlg.h"
 #include "kmymoneyedit.h"
 #include "kmymoneymoneyvalidator.h"
 #define TRY try
 #define CATCH catch (const MyMoneyException &)
 #define PASS catch (const MyMoneyException &) { throw; }
 #else
 #include "mymoneymoney.h"
 #include <KTextEdit>
 //  #define i18n QObject::tr
 #define TRY
 #define CATCH
 #define PASS
 #define MYMONEYEXCEPTION QString
 #define MyMoneyException QString
 #define PACKAGE "KMyMoney"
 #endif // _GNCFILEANON
 
 #include "mymoneyenums.h"
 
 using namespace eMyMoney;
 
 // init static variables
 double MyMoneyGncReader::m_fileHideFactor = 0.0;
 double GncObject::m_moneyHideFactor;
 
 // user options
 void MyMoneyGncReader::setOptions()
 {
 #ifndef _GNCFILEANON
   KGncImportOptionsDlg dlg; // display the dialog to allow the user to set own options
   if (dlg.exec()) {
     // set users input options
     m_dropSuspectSchedules = dlg.scheduleOption();
     m_investmentOption = dlg.investmentOption();
     m_useFinanceQuote = dlg.quoteOption();
     m_useTxNotes = dlg.txNotesOption();
     m_decoder = dlg.decodeOption();
     gncdebug = dlg.generalDebugOption();
     xmldebug = dlg.xmlDebugOption();
     bAnonymize = dlg.anonymizeOption();
   } else {
     // user declined, so set some sensible defaults
     m_dropSuspectSchedules = false;
     // investment option - 0, create investment a/c per stock a/c, 1 = single new investment account, 2 = prompt for each stock
     // option 2 doesn't really work too well at present
     m_investmentOption = 0;
     m_useFinanceQuote = false;
     m_useTxNotes = false;
     m_decoder = 0;
     gncdebug = false; // general debug messages
     xmldebug = false; // xml trace
     bAnonymize = false; // anonymize input
   }
   // no dialog option for the following; it will set base currency, and print actual XML data
   developerDebug = false;
   // set your fave currency here to save getting that enormous dialog each time you run a test
   // especially if you have to scroll down to USD...
   if (developerDebug) m_storage->setValue("kmm-baseCurrency", "GBP");
 #endif // _GNCFILEANON
 }
 
 GncObject::GncObject() :
     pMain(0),
     m_subElementList(0),
     m_subElementListCount(0),
     m_dataElementList(0),
     m_dataElementListCount(0),
     m_dataPtr(0),
     m_state(0),
     m_anonClassList(0),
     m_anonClass(0)
 {
 }
 
 // Check that the current element is of a version we are coded for
 void GncObject::checkVersion(const QString& elName, const QXmlAttributes& elAttrs, const map_elementVersions& map)
 {
   TRY {
     if (map.contains(elName)) { // if it's not in the map, there's nothing to check
-      if (!map[elName].contains(elAttrs.value("version"))) {
-        QString em = Q_FUNC_INFO + i18n(": Sorry. This importer cannot handle version %1 of element %2"
-        , elAttrs.value("version"), elName);
-        throw MYMONEYEXCEPTION(em);
-      }
+      if (!map[elName].contains(elAttrs.value("version")))
+        throw MYMONEYEXCEPTION(QString::fromLatin1("%1 : Sorry. This importer cannot handle version %2 of element %3").arg(Q_FUNC_INFO, elAttrs.value("version"), elName));
     }
     return ;
   }
   PASS
 }
 
 // Check if this element is in the current object's sub element list
 GncObject *GncObject::isSubElement(const QString& elName, const QXmlAttributes& elAttrs)
 {
   TRY {
     uint i;
     GncObject *next = 0;
     for (i = 0; i < m_subElementListCount; i++) {
       if (elName == m_subElementList[i]) {
         m_state = i;
         next = startSubEl(); // go create the sub object
         if (next != 0) {
           next->initiate(elName, elAttrs); // initialize it
           next->m_elementName = elName;    // save it's name so we can identify the end
         }
         break;
       }
     }
     return (next);
   }
   PASS
 }
 
 // Check if this element is in the current object's data element list
 bool GncObject::isDataElement(const QString &elName, const QXmlAttributes& elAttrs)
 {
   TRY {
     uint i;
     for (i = 0; i < m_dataElementListCount; i++) {
       if (elName == m_dataElementList[i]) {
         m_state = i;
         dataEl(elAttrs); // go set the pointer so the data can be stored
         return (true);
       }
     }
     m_dataPtr = 0; // we don't need this, so make sure we don't store extraneous data
     return (false);
   }
   PASS
 }
 
 // return the variable string, decoded if required
 QString GncObject::var(int i) const
 {
   /* This code was needed because the Qt3 XML reader apparently did not process
    the encoding parameter in the <?xml header.
    This SEEMS to have been rectified in Qt4 though I have little test data
    to prove this conclusively.
    If true, we can remove the encoding option in the import options dialog
    and this code too.*/
   return (pMain->m_decoder == 0
           ? m_v[i]
           : pMain->m_decoder->toUnicode(m_v[i].toUtf8()));
 }
 
 const QString GncObject::getKvpValue(const QString& key, const QString& type) const
 {
   QList<GncKvp>::const_iterator it;
   // first check for exact match
   for (it = m_kvpList.begin(); it != m_kvpList.end(); ++it) {
     if (((*it).key() == key) && ((type.isEmpty()) || ((*it).type() == type)))
       return (*it).value();
   }
   // then for partial match
   for (it = m_kvpList.begin(); it != m_kvpList.end(); ++it) {
     if (((*it).key().contains(key)) && ((type.isEmpty()) || ((*it).type() == type)))
       return (*it).value();
   }
   return (QString());
 }
 
 void GncObject::adjustHideFactor()
 {
 #if QT_VERSION >= 0x051000
   m_moneyHideFactor = pMain->m_fileHideFactor * (1.0 + (int)(200.0 * QRandomGenerator::system()->generate() / (RAND_MAX + 1.0))) / 100.0;
 #else
   m_moneyHideFactor = pMain->m_fileHideFactor * (1.0 + (int)(200.0 * rand() / (RAND_MAX + 1.0))) / 100.0;
 #endif
 }
 
 // data anonymizer
 QString GncObject::hide(QString data, unsigned int anonClass)
 {
   TRY {
     if (!pMain->bAnonymize) return (data); // no anonymizing required
     // counters used to generate names for anonymizer
     static int nextAccount;
     static int nextEquity;
     static int nextPayee;
     static int nextSched;
     static QMap<QString, QString> anonPayees; // to check for duplicate payee names
     static QMap<QString, QString> anonStocks; // for reference to equities
 
     QString result(data);
     QMap<QString, QString>::const_iterator it;
     MyMoneyMoney in, mresult;
     switch (anonClass) {
       case ASIS:     // this is not personal data
         break;
       case SUPPRESS: // this is personal and is not essential
         result = "";
         break;
       case NXTACC:   // generate account name
         result = ki18n("Account%1").subs(++nextAccount, -6).toString();
         break;
       case NXTEQU:   // generate/return an equity name
         it = anonStocks.constFind(data);
         if (it == anonStocks.constEnd()) {
           result = ki18n("Stock%1").subs(++nextEquity, -6).toString();
           anonStocks.insert(data, result);
         } else {
           result = (*it);
         }
         break;
       case NXTPAY:   // generate/return a payee name
         it = anonPayees.constFind(data);
         if (it == anonPayees.constEnd()) {
           result = ki18n("Payee%1").subs(++nextPayee, -6).toString();
           anonPayees.insert(data, result);
         } else {
           result = (*it);
         }
         break;
       case NXTSCHD:  // generate a schedule name
         result = ki18n("Schedule%1").subs(++nextSched, -6).toString();
         break;
       case MONEY1:
         in = MyMoneyMoney(data);
         if (data == "-1/0") in = MyMoneyMoney();  // spurious gnucash data - causes a crash sometimes
         mresult = MyMoneyMoney(m_moneyHideFactor) * in;
         mresult.convert(10000);
         result = mresult.toString();
         break;
       case MONEY2:
         in = MyMoneyMoney(data);
         if (data == "-1/0") in = MyMoneyMoney();
         mresult  = MyMoneyMoney(m_moneyHideFactor) * in;
         mresult.convert(10000);
         mresult.setThousandSeparator(' ');
         result = mresult.formatMoney("", 2);
         break;
     }
     return (result);
   }
   PASS
 }
 
 // dump current object data values // only called if gncdebug set
 void GncObject::debugDump()
 {
   uint i;
   qDebug() << "Object" << m_elementName;
   for (i = 0; i < m_dataElementListCount; i++) {
     qDebug() << m_dataElementList[i] << "=" << m_v[i];
   }
 }
 //*****************************************************************
 GncFile::GncFile()
 {
   static const QString subEls[] = {"gnc:book", "gnc:count-data", "gnc:commodity", "price",
                                    "gnc:account", "gnc:transaction", "gnc:template-transactions",
                                    "gnc:schedxaction"
                                   };
   m_subElementList = subEls;
   m_subElementListCount = END_FILE_SELS;
   m_dataElementListCount = 0;
   m_processingTemplates = false;
   m_bookFound = false;
 }
 
 GncFile::~GncFile() {}
 
 GncObject *GncFile::startSubEl()
 {
   TRY {
     if (pMain->xmldebug) qDebug("File start subel m_state %d", m_state);
     GncObject *next = 0;
     switch (m_state) {
       case BOOK:
-        if (m_bookFound) throw MYMONEYEXCEPTION(i18n("This version of the importer cannot handle multi-book files."));
+        if (m_bookFound) MYMONEYEXCEPTION(QString::fromLatin1("This version of the importer cannot handle multi-book files."));
         m_bookFound = true;
         break;
       case COUNT:
         next = new GncCountData;
         break;
       case CMDTY:
         next = new GncCommodity;
         break;
       case PRICE:
         next = new GncPrice;
         break;
       case ACCT:
         // accounts within the template section are ignored
         if (!m_processingTemplates) next = new GncAccount;
         break;
       case TX:
         next = new GncTransaction(m_processingTemplates);
         break;
       case TEMPLATES:
         m_processingTemplates = true;
         break;
       case SCHEDULES:
         m_processingTemplates = false;
         next = new GncSchedule;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncFile rcvd invalid state");
+        throw MYMONEYEXCEPTION_CSTRING("GncFile rcvd invalid state");
     }
     return (next);
   }
   PASS
 }
 
 void GncFile::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("File end subel");
   if (!m_processingTemplates) delete subObj; // template txs must be saved awaiting schedules
   m_dataPtr = 0;
   return ;
 }
 //****************************************** GncDate *********************************************
 GncDate::GncDate()
 {
   m_subElementListCount = 0;
   static const QString dEls[] = {"ts:date", "gdate"};
   m_dataElementList = dEls;
   m_dataElementListCount = END_Date_DELS;
   static const unsigned int anonClasses[] = {ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncDate::~GncDate() {}
 //*************************************GncCmdtySpec***************************************
 GncCmdtySpec::GncCmdtySpec()
 {
   m_subElementListCount = 0;
   static const QString dEls[] = {"cmdty:space", "cmdty:id"};
   m_dataElementList = dEls;
   m_dataElementListCount = END_CmdtySpec_DELS;
   static const unsigned int anonClasses[] = {ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncCmdtySpec::~GncCmdtySpec() {}
 
 QString GncCmdtySpec::hide(QString data, unsigned int)
 {
   // hide equity names, but not currency names
   unsigned int newClass = ASIS;
   switch (m_state) {
     case CMDTYID:
       if (!isCurrency()) newClass = NXTEQU;
   }
   return (GncObject::hide(data, newClass));
 }
 //************* GncKvp********************************************
 GncKvp::GncKvp()
 {
   m_subElementListCount = END_Kvp_SELS;
   static const QString subEls[] = {"slot"}; // kvp's may be nested
   m_subElementList = subEls;
   m_dataElementListCount = END_Kvp_DELS;
   static const QString dataEls[] = {"slot:key", "slot:value"};
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncKvp::~GncKvp() {}
 
 void GncKvp::dataEl(const QXmlAttributes& elAttrs)
 {
   switch (m_state) {
     case VALUE:
       m_kvpType = elAttrs.value("type");
   }
   m_dataPtr = &(m_v[m_state]);
   if (key().contains("formula")) {
     m_anonClass = MONEY2;
   } else {
     m_anonClass = ASIS;
   }
   return ;
 }
 
 GncObject *GncKvp::startSubEl()
 {
   if (pMain->xmldebug) qDebug("Kvp start subel m_state %d", m_state);
   TRY {
     GncObject *next = 0;
     switch (m_state) {
       case KVP:
         next = new GncKvp;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncKvp rcvd invalid m_state ");
+        throw MYMONEYEXCEPTION_CSTRING("GncKvp rcvd invalid m_state ");
     }
     return (next);
   }
   PASS
 }
 
 void GncKvp::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Kvp end subel");
   m_kvpList.append(*(static_cast <GncKvp*>(subObj)));
   m_dataPtr = 0;
   return ;
 }
 //*********************************GncLot*********************************************
 GncLot::GncLot()
 {
   m_subElementListCount = 0;
   m_dataElementListCount = 0;
 }
 
 GncLot::~GncLot() {}
 
 //*********************************GncCountData***************************************
 GncCountData::GncCountData()
 {
   m_subElementListCount = 0;
   m_dataElementListCount = 0;
   m_v.append(QString());  // only 1 data item
 }
 
 GncCountData::~GncCountData() {}
 
 void GncCountData::initiate(const QString&, const QXmlAttributes& elAttrs)
 {
   m_countType = elAttrs.value("cd:type");
   m_dataPtr = &(m_v[0]);
   return ;
 }
 
 void GncCountData::terminate()
 {
   int i = m_v[0].toInt();
   if (m_countType == "commodity") {
     pMain->setGncCommodityCount(i); return ;
   }
   if (m_countType == "account") {
     pMain->setGncAccountCount(i); return ;
   }
   if (m_countType == "transaction") {
     pMain->setGncTransactionCount(i); return ;
   }
   if (m_countType == "schedxaction") {
     pMain->setGncScheduleCount(i); return ;
   }
   if (i != 0) {
     if (m_countType == "budget") pMain->setBudgetsFound(true);
     else if (m_countType.left(7) == "gnc:Gnc") pMain->setSmallBusinessFound(true);
     else if (pMain->xmldebug) qDebug() << "Unknown count type" << m_countType;
   }
   return ;
 }
 //*********************************GncCommodity***************************************
 GncCommodity::GncCommodity()
 {
   m_subElementListCount = 0;
   static const QString dEls[] = {"cmdty:space", "cmdty:id", "cmdty:name", "cmdty:fraction"};
   m_dataElementList = dEls;
   m_dataElementListCount = END_Commodity_DELS;
   static const unsigned int anonClasses[] = {ASIS, NXTEQU, SUPPRESS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncCommodity::~GncCommodity() {}
 
 void GncCommodity::terminate()
 {
   TRY {
     pMain->convertCommodity(this);
     return ;
   }
   PASS
 }
 //************* GncPrice********************************************
 GncPrice::GncPrice()
 {
   static const QString subEls[] = {"price:commodity", "price:currency", "price:time"};
   m_subElementList = subEls;
   m_subElementListCount = END_Price_SELS;
   m_dataElementListCount = END_Price_DELS;
   static const QString dataEls[] = {"price:value"};
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
   m_vpCommodity = 0;
   m_vpCurrency = 0;
   m_vpPriceDate = 0;
 }
 
 GncPrice::~GncPrice()
 {
   delete m_vpCommodity; delete m_vpCurrency; delete m_vpPriceDate;
 }
 
 GncObject *GncPrice::startSubEl()
 {
   TRY {
     GncObject *next = 0;
     switch (m_state) {
       case CMDTY:
         next = new GncCmdtySpec;
         break;
       case CURR:
         next = new GncCmdtySpec;
         break;
       case PRICEDATE:
         next = new GncDate;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncPrice rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncPrice rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncPrice::endSubEl(GncObject *subObj)
 {
   TRY {
     switch (m_state) {
       case CMDTY:
         m_vpCommodity = static_cast<GncCmdtySpec *>(subObj);
         break;
       case CURR:
         m_vpCurrency = static_cast<GncCmdtySpec *>(subObj);
         break;
       case PRICEDATE:
         m_vpPriceDate = static_cast<GncDate *>(subObj);
         break;
       default:
-        throw MYMONEYEXCEPTION("GncPrice rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncPrice rcvd invalid m_state");
     }
     return;
   }
   PASS
 }
 
 void GncPrice::terminate()
 {
   TRY {
     pMain->convertPrice(this);
     return ;
   }
   PASS
 }
 //************* GncAccount********************************************
 GncAccount::GncAccount()
 {
   m_subElementListCount = END_Account_SELS;
   static const QString subEls[] = {"act:commodity", "slot", "act:lots"};
   m_subElementList = subEls;
   m_dataElementListCount = END_Account_DELS;
   static const QString dataEls[] = {"act:id", "act:name", "act:description",
                                     "act:type", "act:parent"
                                    };
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, NXTACC, SUPPRESS, ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
   m_vpCommodity = 0;
 }
 
 GncAccount::~GncAccount()
 {
   delete m_vpCommodity;
 }
 
 GncObject *GncAccount::startSubEl()
 {
   TRY {
     if (pMain->xmldebug) qDebug("Account start subel m_state %d", m_state);
     GncObject *next = 0;
     switch (m_state) {
       case CMDTY:
         next = new GncCmdtySpec;
         break;
       case KVP:
         next = new GncKvp;
         break;
       case LOTS:
         next = new GncLot();
         pMain->setLotsFound(true); // we don't handle lots; just set flag to report
         break;
       default:
-        throw MYMONEYEXCEPTION("GncAccount rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncAccount rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncAccount::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Account end subel");
   switch (m_state) {
     case CMDTY:
       m_vpCommodity = static_cast<GncCmdtySpec *>(subObj);
       break;
     case KVP:
       m_kvpList.append(*(static_cast <GncKvp*>(subObj)));
   }
   return ;
 }
 
 void GncAccount::terminate()
 {
   TRY {
     pMain->convertAccount(this);
     return ;
   }
   PASS
 }
 //************* GncTransaction********************************************
 GncTransaction::GncTransaction(bool processingTemplates)
 {
   m_subElementListCount = END_Transaction_SELS;
   static const QString subEls[] = {"trn:currency", "trn:date-posted", "trn:date-entered",
                                    "trn:split", "slot"
                                   };
   m_subElementList = subEls;
   m_dataElementListCount = END_Transaction_DELS;
   static const QString dataEls[] = {"trn:id", "trn:num", "trn:description"};
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, SUPPRESS, NXTPAY};
   m_anonClassList = anonClasses;
   adjustHideFactor();
   m_template = processingTemplates;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
   m_vpCurrency = 0;
   m_vpDateEntered = m_vpDatePosted = 0;
 }
 
 GncTransaction::~GncTransaction()
 {
   delete m_vpCurrency; delete m_vpDatePosted; delete m_vpDateEntered;
 }
 
 GncObject *GncTransaction::startSubEl()
 {
   TRY {
     if (pMain->xmldebug) qDebug("Transaction start subel m_state %d", m_state);
     GncObject *next = 0;
     switch (m_state) {
       case CURRCY:
         next = new GncCmdtySpec;
         break;
       case POSTED:
       case ENTERED:
         next = new GncDate;
         break;
       case SPLIT:
         if (isTemplate()) {
           next = new GncTemplateSplit;
         } else {
           next = new GncSplit;
         }
         break;
       case KVP:
         next = new GncKvp;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncTransaction rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncTransaction rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncTransaction::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Transaction end subel");
   switch (m_state) {
     case CURRCY:
       m_vpCurrency = static_cast<GncCmdtySpec *>(subObj);
       break;
     case POSTED:
       m_vpDatePosted = static_cast<GncDate *>(subObj);
       break;
     case ENTERED:
       m_vpDateEntered = static_cast<GncDate *>(subObj);
       break;
     case SPLIT:
       m_splitList.append(subObj);
       break;
     case KVP:
       m_kvpList.append(*(static_cast <GncKvp*>(subObj)));
   }
   return ;
 }
 
 void GncTransaction::terminate()
 {
   TRY {
     if (isTemplate()) {
       pMain->saveTemplateTransaction(this);
     } else {
       pMain->convertTransaction(this);
     }
     return ;
   }
   PASS
 }
 //************* GncSplit********************************************
 GncSplit::GncSplit()
 {
   m_subElementListCount = END_Split_SELS;
   static const QString subEls[] = {"split:reconcile-date"};
   m_subElementList = subEls;
   m_dataElementListCount = END_Split_DELS;
   static const QString dataEls[] = {"split:id", "split:memo", "split:reconciled-state", "split:value",
                                     "split:quantity", "split:account"
                                    };
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, SUPPRESS, ASIS, MONEY1, MONEY1, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
   m_vpDateReconciled = 0;
 }
 
 GncSplit::~GncSplit()
 {
   delete m_vpDateReconciled;
 }
 
 GncObject *GncSplit::startSubEl()
 {
   TRY {
     GncObject *next = 0;
     switch (m_state) {
       case RECDATE:
         next = new GncDate;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncTemplateSplit rcvd invalid m_state ");
+        throw MYMONEYEXCEPTION_CSTRING("GncTemplateSplit rcvd invalid m_state ");
     }
     return (next);
   }
   PASS
 }
 
 void GncSplit::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Split end subel");
   switch (m_state) {
     case RECDATE:
       m_vpDateReconciled = static_cast<GncDate *>(subObj);
       break;
   }
   return ;
 }
 //************* GncTemplateSplit********************************************
 GncTemplateSplit::GncTemplateSplit()
 {
   m_subElementListCount = END_TemplateSplit_SELS;
   static const QString subEls[] = {"slot"};
   m_subElementList = subEls;
   m_dataElementListCount = END_TemplateSplit_DELS;
   static const QString dataEls[] = {"split:id", "split:memo", "split:reconciled-state", "split:value",
                                     "split:quantity", "split:account"
                                    };
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, SUPPRESS, ASIS, MONEY1, MONEY1, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncTemplateSplit::~GncTemplateSplit() {}
 
 GncObject *GncTemplateSplit::startSubEl()
 {
   if (pMain->xmldebug) qDebug("TemplateSplit start subel m_state %d", m_state);
   TRY {
     GncObject *next = 0;
     switch (m_state) {
       case KVP:
         next = new GncKvp;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncTemplateSplit rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncTemplateSplit rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncTemplateSplit::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("TemplateSplit end subel");
   m_kvpList.append(*(static_cast <GncKvp*>(subObj)));
   m_dataPtr = 0;
   return ;
 }
 //************* GncSchedule********************************************
 GncSchedule::GncSchedule()
 {
   m_subElementListCount = END_Schedule_SELS;
   static const QString subEls[] = {"sx:start", "sx:last", "sx:end", "gnc:freqspec", "gnc:recurrence", "sx:deferredInstance"};
   m_subElementList = subEls;
   m_dataElementListCount = END_Schedule_DELS;
   static const QString dataEls[] = {"sx:name", "sx:enabled", "sx:autoCreate", "sx:autoCreateNotify",
                                     "sx:autoCreateDays", "sx:advanceCreateDays", "sx:advanceRemindDays",
                                     "sx:instanceCount", "sx:num-occur",
                                     "sx:rem-occur", "sx:templ-acct"
                                    };
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {NXTSCHD, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
   m_vpStartDate = m_vpLastDate = m_vpEndDate = 0;
   m_vpFreqSpec = 0;
   m_vpRecurrence.clear();
   m_vpSchedDef = 0;
 }
 
 GncSchedule::~GncSchedule()
 {
   delete m_vpStartDate; delete m_vpLastDate; delete m_vpEndDate; delete m_vpFreqSpec; delete m_vpSchedDef;
 }
 
 GncObject *GncSchedule::startSubEl()
 {
   if (pMain->xmldebug) qDebug("Schedule start subel m_state %d", m_state);
   TRY {
     GncObject *next = 0;
     switch (m_state) {
       case STARTDATE:
       case LASTDATE:
       case ENDDATE:
         next = new GncDate;
         break;
       case FREQ:
         next = new GncFreqSpec;
         break;
       case RECURRENCE:
         next = new GncRecurrence;
         break;
       case DEFINST:
         next = new GncSchedDef;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncSchedule rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncSchedule rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncSchedule::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Schedule end subel");
   switch (m_state) {
     case STARTDATE:
       m_vpStartDate = static_cast<GncDate *>(subObj);
       break;
     case LASTDATE:
       m_vpLastDate = static_cast<GncDate *>(subObj);
       break;
     case ENDDATE:
       m_vpEndDate = static_cast<GncDate *>(subObj);
       break;
     case FREQ:
       m_vpFreqSpec = static_cast<GncFreqSpec *>(subObj);
       break;
     case RECURRENCE:
       m_vpRecurrence.append(static_cast<GncRecurrence *>(subObj));
       break;
     case DEFINST:
       m_vpSchedDef = static_cast<GncSchedDef *>(subObj);
       break;
   }
   return ;
 }
 
 void GncSchedule::terminate()
 {
   TRY {
     pMain->convertSchedule(this);
     return ;
   }
   PASS
 }
 //************* GncFreqSpec********************************************
 GncFreqSpec::GncFreqSpec()
 {
   m_subElementListCount = END_FreqSpec_SELS;
   static const QString subEls[] = {"gnc:freqspec"};
   m_subElementList = subEls;
   m_dataElementListCount = END_FreqSpec_DELS;
   static const QString dataEls[] = {"fs:ui_type", "fs:monthly", "fs:daily", "fs:weekly", "fs:interval",
                                     "fs:offset", "fs:day"
                                    };
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, ASIS, ASIS, ASIS, ASIS, ASIS, ASIS      };
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncFreqSpec::~GncFreqSpec() {}
 
 GncObject *GncFreqSpec::startSubEl()
 {
   TRY {
     if (pMain->xmldebug) qDebug("FreqSpec start subel m_state %d", m_state);
 
     GncObject *next = 0;
     switch (m_state) {
       case COMPO:
         next = new GncFreqSpec;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncFreqSpec rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncFreqSpec rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncFreqSpec::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("FreqSpec end subel");
   switch (m_state) {
     case COMPO:
       m_fsList.append(subObj);
       break;
   }
   m_dataPtr = 0;
   return ;
 }
 
 void GncFreqSpec::terminate()
 {
   pMain->convertFreqSpec(this);
   return ;
 }
 //************* GncRecurrence********************************************
 GncRecurrence::GncRecurrence() :
     m_vpStartDate(0)
 {
   m_subElementListCount = END_Recurrence_SELS;
   static const QString subEls[] = {"recurrence:start"};
   m_subElementList = subEls;
   m_dataElementListCount = END_Recurrence_DELS;
   static const QString dataEls[] = {"recurrence:mult", "recurrence:period_type"};
   m_dataElementList = dataEls;
   static const unsigned int anonClasses[] = {ASIS, ASIS};
   m_anonClassList = anonClasses;
   for (uint i = 0; i < m_dataElementListCount; i++) m_v.append(QString());
 }
 
 GncRecurrence::~GncRecurrence()
 {
   delete m_vpStartDate;
 }
 
 GncObject *GncRecurrence::startSubEl()
 {
   TRY {
     if (pMain->xmldebug) qDebug("Recurrence start subel m_state %d", m_state);
 
     GncObject *next = 0;
     switch (m_state) {
       case STARTDATE:
         next = new GncDate;
         break;
       default:
-        throw MYMONEYEXCEPTION("GncRecurrence rcvd invalid m_state");
+        throw MYMONEYEXCEPTION_CSTRING("GncRecurrence rcvd invalid m_state");
     }
     return (next);
   }
   PASS
 }
 
 void GncRecurrence::endSubEl(GncObject *subObj)
 {
   if (pMain->xmldebug) qDebug("Recurrence end subel");
   switch (m_state) {
     case STARTDATE:
       m_vpStartDate = static_cast<GncDate *>(subObj);
       break;
   }
   m_dataPtr = 0;
   return ;
 }
 
 void GncRecurrence::terminate()
 {
   pMain->convertRecurrence(this);
   return ;
 }
 
 QString GncRecurrence::getFrequency() const
 {
   // This function converts a gnucash 2.2 recurrence specification into it's previous equivalent
   // This will all need re-writing when MTE finishes the schedule re-write
   if (periodType() == "once") return("once");
   if ((periodType() == "day") && (mult() == "1")) return("daily");
   if (periodType() == "week") {
     if (mult() == "1") return ("weekly");
     if (mult() == "2") return ("bi_weekly");
     if (mult() == "4") return ("four-weekly");
   }
   if (periodType() == "month") {
     if (mult() == "1") return ("monthly");
     if (mult() == "2") return ("two-monthly");
     if (mult() == "3") return ("quarterly");
     if (mult() == "4") return ("tri_annually");
     if (mult() == "6") return ("semi_yearly");
     if (mult() == "12") return ("yearly");
     if (mult() == "24") return ("two-yearly");
   }
   return ("unknown");
 }
 
 //************* GncSchedDef********************************************
 GncSchedDef::GncSchedDef()
 {
   // process ing for this sub-object is undefined at the present time
   m_subElementListCount = 0;
   m_dataElementListCount = 0;
 }
 
 GncSchedDef::~GncSchedDef() {}
 
 /************************************************************************************************
                          XML Reader
 ************************************************************************************************/
 XmlReader::XmlReader(MyMoneyGncReader *pM) :
     m_source(0),
     m_reader(0),
     m_co(0),
     pMain(pM),
     m_headerFound(false)
 {
 }
 
 void XmlReader::processFile(QIODevice* pDevice)
 {
   m_source = new QXmlInputSource(pDevice);  // set up the Qt XML reader
   m_reader = new QXmlSimpleReader;
   m_reader->setContentHandler(this);
   // go read the file
-  if (!m_reader->parse(m_source)) {
-    throw MYMONEYEXCEPTION(i18n("Input file cannot be parsed; may be corrupt\n%1", errorString()));
-  }
+  if (!m_reader->parse(m_source))
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Input file cannot be parsed; may be corrupt\n%1").arg(errorString()));
+
   delete m_reader;
   delete m_source;
   return ;
 }
 
 // XML handling routines
 bool XmlReader::startDocument()
 {
   m_co = new GncFile; // create initial object, push to stack , pass it the 'main' pointer
   m_os.push(m_co);
   m_co->setPm(pMain);
   m_headerFound = false;
 #ifdef _GNCFILEANON
   pMain->oStream << "<?xml version=\"1.0\"?>";
   lastType = -1;
   indentCount = 0;
 #endif // _GNCFILEANON
   return (true);
 }
 
 bool XmlReader::startElement(const QString&, const QString&, const QString& elName ,
                              const QXmlAttributes& elAttrs)
 {
   try {
     if (pMain->gncdebug) qDebug() << "XML start -" << elName;
 #ifdef _GNCFILEANON
     int i;
     QString spaces;
     // anonymizer - write data
     if (elName == "gnc:book" || elName == "gnc:count-data" || elName == "book:id") lastType = -1;
     pMain->oStream << endl;
     switch (lastType) {
       case 0:
         indentCount += 2;
         // tricky fall through here
 
       case 2:
         spaces.fill(' ', indentCount);
         pMain->oStream << spaces.toLatin1();
         break;
     }
     pMain->oStream << '<' << elName;
     for (i = 0; i < elAttrs.count(); ++i) {
       pMain->oStream << ' ' << elAttrs.qName(i) << '='  << '"' << elAttrs.value(i) << '"';
     }
     pMain->oStream << '>';
     lastType = 0;
 #else
     if ((!m_headerFound) && (elName != "gnc-v2"))
-      throw MYMONEYEXCEPTION(i18n("Invalid header for file. Should be 'gnc-v2'"));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Invalid header for file. Should be 'gnc-v2'"));
     m_headerFound = true;
 #endif // _GNCFILEANON
     m_co->checkVersion(elName, elAttrs, pMain->m_versionList);
     // check if this is a sub object element; if so, push stack and initialize
     GncObject *temp = m_co->isSubElement(elName, elAttrs);
     if (temp != 0) {
       m_os.push(temp);
       m_co = m_os.top();
       m_co->setVersion(elAttrs.value("version"));
       m_co->setPm(pMain);  // pass the 'main' pointer to the sub object
       // return true;   // removed, as we hit a return true anyway
     }
 #if 0
     // check for a data element
     if (m_co->isDataElement(elName, elAttrs))
       return (true);
 #endif
     else {
       // reduced the above to
       m_co->isDataElement(elName, elAttrs);
     }
   } catch (const MyMoneyException &e) {
 #ifndef _GNCFILEANON
     // we can't pass on exceptions here coz the XML reader won't catch them and we just abort
-    KMessageBox::error(0, i18n("Import failed:\n\n%1", e.what()), PACKAGE);
-    qWarning("%s", qPrintable(e.what()));
+    KMessageBox::error(0, i18n("Import failed:\n\n%1", QString::fromLatin1(e.what())), PACKAGE);
+    qWarning("%s", e.what());
 #else
     qWarning("%s", e->toLatin1());
 #endif // _GNCFILEANON
   }
   return true; // to keep compiler happy
 }
 
 bool XmlReader::endElement(const QString&, const QString&, const QString&elName)
 {
   try {
     if (pMain->xmldebug) qDebug() << "XML end -" << elName;
 #ifdef _GNCFILEANON
     QString spaces;
     switch (lastType) {
       case 2:
         indentCount -= 2;
         spaces.fill(' ', indentCount);
         pMain->oStream << endl << spaces.toLatin1();
         break;
     }
     pMain->oStream << "</" << elName << '>' ;
     lastType = 2;
 #endif // _GNCFILEANON
     m_co->resetDataPtr(); // so we don't get extraneous data loaded into the variables
     if (elName == m_co->getElName()) { // check if this is the end of the current object
       if (pMain->gncdebug) m_co->debugDump(); // dump the object data (temp)
       // call the terminate routine, pop the stack, and advise the parent that it's done
       m_co->terminate();
       GncObject *temp = m_co;
       m_os.pop();
       m_co = m_os.top();
       m_co->endSubEl(temp);
     }
     return (true);
   } catch (const MyMoneyException &e) {
 #ifndef _GNCFILEANON
     // we can't pass on exceptions here coz the XML reader won't catch them and we just abort
-    KMessageBox::error(0, i18n("Import failed:\n\n%1", e.what()), PACKAGE);
-    qWarning("%s", qPrintable(e.what()));
+    KMessageBox::error(0, i18n("Import failed:\n\n%1", QString::fromLatin1(e.what())), PACKAGE);
+    qWarning("%s", e.what());
 #else
     qWarning("%s", e->toLatin1());
 #endif // _GNCFILEANON
   }
   return (true); // to keep compiler happy
 }
 
 bool XmlReader::characters(const QString &data)
 {
   if (pMain->xmldebug) qDebug("XML Data received - %d bytes", data.length());
   QString pData = data.trimmed(); // data may contain line feeds and indentation spaces
   if (!pData.isEmpty()) {
     if (pMain->developerDebug) qDebug() << "XML Data -" << pData;
     m_co->storeData(pData);  //go store it
 #ifdef _GNCFILEANON
     QString anonData = m_co->getData();
     if (anonData.isEmpty()) anonData = pData;
     // there must be a Qt standard way of doing the following but I can't ... find it
     anonData.replace('<', "&lt;");
     anonData.replace('>', "&gt;");
     anonData.replace('&', "&amp;");
     pMain->oStream << anonData; // write original data
     lastType = 1;
 #endif // _GNCFILEANON
   }
   return (true);
 }
 
 bool XmlReader::endDocument()
 {
 #ifdef _GNCFILEANON
   pMain->oStream << endl << endl;
   pMain->oStream << "<!-- Local variables: -->" << endl;
   pMain->oStream << "<!-- mode: xml        -->" << endl;
   pMain->oStream << "<!-- End:             -->" << endl;
 #endif // _GNCFILEANON
   return (true);
 }
 
 /*******************************************************************************************
                                  Main class for this module
   Controls overall operation of the importer
 ********************************************************************************************/
 //***************** Constructor ***********************
 MyMoneyGncReader::MyMoneyGncReader() :
     m_dropSuspectSchedules(0),
     m_investmentOption(0),
     m_useFinanceQuote(0),
     m_useTxNotes(0),
     gncdebug(0),
     xmldebug(0),
     bAnonymize(0),
     developerDebug(0),
     m_xr(0),
     m_progressCallback(0),
     m_ccCount(0),
     m_orCount(0),
     m_scCount(0),
     m_potentialTransfer(0),
     m_suspectSchedule(false)
 {
 #ifndef _GNCFILEANON
   m_storage = 0;
 #endif // _GNCFILEANON
 // to hold gnucash count data (only used for progress bar)
   m_gncCommodityCount = m_gncAccountCount = m_gncTransactionCount = m_gncScheduleCount = 0;
   m_smallBusinessFound = m_budgetsFound = m_lotsFound = false;
   m_commodityCount = m_priceCount = m_accountCount = m_transactionCount = m_templateCount = m_scheduleCount = 0;
   m_decoder = 0;
   // build a list of valid versions
   static const QString versionList[] = {"gnc:book 2.0.0", "gnc:commodity 2.0.0", "gnc:pricedb 1",
                                         "gnc:account 2.0.0", "gnc:transaction 2.0.0", "gnc:schedxaction 1.0.0",
                                         "gnc:schedxaction 2.0.0", // for gnucash 2.2 onward
                                         "gnc:freqspec 1.0.0", "zzz" // zzz = stopper
                                        };
   unsigned int i;
   for (i = 0; versionList[i] != "zzz"; ++i)
     m_versionList[versionList[i].section(' ', 0, 0)].append(versionList[i].section(' ', 1, 1));
 }
 
 //***************** Destructor *************************
 MyMoneyGncReader::~MyMoneyGncReader() {}
 
 //**************************** Main Entry Point ************************************
 #ifndef _GNCFILEANON
 void MyMoneyGncReader::readFile(QIODevice* pDevice, MyMoneyStorageMgr* storage)
 {
   Q_CHECK_PTR(pDevice);
   Q_CHECK_PTR(storage);
 
   m_storage = storage;
   qDebug("Entering gnucash importer");
   setOptions();
   // get a file anonymization factor from the user
   if (bAnonymize) setFileHideFactor();
   //m_defaultPayee = createPayee (i18n("Unknown payee"));
 
   MyMoneyFile::instance()->attachStorage(m_storage);
   loadAllCurrencies();
   MyMoneyFileTransaction ft;
   m_xr = new XmlReader(this);
   bool blocked = MyMoneyFile::instance()->signalsBlocked();
   MyMoneyFile::instance()->blockSignals(true);
   try {
     m_xr->processFile(pDevice);
     terminate();  // do all the wind-up things
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::error(0, i18n("Import failed:\n\n%1", e.what()), PACKAGE);
-    qWarning("%s", qPrintable(e.what()));
+    KMessageBox::error(0, i18n("Import failed:\n\n%1", QString::fromLatin1(e.what())), PACKAGE);
+    qWarning("%s", e.what());
   } // end catch
   MyMoneyFile::instance()->blockSignals(blocked);
   MyMoneyFile::instance()->detachStorage(m_storage);
   signalProgress(0, 1, i18n("Import complete"));  // switch off progress bar
   delete m_xr;
   signalProgress(0, 1, i18nc("Application is ready to use", "Ready.")); // application is ready for input
   qDebug("Exiting gnucash importer");
 }
 #else
 // Control code for the file anonymizer
 void MyMoneyGncReader::readFile(QString in, QString out)
 {
   QFile pDevice(in);
   if (!pDevice.open(QIODevice::ReadOnly)) qWarning("Can't open input file");
   QFile outFile(out);
   if (!outFile.open(QIODevice::WriteOnly)) qWarning("Can't open output file");
   oStream.setDevice(&outFile);
   bAnonymize = true;
   // get a file anonymization factor from the user
   setFileHideFactor();
   m_xr = new XmlReader(this);
   try {
     m_xr->processFile(&pDevice);
   } catch (const MyMoneyException &e) {
     qWarning("%s", e->toLatin1());
   } // end catch
   delete m_xr;
   pDevice.close();
   outFile.close();
   return ;
 }
 
 #include <QApplication>
 int main(int argc, char ** argv)
 {
   QApplication a(argc, argv);
   MyMoneyGncReader m;
   QString inFile, outFile;
 
   if (argc > 0) inFile = a.argv()[1];
   if (argc > 1) outFile = a.argv()[2];
   if (inFile.isEmpty()) {
     inFile = KFileDialog::getOpenFileName("",
                                           "Gnucash files(*.nc *)",
                                           0);
   }
   if (inFile.isEmpty()) qWarning("Input file required");
   if (outFile.isEmpty()) outFile = inFile + ".anon";
   m.readFile(inFile, outFile);
   exit(0);
 }
 #endif // _GNCFILEANON
 
 void MyMoneyGncReader::setFileHideFactor()
 {
 #define MINFILEHIDEF 0.01
 #define MAXFILEHIDEF 99.99
 #if QT_VERSION >= 0x051000
   m_fileHideFactor = 0.0;
   while (m_fileHideFactor == 0.0) {
     m_fileHideFactor = QInputDialog::getDouble(0,
                          i18n("Disguise your wealth"),
                          i18n("Each monetary value on your file will be multiplied by a random number between 0.01 and 1.99\n"
                               "with a different value used for each transaction. In addition, to further disguise the true\n"
                               "values, you may enter a number between %1 and %2 which will be applied to all values.\n"
                               "These numbers will not be stored in the file.", MINFILEHIDEF, MAXFILEHIDEF),
                          (1.0 + (int)(1000.0 * QRandomGenerator::system()->generate() / (RAND_MAX + 1.0))) / 100.0,
                          MINFILEHIDEF, MAXFILEHIDEF, 2);
   }
 #else
   srand(QTime::currentTime().second());  // seed randomizer for anonymize
   m_fileHideFactor = 0.0;
   while (m_fileHideFactor == 0.0) {
     m_fileHideFactor = QInputDialog::getDouble(0,
                          i18n("Disguise your wealth"),
                          i18n("Each monetary value on your file will be multiplied by a random number between 0.01 and 1.99\n"
                               "with a different value used for each transaction. In addition, to further disguise the true\n"
                               "values, you may enter a number between %1 and %2 which will be applied to all values.\n"
                               "These numbers will not be stored in the file.", MINFILEHIDEF, MAXFILEHIDEF),
                          (1.0 + (int)(1000.0 * rand() / (RAND_MAX + 1.0))) / 100.0,
                          MINFILEHIDEF, MAXFILEHIDEF, 2);
   }
 #endif
 }
 #ifndef _GNCFILEANON
 
 //********************************* convertCommodity *******************************************
 void MyMoneyGncReader::convertCommodity(const GncCommodity *gcm)
 {
   Q_CHECK_PTR(gcm);
   MyMoneySecurity equ;
   if (m_commodityCount == 0) signalProgress(0, m_gncCommodityCount, i18n("Loading commodities..."));
   if (!gcm->isCurrency()) { // currencies should not be present here but...
     equ.setName(gcm->name());
     equ.setTradingSymbol(gcm->id());
     equ.setTradingMarket(gcm->space());  // the 'space' may be market or quote source, dep on what the user did
     // don't set the source here since he may not want quotes
     //equ.setValue ("kmm-online-source", gcm->space()); // we don't know, so use it as both
     equ.setTradingCurrency("");  // not available here, will set from pricedb or transaction
     equ.setSecurityType(Security::Type::Stock);  // default to it being a stock
     //tell the storage objects we have a new equity object.
     equ.setSmallestAccountFraction(gcm->fraction().toInt());
     m_storage->addSecurity(equ);
 
     //assign the gnucash id as the key into the map to find our id
     if (gncdebug) qDebug() << "mapping, key =" << gcm->id() << "id =" << equ.id();
     m_mapEquities[gcm->id().toUtf8()] = equ.id();
   }
   signalProgress(++m_commodityCount, 0);
   return ;
 }
 
 //******************************* convertPrice ************************************************
 void MyMoneyGncReader::convertPrice(const GncPrice *gpr)
 {
   Q_CHECK_PTR(gpr);
   // add this to our price history
   if (m_priceCount == 0) signalProgress(0, 1, i18n("Loading prices..."));
   MyMoneyMoney rate(convBadValue(gpr->value()));
   if (gpr->commodity()->isCurrency()) {
     MyMoneyPrice exchangeRate(gpr->commodity()->id().toUtf8(), gpr->currency()->id().toUtf8(),
                               gpr->priceDate(), rate, i18n("Imported History"));
     if (!exchangeRate.rate(QString()).isZero())
       m_storage->addPrice(exchangeRate);
   } else {
     MyMoneySecurity e = m_storage->security(m_mapEquities[gpr->commodity()->id().toUtf8()]);
     if (gncdebug) qDebug() << "Searching map, key = " << gpr->commodity()->id()
       << ", found id =" << e.id().data();
     e.setTradingCurrency(gpr->currency()->id().toUtf8());
     MyMoneyPrice stockPrice(e.id(), gpr->currency()->id().toUtf8(), gpr->priceDate(), rate, i18n("Imported History"));
     if (!stockPrice.rate(QString()).isZero())
       m_storage->addPrice(stockPrice);
     m_storage->modifySecurity(e);
   }
   signalProgress(++m_priceCount, 0);
   return ;
 }
 
 //*********************************convertAccount ****************************************
 void MyMoneyGncReader::convertAccount(const GncAccount* gac)
 {
   Q_CHECK_PTR(gac);
   TRY {
     // we don't care about the GNC root account
     if ("ROOT" == gac->type()) {
       m_rootId = gac->id().toUtf8();
       return;
     }
 
     MyMoneyAccount acc;
     if (m_accountCount == 0) signalProgress(0, m_gncAccountCount, i18n("Loading accounts..."));
     acc.setName(gac->name());
 
     acc.setDescription(gac->desc());
 
     QDate currentDate = QDate::currentDate();
     acc.setOpeningDate(currentDate);
     acc.setLastModified(currentDate);
     acc.setLastReconciliationDate(currentDate);
     if (gac->commodity()->isCurrency()) {
       acc.setCurrencyId(gac->commodity()->id().toUtf8());
       m_currencyCount[gac->commodity()->id()]++;
     }
 
     acc.setParentAccountId(gac->parent().toUtf8());
     // now determine the account type and its parent id
     /* This list taken from
     # Feb 2006: A RELAX NG Compact schema for gnucash "v2" XML files.
     # Copyright (C) 2006 Joshua Sled <jsled@asynchronous.org>
     "NO_TYPE" "BANK" "CASH" "CREDIT" "ASSET" "LIABILITY" "STOCK" "MUTUAL" "CURRENCY"
     "INCOME" "EXPENSE" "EQUITY" "RECEIVABLE" "PAYABLE" "CHECKING" "SAVINGS" "MONEYMRKT" "CREDITLINE"
     Some don't seem to be used in practice. Not sure what CREDITLINE s/be converted as.
     */
     if ("BANK" == gac->type() || "CHECKING" == gac->type()) {
       acc.setAccountType(Account::Type::Checkings);
     } else if ("SAVINGS" == gac->type()) {
       acc.setAccountType(Account::Type::Savings);
     } else if ("ASSET" == gac->type()) {
       acc.setAccountType(Account::Type::Asset);
     } else if ("CASH" == gac->type()) {
       acc.setAccountType(Account::Type::Cash);
     } else if ("CURRENCY" == gac->type()) {
       acc.setAccountType(Account::Type::Cash);
     } else if ("STOCK" == gac->type() || "MUTUAL" == gac->type()) {
       // gnucash allows a 'broker' account to be denominated as type STOCK, but with
       // a currency balance. We do not need to create a stock account for this
       // actually, the latest version of gnc (1.8.8) doesn't seem to allow you to do
       // this any more, though I do have one in my own account...
       if (gac->commodity()->isCurrency()) {
         acc.setAccountType(Account::Type::Investment);
       } else {
         acc.setAccountType(Account::Type::Stock);
       }
     } else if ("EQUITY" == gac->type()) {
       acc.setAccountType(Account::Type::Equity);
     } else if ("LIABILITY" == gac->type()) {
       acc.setAccountType(Account::Type::Liability);
     } else if ("CREDIT" == gac->type()) {
       acc.setAccountType(Account::Type::CreditCard);
     } else if ("INCOME" == gac->type()) {
       acc.setAccountType(Account::Type::Income);
     } else if ("EXPENSE" == gac->type()) {
       acc.setAccountType(Account::Type::Expense);
     } else if ("RECEIVABLE" == gac->type()) {
       acc.setAccountType(Account::Type::Asset);
     } else if ("PAYABLE" == gac->type()) {
       acc.setAccountType(Account::Type::Liability);
     } else if ("MONEYMRKT" == gac->type()) {
       acc.setAccountType(Account::Type::MoneyMarket);
     } else { // we have here an account type we can't currently handle
-      QString em =
-        i18n("Current importer does not recognize GnuCash account type %1", gac->type());
-      throw MYMONEYEXCEPTION(em);
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Current importer does not recognize GnuCash account type %1").arg(gac->type()));
     }
     // if no parent account is present, assign to one of our standard accounts
     if ((acc.parentAccountId().isEmpty()) || (acc.parentAccountId() == m_rootId)) {
       switch (acc.accountGroup()) {
         case Account::Type::Asset:
           acc.setParentAccountId(m_storage->asset().id());
           break;
         case Account::Type::Liability:
           acc.setParentAccountId(m_storage->liability().id());
           break;
         case Account::Type::Income:
           acc.setParentAccountId(m_storage->income().id());
           break;
         case Account::Type::Expense:
           acc.setParentAccountId(m_storage->expense().id());
           break;
         case Account::Type::Equity:
           acc.setParentAccountId(m_storage->equity().id());
           break;
         default:
           break; // not necessary but avoids compiler warnings
       }
     }
 
     // extra processing for a stock account
     if (acc.accountType() == Account::Type::Stock) {
       // save the id for later linking to investment account
       m_stockList.append(gac->id());
       // set the equity type
       MyMoneySecurity e = m_storage->security(m_mapEquities[gac->commodity()->id().toUtf8()]);
       if (gncdebug) qDebug() << "Acct equity search, key =" << gac->commodity()->id()
         << "found id =" << e.id();
       acc.setCurrencyId(e.id());  // actually, the security id
       if ("MUTUAL" == gac->type()) {
         e.setSecurityType(Security::Type::MutualFund);
         if (gncdebug) qDebug() << "Setting" << e.name() << "to mutual";
         m_storage->modifySecurity(e);
       }
 
       QString priceSource = gac->getKvpValue("price-source", "string");
       if (!priceSource.isEmpty()) getPriceSource(e, priceSource);
     }
 
     if (gac->getKvpValue("tax-related", "integer") == QChar('1')) acc.setValue("Tax", "Yes");
     // all the details from the file about the account should be known by now.
     // calling addAccount will automatically fill in the account ID.
     m_storage->addAccount(acc);
     m_mapIds[gac->id().toUtf8()] = acc.id(); // to link gnucash id to ours for tx posting
 
     if (gncdebug)
       qDebug() << "Gnucash account" << gac->id() << "has id of" << acc.id()
       << ", type of" << MyMoneyAccount::accountTypeToString(acc.accountType())
       << "parent is" << acc.parentAccountId();
 
     signalProgress(++m_accountCount, 0);
     return ;
   }
   PASS
 }
 
 //********************************************** convertTransaction *****************************
 void MyMoneyGncReader::convertTransaction(const GncTransaction *gtx)
 {
   Q_CHECK_PTR(gtx);
   MyMoneyTransaction tx;
   MyMoneySplit split;
   unsigned int i;
 
   if (m_transactionCount == 0) signalProgress(0, m_gncTransactionCount, i18n("Loading transactions..."));
   // initialize class variables related to transactions
   m_txCommodity = "";
   m_txPayeeId = "";
   m_potentialTransfer = true;
   m_splitList.clear(); m_liabilitySplitList.clear(); m_otherSplitList.clear();
   // payee, dates, commodity
   if (!gtx->desc().isEmpty()) m_txPayeeId = createPayee(gtx->desc());
   tx.setEntryDate(gtx->dateEntered());
   tx.setPostDate(gtx->datePosted());
   m_txDatePosted = tx.postDate(); // save for use in splits
   m_txChequeNo = gtx->no(); // ditto
   tx.setCommodity(gtx->currency().toUtf8());
   m_txCommodity = tx.commodity(); // save in storage, maybe needed for Orphan accounts
   // process splits
   for (i = 0; i < gtx->splitCount(); i++) {
     convertSplit(static_cast<const GncSplit *>(gtx->getSplit(i)));
   }
   // handle the odd case of just one split, which gnc allows,
   // by just duplicating the split
   // of course, we should change the sign but this case has only ever been seen
   // when the balance is zero, and can cause kmm to crash, so...
   if (gtx->splitCount() == 1) {
     convertSplit(static_cast<const GncSplit *>(gtx->getSplit(0)));
   }
   m_splitList += m_liabilitySplitList += m_otherSplitList;
   // the splits are in order in splitList. Link them to the tx. also, determine the
   // action type, and fill in some fields which gnc holds at transaction level
   // first off, is it a transfer (can only have 2 splits?)
   // also, a tx with just 2 splits is shown by GnuCash as non-split
   bool nonSplitTx = true;
   if (m_splitList.count() != 2) {
     m_potentialTransfer = false;
     nonSplitTx = false;
   }
   QString slotMemo = gtx->getKvpValue(QString("notes"));
   if (!slotMemo.isEmpty())  tx.setMemo(slotMemo);
 
   QList<MyMoneySplit>::iterator it = m_splitList.begin();
   while (!m_splitList.isEmpty()) {
     split = *it;
     // at this point, if m_potentialTransfer is still true, it is actually one!
     if (m_potentialTransfer) split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer));
     if ((m_useTxNotes) // if use txnotes option is set
         && (nonSplitTx) // and it's a (GnuCash) non-split transaction
         && (!tx.memo().isEmpty())) // and tx notes are present
       split.setMemo(tx.memo());  // use the tx notes as memo
     tx.addSplit(split);
     it = m_splitList.erase(it);
   }
   m_storage->addTransaction(tx, true); // all done, add the transaction to storage
   signalProgress(++m_transactionCount, 0);
   return ;
 }
 //******************************************convertSplit********************************
 void MyMoneyGncReader::convertSplit(const GncSplit *gsp)
 {
   Q_CHECK_PTR(gsp);
   MyMoneySplit split;
   MyMoneyAccount splitAccount;
   // find the kmm account id corresponding to the gnc id
   QString kmmAccountId;
   map_accountIds::const_iterator id = m_mapIds.constFind(gsp->acct().toUtf8());
   if (id != m_mapIds.constEnd()) {
     kmmAccountId = id.value();
   } else { // for the case where the acs not found (which shouldn't happen?), create an account with gnc name
     kmmAccountId = createOrphanAccount(gsp->acct());
   }
   // find the account pointer and save for later
   splitAccount = m_storage->account(kmmAccountId);
   // print some data so we can maybe identify this split later
   // TODO : prints personal data
   //if (gncdebug) qDebug ("Split data - gncid %s, kmmid %s, memo %s, value %s, recon state %s",
   //                        gsp->acct().toLatin1(), kmmAccountId.data(), gsp->memo().toLatin1(), gsp->value().toLatin1(),
   //                        gsp->recon().toLatin1());
   // payee id
   split.setPayeeId(m_txPayeeId.toUtf8());
   // reconciled state and date
   switch (gsp->recon().at(0).toLatin1()) {
     case 'n':
       split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
       break;
     case 'c':
       split.setReconcileFlag(eMyMoney::Split::State::Cleared);
       break;
     case 'y':
       split.setReconcileFlag(eMyMoney::Split::State::Reconciled);
       break;
   }
   split.setReconcileDate(gsp->reconDate());
   // memo
   split.setMemo(gsp->memo());
   // accountId
   split.setAccountId(kmmAccountId);
   // cheque no
   split.setNumber(m_txChequeNo);
   // value and quantity
   MyMoneyMoney splitValue(convBadValue(gsp->value()));
   if (gsp->value() == "-1/0") { // treat gnc invalid value as zero
     // it's not quite a consistency check, but easier to treat it as such
     m_messageList["CC"].append
     (i18n("Account or Category %1, transaction date %2; split contains invalid value; please check",
           splitAccount.name(), m_txDatePosted.toString(Qt::ISODate)));
   }
   MyMoneyMoney splitQuantity(convBadValue(gsp->qty()));
   split.setValue(splitValue);
   // if split currency = tx currency, set shares = value (14/10/05)
   if (splitAccount.currencyId() == m_txCommodity) {
     split.setShares(splitValue);
   } else {
     split.setShares(splitQuantity);
   }
 
   // in kmm, the first split is important. in this routine we will
   // save the splits in our split list with the priority:
   // 1. assets
   // 2. liabilities
   // 3. others (categories)
   // but keeping each in same order as gnucash
 
   switch (splitAccount.accountGroup()) {
     case Account::Type::Asset:
       if (splitAccount.accountType() == Account::Type::Stock) {
         split.value().isZero() ?
         split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::AddShares)) :      // free shares?
         split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares));
         m_potentialTransfer = false; // ?
         // add a price history entry
         MyMoneySecurity e = m_storage->security(splitAccount.currencyId());
         MyMoneyMoney price;
         if (!split.shares().isZero()) {
           static const signed64 NEW_DENOM = 10000;
           price = split.value() / split.shares();
           price = MyMoneyMoney(price.toDouble(), NEW_DENOM);
         }
         if (!price.isZero()) {
           TRY {
             // we can't use m_storage->security coz security list is not built yet
             m_storage->currency(m_txCommodity);   // will throw exception if not currency
             e.setTradingCurrency(m_txCommodity);
             if (gncdebug) qDebug() << "added price for" << e.name()
               << price.toString() << "date" << m_txDatePosted.toString(Qt::ISODate);
             m_storage->modifySecurity(e);
             MyMoneyPrice dealPrice(e.id(), m_txCommodity, m_txDatePosted, price, i18n("Imported Transaction"));
             m_storage->addPrice(dealPrice);
           } CATCH {
             // stock transfer; treat like free shares?
             split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::AddShares));
           }
         }
       } else { // not stock
         if (split.value().isNegative()) {
           bool isNumeric = false;
           if (!split.number().isEmpty()) {
             split.number().toLong(&isNumeric);    // No QString.isNumeric()??
           }
           if (isNumeric) {
             split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Check));
           } else {
             split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal));
           }
         } else {
           split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit));
         }
       }
       m_splitList.append(split);
       break;
     case Account::Type::Liability:
       split.value().isNegative() ?
       split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal)) :
       split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit));
       m_liabilitySplitList.append(split);
       break;
     default:
       m_potentialTransfer = false;
       m_otherSplitList.append(split);
   }
 // backdate the account opening date if necessary
   if (m_txDatePosted < splitAccount.openingDate()) {
     splitAccount.setOpeningDate(m_txDatePosted);
     m_storage->modifyAccount(splitAccount);
   }
   return ;
 }
 //********************************* convertTemplateTransaction **********************************************
 MyMoneyTransaction MyMoneyGncReader::convertTemplateTransaction(const QString& schedName, const GncTransaction *gtx)
 {
 
   Q_CHECK_PTR(gtx);
   MyMoneyTransaction tx;
   MyMoneySplit split;
   unsigned int i;
   if (m_templateCount == 0) signalProgress(0, 1, i18n("Loading templates..."));
 
   // initialize class variables related to transactions
   m_txCommodity = "";
   m_txPayeeId = "";
   m_potentialTransfer = true;
   m_splitList.clear(); m_liabilitySplitList.clear(); m_otherSplitList.clear();
 
   // payee, dates, commodity
   if (!gtx->desc().isEmpty()) {
     m_txPayeeId = createPayee(gtx->desc());
   } else {
     m_txPayeeId = createPayee(i18n("Unknown payee"));  // schedules require a payee tho normal tx's don't. not sure why...
   }
   tx.setEntryDate(gtx->dateEntered());
   tx.setPostDate(gtx->datePosted());
   m_txDatePosted = tx.postDate();
   tx.setCommodity(gtx->currency().toUtf8());
   m_txCommodity = tx.commodity(); // save for possible use in orphan account
   // process splits
   for (i = 0; i < gtx->splitCount(); i++) {
     convertTemplateSplit(schedName, static_cast<const GncTemplateSplit *>(gtx->getSplit(i)));
   }
   // determine the action type for the splits and link them to the template tx
 
   if (!m_otherSplitList.isEmpty()) m_potentialTransfer = false; // tfrs can occur only between assets and asset/liabilities
   m_splitList += m_liabilitySplitList += m_otherSplitList;
   // the splits are in order in splitList. Transfer them to the tx
   // also, determine the action type. first off, is it a transfer (can only have 2 splits?)
   if (m_splitList.count() != 2) m_potentialTransfer = false;
   // at this point, if m_potentialTransfer is still true, it is actually one!
   QString txMemo = "";
   QList<MyMoneySplit>::iterator it = m_splitList.begin();
   while (!m_splitList.isEmpty()) {
     split = *it;
     if (m_potentialTransfer) {
       split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer));
     } else {
       if (split.value().isNegative()) {
         //split.setAction (negativeActionType);
         split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal));
       } else {
         //split.setAction (positiveActionType);
         split.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit));
       }
     }
     split.setNumber(gtx->no()); // set cheque no (or equivalent description)
     // Arbitrarily, save the first non-null split memo as the memo for the whole tx
     // I think this is necessary because txs with just 2 splits (the majority)
     // are not viewable as split transactions in kmm so the split memo is not seen
     if ((txMemo.isEmpty()) && (!split.memo().isEmpty())) txMemo = split.memo();
     tx.addSplit(split);
     it = m_splitList.erase(it);
   }
   // memo - set from split
   tx.setMemo(txMemo);
   signalProgress(++m_templateCount, 0);
   return (tx);
 }
 //********************************* convertTemplateSplit ****************************************************
 void MyMoneyGncReader::convertTemplateSplit(const QString& schedName, const GncTemplateSplit *gsp)
 {
   Q_CHECK_PTR(gsp);
   // convertTemplateSplit
   MyMoneySplit split;
   MyMoneyAccount splitAccount;
   unsigned int i, j;
   bool nonNumericFormula = false;
 
   // action, value and account will be set from slots
   // reconcile state, always Not since it hasn't even been posted yet (?)
   split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
   // memo
   split.setMemo(gsp->memo());
   // payee id
   split.setPayeeId(m_txPayeeId.toUtf8());
   // read split slots (KVPs)
   int xactionCount = 0;
   int validSlotCount = 0;
   QString gncAccountId;
   for (i = 0; i < gsp->kvpCount(); i++) {
     const GncKvp& slot = gsp->getKvp(i);
     if ((slot.key() == "sched-xaction") && (slot.type() == "frame")) {
       bool bFoundStringCreditFormula = false;
       bool bFoundStringDebitFormula = false;
       bool bFoundGuidAccountId = false;
       QString gncCreditFormula, gncDebitFormula;
       for (j = 0; j < slot.kvpCount(); j++) {
         const GncKvp& subSlot = slot.getKvp(j);
         // again, see comments above. when we have a full specification
         // of all the options available to us, we can no doubt improve on this
         if ((subSlot.key() == "credit-formula") && (subSlot.type() == "string")) {
           gncCreditFormula = subSlot.value();
           bFoundStringCreditFormula = true;
         }
         if ((subSlot.key() == "debit-formula") && (subSlot.type() == "string")) {
           gncDebitFormula = subSlot.value();
           bFoundStringDebitFormula = true;
         }
         if ((subSlot.key() == "account") && (subSlot.type() == "guid")) {
           gncAccountId = subSlot.value();
           bFoundGuidAccountId = true;
         }
       }
       // all data read, now check we have everything
       if ((bFoundStringCreditFormula) && (bFoundStringDebitFormula) && (bFoundGuidAccountId)) {
         if (gncdebug) qDebug() << "Found valid slot; credit" << gncCreditFormula
           << "debit" << gncDebitFormula << "acct" << gncAccountId;
         validSlotCount++;
       }
       // validate numeric, work out sign
       MyMoneyMoney exFormula;
       exFormula.setNegativeMonetarySignPosition(eMyMoney::Money::BeforeQuantityMoney);
       QString numericTest;
       char crdr = 0 ;
       if (!gncCreditFormula.isEmpty()) {
         crdr = 'C';
         numericTest = gncCreditFormula;
       } else if (!gncDebitFormula.isEmpty()) {
         crdr = 'D';
         numericTest = gncDebitFormula;
       }
       KMyMoneyMoneyValidator v(0);
       int pos; // useless, but required for validator
       if (v.validate(numericTest, pos) == QValidator::Acceptable) {
         switch (crdr) {
           case 'C':
             exFormula = QString("-" + numericTest);
             break;
           case 'D':
             exFormula = numericTest;
         }
       } else {
         if (gncdebug) qDebug() << numericTest << "is not numeric";
         nonNumericFormula = true;
       }
       split.setValue(exFormula);
       xactionCount++;
     } else {
       m_messageList["SC"].append(
         i18n("Schedule %1 contains unknown action (key = %2, type = %3)",
              schedName, slot.key(), slot.type()));
       m_suspectSchedule = true;
     }
   }
   // report this as untranslatable tx
   if (xactionCount > 1) {
     m_messageList["SC"].append(
       i18n("Schedule %1 contains multiple actions; only one has been imported",
            schedName));
     m_suspectSchedule = true;
   }
   if (validSlotCount == 0) {
     m_messageList["SC"].append(
       i18n("Schedule %1 contains no valid splits", schedName));
     m_suspectSchedule = true;
   }
   if (nonNumericFormula) {
     m_messageList["SC"].append(
       i18n("Schedule %1 appears to contain a formula. GnuCash formulae are not convertible",
            schedName));
     m_suspectSchedule = true;
   }
   // find the kmm account id corresponding to the gnc id
   QString kmmAccountId;
   map_accountIds::const_iterator id = m_mapIds.constFind(gncAccountId.toUtf8());
   if (id != m_mapIds.constEnd()) {
     kmmAccountId = id.value();
   } else { // for the case where the acs not found (which shouldn't happen?), create an account with gnc name
     kmmAccountId = createOrphanAccount(gncAccountId);
   }
   splitAccount = m_storage->account(kmmAccountId);
   split.setAccountId(kmmAccountId);
   // if split currency = tx currency, set shares = value (14/10/05)
   if (splitAccount.currencyId() == m_txCommodity) {
     split.setShares(split.value());
   } /* else {  //FIXME: scheduled currency or investment tx needs to be investigated
     split.setShares (splitQuantity);
   }  */
   // add the split to one of the lists
   switch (splitAccount.accountGroup()) {
     case Account::Type::Asset:
       m_splitList.append(split);
       break;
     case Account::Type::Liability:
       m_liabilitySplitList.append(split);
       break;
     default:
       m_otherSplitList.append(split);
   }
   // backdate the account opening date if necessary
   if (m_txDatePosted < splitAccount.openingDate()) {
     splitAccount.setOpeningDate(m_txDatePosted);
     m_storage->modifyAccount(splitAccount);
   }
   return ;
 }
 //********************************* convertSchedule  ********************************************************
 void MyMoneyGncReader::convertSchedule(const GncSchedule *gsc)
 {
   TRY {
     Q_CHECK_PTR(gsc);
     MyMoneySchedule sc;
     MyMoneyTransaction tx;
     m_suspectSchedule = false;
     QDate startDate, nextDate, lastDate, endDate;  // for date calculations
     QDate today = QDate::currentDate();
     int numOccurs, remOccurs;
 
     if (m_scheduleCount == 0) signalProgress(0, m_gncScheduleCount, i18n("Loading schedules..."));
     // schedule name
     sc.setName(gsc->name());
     // find the transaction template as stored earlier
     QList<GncTransaction*>::const_iterator itt;
     for (itt = m_templateList.constBegin(); itt != m_templateList.constEnd(); ++itt) {
       // the id to match against is the split:account value in the splits
       if (static_cast<const GncTemplateSplit *>((*itt)->getSplit(0))->acct() == gsc->templId()) break;
     }
     if (itt == m_templateList.constEnd()) {
-      throw MYMONEYEXCEPTION(i18n("Cannot find template transaction for schedule %1", sc.name()));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Cannot find template transaction for schedule %1").arg(sc.name()));
     } else {
       tx = convertTemplateTransaction(sc.name(), *itt);
     }
     tx.clearId();
 
 // define the conversion table for intervals
     struct convIntvl {
       QString gncType; // the gnucash name
       unsigned char interval; // for date calculation
       unsigned int intervalCount;
       Schedule::Occurrence occ; // equivalent occurrence code
       Schedule::WeekendOption wo;
     };
     /* other intervals supported by gnc according to Josh Sled's schema (see above)
      "none" "semi_monthly"
      */
     /* some of these type names do not appear in gnucash and are difficult to generate for
     pre 2.2 files.They can be generated for 2.2 however, by GncRecurrence::getFrequency() */
     static convIntvl vi [] = {
       {"once", 'o', 1, Schedule::Occurrence::Once, Schedule::WeekendOption::MoveNothing },
       {"daily" , 'd', 1, Schedule::Occurrence::Daily, Schedule::WeekendOption::MoveNothing },
       //{"daily_mf", 'd', 1, Schedule::Occurrence::Daily, Schedule::WeekendOption::MoveAfter }, doesn't work, need new freq in kmm
       {"30-days" , 'd', 30, Schedule::Occurrence::EveryThirtyDays, Schedule::WeekendOption::MoveNothing },
       {"weekly", 'w', 1, Schedule::Occurrence::Weekly, Schedule::WeekendOption::MoveNothing },
       {"bi_weekly", 'w', 2, Schedule::Occurrence::EveryOtherWeek, Schedule::WeekendOption::MoveNothing },
       {"three-weekly", 'w', 3, Schedule::Occurrence::EveryThreeWeeks, Schedule::WeekendOption::MoveNothing },
       {"four-weekly", 'w', 4, Schedule::Occurrence::EveryFourWeeks,
        Schedule::WeekendOption::MoveNothing },
       {"eight-weekly", 'w', 8, Schedule::Occurrence::EveryEightWeeks, Schedule::WeekendOption::MoveNothing },
       {"monthly", 'm', 1, Schedule::Occurrence::Monthly, Schedule::WeekendOption::MoveNothing },
       {"two-monthly", 'm', 2, Schedule::Occurrence::EveryOtherMonth,
        Schedule::WeekendOption::MoveNothing },
       {"quarterly", 'm', 3, Schedule::Occurrence::Quarterly, Schedule::WeekendOption::MoveNothing },
       {"tri_annually", 'm', 4, Schedule::Occurrence::EveryFourMonths, Schedule::WeekendOption::MoveNothing },
       {"semi_yearly", 'm', 6, Schedule::Occurrence::TwiceYearly, Schedule::WeekendOption::MoveNothing },
       {"yearly", 'y', 1, Schedule::Occurrence::Yearly, Schedule::WeekendOption::MoveNothing },
       {"two-yearly", 'y', 2, Schedule::Occurrence::EveryOtherYear,
        Schedule::WeekendOption::MoveNothing },
       {"zzz", 'y', 1, Schedule::Occurrence::Yearly, Schedule::WeekendOption::MoveNothing}
       // zzz = stopper, may cause problems. what else can we do?
     };
 
     QString frequency = "unknown"; // set default to unknown frequency
     bool unknownOccurs = false; // may have zero, or more than one frequency/recurrence spec
     QString schedEnabled;
     if (gsc->version() == "2.0.0") {
       if (gsc->m_vpRecurrence.count() != 1) {
         unknownOccurs = true;
       } else {
         const GncRecurrence *gre = gsc->m_vpRecurrence.first();
         //qDebug (QString("Sched %1, pt %2, mu %3, sd %4").arg(gsc->name()).arg(gre->periodType())
         // .arg(gre->mult()).arg(gre->startDate().toString(Qt::ISODate)));
         frequency = gre->getFrequency();
         schedEnabled = gsc->enabled();
       }
       sc.setOccurrence(Schedule::Occurrence::Once); // FIXME - how to convert
     } else {
       // find this interval
       const GncFreqSpec *fs = gsc->getFreqSpec();
       if (fs == 0) {
         unknownOccurs = true;
       } else {
         frequency = fs->intervalType();
         if (!fs->m_fsList.isEmpty()) unknownOccurs = true; // nested freqspec
       }
       schedEnabled = 'y'; // earlier versions did not have an enable flag
     }
 
     int i;
     for (i = 0; vi[i].gncType != "zzz"; i++) {
       if (frequency == vi[i].gncType) break;
     }
     if (vi[i].gncType == "zzz") {
       m_messageList["SC"].append(
         i18n("Schedule %1 has interval of %2 which is not currently available",
              sc.name(), frequency));
       i = 0; // treat as single occurrence
       m_suspectSchedule = true;
     }
     if (unknownOccurs) {
       m_messageList["SC"].append(
         i18n("Schedule %1 contains unknown interval specification; please check for correct operation",
              sc.name()));
       m_suspectSchedule = true;
     }
     // set the occurrence interval, weekend option, start date
     sc.setOccurrence(vi[i].occ);
     sc.setWeekendOption(vi[i].wo);
     sc.setStartDate(gsc->startDate());
     // if a last date was specified, use it, otherwise try to work out the last date
     sc.setLastPayment(gsc->lastDate());
     numOccurs = gsc->numOccurs().toInt();
     if (sc.lastPayment() == QDate()) {
       nextDate = lastDate = gsc->startDate();
       while ((nextDate < today) && (numOccurs-- != 0)) {
         lastDate = nextDate;
         nextDate = incrDate(lastDate, vi[i].interval, vi[i].intervalCount);
       }
       sc.setLastPayment(lastDate);
     }
     // under Tom's new regime, the tx dates are the next due date (I think)
     tx.setPostDate(incrDate(sc.lastPayment(), vi[i].interval, vi[i].intervalCount));
     tx.setEntryDate(incrDate(sc.lastPayment(), vi[i].interval, vi[i].intervalCount));
     // if an end date was specified, use it, otherwise if the input file had a number
     // of occurs remaining, work out the end date
     sc.setEndDate(gsc->endDate());
     numOccurs = gsc->numOccurs().toInt();
     remOccurs = gsc->remOccurs().toInt();
     if ((sc.endDate() == QDate()) && (remOccurs > 0)) {
       endDate = sc.lastPayment();
       while (remOccurs-- > 0) {
         endDate = incrDate(endDate, vi[i].interval, vi[i].intervalCount);
       }
       sc.setEndDate(endDate);
     }
     // Check for sched deferred interval. Don't know how/if we can handle it, or even what it means...
     if (gsc->getSchedDef() != 0) {
       m_messageList["SC"].append(
         i18n("Schedule %1 contains a deferred interval specification; please check for correct operation",
              sc.name()));
       m_suspectSchedule = true;
     }
     // payment type, options
     sc.setPaymentType((Schedule::PaymentType)Schedule::PaymentType::Other);
     sc.setFixed(!m_suspectSchedule);  // if any probs were found, set it as variable so user will always be prompted
     // we don't currently have a 'disable' option, but just make sure auto-enter is off if not enabled
     //qDebug(QString("%1 and %2").arg(gsc->autoCreate()).arg(schedEnabled));
     sc.setAutoEnter((gsc->autoCreate() == QChar('y')) && (schedEnabled == QChar('y')));
     //qDebug(QString("autoEnter set to %1").arg(sc.autoEnter()));
     // type
     QString actionType = tx.splits().first().action();
     if (actionType == MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit)) {
       sc.setType((Schedule::Type)Schedule::Type::Deposit);
     } else if (actionType == MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer)) {
       sc.setType((Schedule::Type)Schedule::Type::Transfer);
     } else {
       sc.setType((Schedule::Type)Schedule::Type::Bill);
     }
     // finally, set the transaction pointer
     sc.setTransaction(tx);
     //tell the storage objects we have a new schedule object.
     if (m_suspectSchedule && m_dropSuspectSchedules) {
       m_messageList["SC"].append(
         i18n("Schedule %1 dropped at user request", sc.name()));
     } else {
       m_storage->addSchedule(sc);
       if (m_suspectSchedule)
         m_suspectList.append(sc.id());
     }
     signalProgress(++m_scheduleCount, 0);
     return ;
   }
   PASS
 }
 //********************************* convertFreqSpec  ********************************************************
 void MyMoneyGncReader::convertFreqSpec(const GncFreqSpec *)
 {
   // Nowt to do here at the moment, convertSched only retrieves the interval type
   // but we will probably need to look into the nested freqspec when we properly implement semi-monthly and stuff
   return ;
 }
 //********************************* convertRecurrence  ********************************************************
 void MyMoneyGncReader::convertRecurrence(const GncRecurrence *)
 {
   return ;
 }
 
 //**********************************************************************************************************
 //************************************* terminate **********************************************************
 void MyMoneyGncReader::terminate()
 {
   TRY {
     // All data has been converted and added to storage
     // this code is just temporary to show us what is in the file.
     if (gncdebug) qDebug("%d accounts found in the GnuCash file", (unsigned int)m_mapIds.count());
     for (map_accountIds::const_iterator it = m_mapIds.constBegin(); it != m_mapIds.constEnd(); ++it) {
       if (gncdebug) qDebug() << "key ="  << it.key() << "value =" << it.value();
     }
     // first step is to implement the users investment option, now we
     // have all the accounts available
     QList<QString>::iterator stocks;
     for (stocks = m_stockList.begin(); stocks != m_stockList.end(); ++stocks) {
       checkInvestmentOption(*stocks);
     }
     // Next step is to walk the list and assign the parent/child relationship between the objects.
     unsigned int i = 0;
     signalProgress(0, m_accountCount, i18n("Reorganizing accounts..."));
     QList<MyMoneyAccount> list;
     QList<MyMoneyAccount>::iterator acc;
     m_storage->accountList(list);
     for (acc = list.begin(); acc != list.end(); ++acc) {
       if ((*acc).parentAccountId() == m_storage->asset().id()) {
         MyMoneyAccount assets = m_storage->asset();
         m_storage->addAccount(assets, (*acc));
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main asset account";
       } else if ((*acc).parentAccountId() == m_storage->liability().id()) {
         MyMoneyAccount liabilities = m_storage->liability();
         m_storage->addAccount(liabilities, (*acc));
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main liability account";
       } else if ((*acc).parentAccountId() == m_storage->income().id()) {
         MyMoneyAccount incomes = m_storage->income();
         m_storage->addAccount(incomes, (*acc));
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main income account";
       } else if ((*acc).parentAccountId() == m_storage->expense().id()) {
         MyMoneyAccount expenses = m_storage->expense();
         m_storage->addAccount(expenses, (*acc));
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main expense account";
       } else if ((*acc).parentAccountId() == m_storage->equity().id()) {
         MyMoneyAccount equity = m_storage->equity();
         m_storage->addAccount(equity, (*acc));
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main equity account";
       } else if ((*acc).parentAccountId() == m_rootId) {
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of the main root account";
       } else {
         // it is not under one of the main accounts, so find gnucash parent
         QString parentKey = (*acc).parentAccountId();
         if (gncdebug) qDebug() << "Account id" << (*acc).id() << "is a child of " << (*acc).parentAccountId();
         map_accountIds::const_iterator id = m_mapIds.constFind(parentKey);
         if (id != m_mapIds.constEnd()) {
           if (gncdebug)
             qDebug() << "Setting account id" << (*acc).id()
             << "parent account id to" << id.value();
           MyMoneyAccount parent = m_storage->account(id.value());
           parent = checkConsistency(parent, (*acc));
           m_storage->addAccount(parent, (*acc));
         } else {
-          throw MYMONEYEXCEPTION("terminate() could not find account id");
+          throw MYMONEYEXCEPTION_CSTRING("terminate() could not find account id");
         }
       }
       signalProgress(++i, 0);
     } // end for account
     signalProgress(0, 1, ("."));  // debug - get rid of reorg message
     // offer the most common account currency as a default
     QString mainCurrency = "";
     unsigned int maxCount = 0;
     QMap<QString, unsigned int>::ConstIterator it;
     for (it = m_currencyCount.constBegin(); it != m_currencyCount.constEnd(); ++it) {
       if (it.value() > maxCount) {
         maxCount = it.value();
         mainCurrency = it.key();
       }
     }
 
     if (mainCurrency != "") {
       QString question = i18n("Your main currency seems to be %1 (%2); do you want to set this as your base currency?", mainCurrency, m_storage->currency(mainCurrency.toUtf8()).name());
       if (KMessageBox::questionYesNo(0, question, PACKAGE) == KMessageBox::Yes) {
         m_storage->setValue("kmm-baseCurrency", mainCurrency);
       }
     }
     // now produce the end of job reports - first, work out which ones are required
     QList<QString> sectionsToReport; // list of sections needing report
     sectionsToReport.append("MN");  // always build the main section
     if ((m_ccCount = m_messageList["CC"].count()) > 0) sectionsToReport.append("CC");
     if ((m_orCount = m_messageList["OR"].count()) > 0) sectionsToReport.append("OR");
     if ((m_scCount = m_messageList["SC"].count()) > 0) sectionsToReport.append("SC");
     // produce the sections in separate message boxes
     bool exit = false;
     int si;
     for (si = 0; (si < sectionsToReport.count()) && !exit; ++si) {
       QString button0Text = i18nc("Button to show more detailed data", "More");
       if (si + 1 == sectionsToReport.count())
         button0Text = i18nc("Button to close the current dialog", "Done"); // last section
       KGuiItem yesItem(button0Text, QIcon(), "", "");
       KGuiItem noItem(i18n("Save Report"), QIcon(), "", "");
 
       switch (KMessageBox::questionYesNoCancel(0,
               buildReportSection(sectionsToReport[si]),
               PACKAGE,
               yesItem, noItem)) {
         case KMessageBox::Yes:
           break;
         case KMessageBox::No:
           exit = writeReportToFile(sectionsToReport);
           break;
         default:
           exit = true;
           break;
       }
     }
 
 
     for (si = 0; si < m_suspectList.count(); ++si) {
       auto sc = m_storage->schedule(m_suspectList[si]);
       KMessageBox::information(0, i18n("Problems were encountered in converting schedule '%1'.", sc.name()), PACKAGE);
 //      TODO: return this feature
 //      switch (KMessageBox::warningYesNo(0, i18n("Problems were encountered in converting schedule '%1'.\nDo you want to review or edit it now?", sc.name()), PACKAGE)) {
 //        case KMessageBox::Yes:
 //          auto s = new KEditScheduleDlg(sc);
 //          if (s->exec())
 //            m_storage->modifySchedule(s->schedule());
 //          delete s;
 //          break;
 
 //        default:
 //          break;
 //      }
     }
   }
   PASS
 }
 //************************************ buildReportSection************************************
 QString MyMoneyGncReader::buildReportSection(const QString& source)
 {
   TRY {
     QString s = "";
     bool more = false;
     if (source == "MN") {
       s.append(i18n("Found:\n\n"));
       s.append(i18np("%1 commodity (equity)\n", "%1 commodities (equities)\n", m_commodityCount));
       s.append(i18np("%1 price\n", "%1 prices\n", m_priceCount));
       s.append(i18np("%1 account\n", "%1 accounts\n", m_accountCount));
       s.append(i18np("%1 transaction\n", "%1 transactions\n", m_transactionCount));
       s.append(i18np("%1 schedule\n", "%1 schedules\n", m_scheduleCount));
       s.append("\n\n");
       if (m_ccCount == 0) {
         s.append(i18n("No inconsistencies were detected\n"));
       } else {
         s.append(i18np("%1 inconsistency was detected and corrected\n", "%1 inconsistencies were detected and corrected\n", m_ccCount));
         more = true;
       }
       if (m_orCount > 0) {
         s.append("\n\n");
         s.append(i18np("%1 orphan account was created\n", "%1 orphan accounts were created\n", m_orCount));
         more = true;
       }
       if (m_scCount > 0) {
         s.append("\n\n");
         s.append(i18np("%1 possible schedule problem was noted\n", "%1 possible schedule problems were noted\n", m_scCount));
         more = true;
       }
       QString unsupported("");
       QString lineSep("\n  - ");
       if (m_smallBusinessFound) unsupported.append(lineSep + i18n("Small Business Features (Customers, Invoices, etc.)"));
       if (m_budgetsFound) unsupported.append(lineSep + i18n("Budgets"));
       if (m_lotsFound) unsupported.append(lineSep + i18n("Lots"));
       if (!unsupported.isEmpty()) {
         unsupported.prepend(i18n("The following features found in your file are not currently supported:"));
         s.append(unsupported);
       }
       if (more) s.append(i18n("\n\nPress More for further information"));
     } else {
       s = m_messageList[source].join(QChar('\n'));
     }
     if (gncdebug) qDebug() << s;
     return (static_cast<const QString>(s));
   }
   PASS
 }
 //************************ writeReportToFile*********************************
 bool MyMoneyGncReader::writeReportToFile(const QList<QString>& sectionsToReport)
 {
   TRY {
     int i;
     QString fd = QFileDialog::getSaveFileName(0, QString(), QString(),
                  i18n("Save report as"));
     if (fd.isEmpty()) return (false);
     QFile reportFile(fd);
     if (!reportFile.open(QIODevice::WriteOnly))  {
       return (false);
     }
     QTextStream stream(&reportFile);
     for (i = 0; i < sectionsToReport.count(); i++)
       stream << buildReportSection(sectionsToReport[i]) << endl;
     reportFile.close();
     return (true);
   }
   PASS
 }
 /****************************************************************************
                     Utility routines
 *****************************************************************************/
 //************************ createPayee ***************************
 
 QString MyMoneyGncReader::createPayee(const QString& gncDescription)
 {
   MyMoneyPayee payee;
   TRY {
     payee = m_storage->payeeByName(gncDescription);
   } CATCH { // payee not found, create one
     payee.setName(gncDescription);
     m_storage->addPayee(payee);
   }
   return (payee.id());
 }
 //************************************** createOrphanAccount *******************************
 QString MyMoneyGncReader::createOrphanAccount(const QString& gncName)
 {
   MyMoneyAccount acc;
 
   acc.setName("orphan_" + gncName);
   acc.setDescription(i18n("Orphan created from unknown GnuCash account"));
 
   QDate today = QDate::currentDate();
 
   acc.setOpeningDate(today);
   acc.setLastModified(today);
   acc.setLastReconciliationDate(today);
   acc.setCurrencyId(m_txCommodity);
   acc.setAccountType(Account::Type::Asset);
   acc.setParentAccountId(m_storage->asset().id());
   m_storage->addAccount(acc);
   // assign the gnucash id as the key into the map to find our id
   m_mapIds[gncName.toUtf8()] = acc.id();
   m_messageList["OR"].append(
     i18n("One or more transactions contain a reference to an otherwise unknown account\n"
          "An asset account with the name %1 has been created to hold the data", acc.name()));
   return (acc.id());
 }
 //****************************** incrDate *********************************************
 QDate MyMoneyGncReader::incrDate(QDate lastDate, unsigned char interval, unsigned int intervalCount)
 {
   TRY {
     switch (interval) {
       case 'd':
         return (lastDate.addDays(intervalCount));
       case 'w':
         return (lastDate.addDays(intervalCount * 7));
       case 'm':
         return (lastDate.addMonths(intervalCount));
       case 'y':
         return (lastDate.addYears(intervalCount));
       case 'o': // once-only
         return (lastDate);
     }
-    throw MYMONEYEXCEPTION(i18n("Internal error - invalid interval char in incrDate"));
+    throw MYMONEYEXCEPTION_CSTRING("Internal error - invalid interval char in incrDate");
 //    QDate r = QDate(); return (r); // to keep compiler happy
   }
   PASS
 }
 //********************************* checkConsistency **********************************
 MyMoneyAccount MyMoneyGncReader::checkConsistency(MyMoneyAccount& parent, MyMoneyAccount& child)
 {
   TRY {
     // gnucash is flexible/weird enough to allow various inconsistencies
     // these are a couple I found in my file, no doubt more will be discovered
     if ((child.accountType() == Account::Type::Investment) &&
     (parent.accountType() != Account::Type::Asset)) {
       m_messageList["CC"].append(
         i18n("An Investment account must be a child of an Asset account\n"
       "Account %1 will be stored under the main Asset account", child.name()));
       return m_storage->asset();
     }
     if ((child.accountType() == Account::Type::Income) &&
         (parent.accountType() != Account::Type::Income)) {
       m_messageList["CC"].append(
         i18n("An Income account must be a child of an Income account\n"
              "Account %1 will be stored under the main Income account", child.name()));
       return m_storage->income();
     }
     if ((child.accountType() == Account::Type::Expense) &&
         (parent.accountType() != Account::Type::Expense)) {
       m_messageList["CC"].append(
         i18n("An Expense account must be a child of an Expense account\n"
              "Account %1 will be stored under the main Expense account", child.name()));
       return m_storage->expense();
     }
     return (parent);
   }
   PASS
 }
 //*********************************** checkInvestmentOption *************************
 void MyMoneyGncReader::checkInvestmentOption(QString stockId)
 {
   // implement the investment option for stock accounts
   // first check whether the parent account (gnucash id) is actually an
   // investment account. if it is, no further action is needed
   MyMoneyAccount stockAcc = m_storage->account(m_mapIds[stockId.toUtf8()]);
   MyMoneyAccount parent;
   QString parentKey = stockAcc.parentAccountId();
   map_accountIds::const_iterator id = m_mapIds.constFind(parentKey);
   if (id != m_mapIds.constEnd()) {
     parent = m_storage->account(id.value());
     if (parent.accountType() == Account::Type::Investment) return ;
   }
   // so now, check the investment option requested by the user
   // option 0 creates a separate investment account for each stock account
   if (m_investmentOption == 0) {
     MyMoneyAccount invAcc(stockAcc);
     invAcc.setAccountType(Account::Type::Investment);
     invAcc.setCurrencyId(QString(""));  // we don't know what currency it is!!
     invAcc.setParentAccountId(parentKey);  // intersperse it between old parent and child stock acct
     m_storage->addAccount(invAcc);
     m_mapIds [invAcc.id()] = invAcc.id(); // so stock account gets parented (again) to investment account later
     if (gncdebug) qDebug()
       << "Created investment account" << invAcc.name() << "as id" << invAcc.id()
       << "parent" << invAcc.parentAccountId();
     if (gncdebug) qDebug() << "Setting stock" << stockAcc.name() << "id" <<  stockAcc.id()
       << "as child of" << invAcc.id();
     stockAcc.setParentAccountId(invAcc.id());
     m_storage->addAccount(invAcc, stockAcc);
     // investment option 1 creates a single investment account for all stocks
   } else if (m_investmentOption == 1) {
     static QString singleInvAccId = "";
     MyMoneyAccount singleInvAcc;
     bool ok = false;
     if (singleInvAccId.isEmpty()) { // if the account has not yet been created
       QString invAccName;
       while (!ok) {
         invAccName = QInputDialog::getText(0, QStringLiteral(PACKAGE),
                                            i18n("Enter the investment account name "),
                                            QLineEdit::Normal, i18n("My Investments"), &ok);
       }
       singleInvAcc.setName(invAccName);
       singleInvAcc.setAccountType(Account::Type::Investment);
       singleInvAcc.setCurrencyId(QString(""));
       singleInvAcc.setParentAccountId(m_storage->asset().id());
       m_storage->addAccount(singleInvAcc);
       m_mapIds [singleInvAcc.id()] = singleInvAcc.id(); // so stock account gets parented (again) to investment account later
       if (gncdebug) qDebug() << "Created investment account" << singleInvAcc.name()
         << "as id" << singleInvAcc.id() << "parent" << singleInvAcc.parentAccountId()
         << "reparenting stock";
       singleInvAccId = singleInvAcc.id();
     } else { // the account has already been created
       singleInvAcc = m_storage->account(singleInvAccId);
     }
     m_storage->addAccount(singleInvAcc, stockAcc); // add stock as child
     // the original intention of option 2 was to allow any asset account to be converted to an investment (broker) account
     // however, since we have already stored the accounts as asset, we have no way at present of changing their type
     // the only alternative would be to hold all the gnucash data in memory, then implement this option, then convert all the data
     // that would mean a major overhaul of the code. Perhaps I'll think of another way...
   } else if (m_investmentOption == 2) {
     static int lastSelected = 0;
     MyMoneyAccount invAcc(stockAcc);
     QStringList accList;
     QList<MyMoneyAccount> list;
     QList<MyMoneyAccount>::iterator acc;
     m_storage->accountList(list);
     // build a list of candidates for the input box
     for (acc = list.begin(); acc != list.end(); ++acc) {
       //      if (((*acc).accountGroup() == Account::Type::Asset) && ((*acc).accountType() != Account::Type::Stock)) accList.append ((*acc).name());
       if ((*acc).accountType() == Account::Type::Investment) accList.append((*acc).name());
     }
     //if (accList.isEmpty()) qWarning ("No available accounts");
     bool ok = false;
     while (!ok) { // keep going till we have a valid investment parent
       QString invAccName = QInputDialog::getItem(0,
                              PACKAGE,
                              i18n("Select parent investment account or enter new name. Stock %1", stockAcc.name()),
                              accList,
                              lastSelected, true, &ok);
       if (ok) {
         lastSelected = accList.indexOf(invAccName);  // preserve selection for next time
         for (acc = list.begin(); acc != list.end(); ++acc) {
           if ((*acc).name() == invAccName) break;
         }
         if (acc != list.end()) { // an account was selected
           invAcc = *acc;
         } else {                 // a new account name was entered
           invAcc.setAccountType(Account::Type::Investment);
           invAcc.setName(invAccName);
           invAcc.setCurrencyId(QString(""));
           invAcc.setParentAccountId(m_storage->asset().id());
           m_storage->addAccount(invAcc);
           ok = true;
         }
         if (invAcc.accountType() == Account::Type::Investment) {
           ok = true;
         } else {
           // this code is probably not going to be implemented coz we can't change account types (??)
 #if 0
           QMessageBox mb(PACKAGE,
                          i18n("%1 is not an Investment Account. Do you wish to make it one?", invAcc.name()),
                          QMessageBox::Question,
                          QMessageBox::Yes | QMessageBox::Default,
                          QMessageBox::No | QMessageBox::Escape,
                          Qt::NoButton);
           switch (mb.exec()) {
             case QMessageBox::No :
               ok = false;
               break;
             default:
               // convert it - but what if it has splits???
               qWarning("Not yet implemented");
               ok = true;
               break;
           }
 #endif
           switch (KMessageBox::questionYesNo(0, i18n("%1 is not an Investment Account. Do you wish to make it one?", invAcc.name()), PACKAGE)) {
             case KMessageBox::Yes:
               // convert it - but what if it has splits???
               qWarning("Not yet implemented");
               ok = true;
               break;
             default:
               ok = false;
               break;
           }
         }
       } // end if ok - user pressed Cancel
     } // end while !ok
     m_mapIds [invAcc.id()] = invAcc.id(); // so stock account gets parented (again) to investment account later
     m_storage->addAccount(invAcc, stockAcc);
   } else { // investment option != 0, 1, 2
     qWarning("Invalid investment option %d", m_investmentOption);
   }
 }
 
 // get the price source for a stock (gnc account) where online quotes are requested
 void MyMoneyGncReader::getPriceSource(MyMoneySecurity stock, QString gncSource)
 {
   // if he wants to use Finance::Quote, no conversion of source name is needed
   if (m_useFinanceQuote) {
     stock.setValue("kmm-online-quote-system", "Finance::Quote");
     stock.setValue("kmm-online-source", gncSource.toLower());
     m_storage->modifySecurity(stock);
     return;
   }
   // first check if we have already asked about this source
   // (mapSources is initialy empty. We may be able to pre-fill it with some equivalent
   //  sources, if such things do exist. User feedback may help here.)
   QMap<QString, QString>::const_iterator it;
   for (it = m_mapSources.constBegin(); it != m_mapSources.constEnd(); ++it) {
     if (it.key() == gncSource) {
       stock.setValue("kmm-online-source", it.value());
       m_storage->modifySecurity(stock);
       return;
     }
   }
   // not found in map, so ask the user
   QPointer<KGncPriceSourceDlg> dlg = new KGncPriceSourceDlg(stock.name(), gncSource);
   dlg->exec();
   QString s = dlg->selectedSource();
   if (!s.isEmpty()) {
     stock.setValue("kmm-online-source", s);
     m_storage->modifySecurity(stock);
   }
   if (dlg->alwaysUse()) m_mapSources[gncSource] = s;
   delete dlg;
   return;
 }
 
 void MyMoneyGncReader::loadAllCurrencies()
 {
   auto file = MyMoneyFile::instance();
   MyMoneyFileTransaction ft;
   if (!file->currencyList().isEmpty())
     return;
   auto ancientCurrencies = file->ancientCurrencies();
   try {
   foreach (auto currency, file->availableCurrencyList()) {
     file->addCurrency(currency);
     MyMoneyPrice price = ancientCurrencies.value(currency, MyMoneyPrice());
     if (price != MyMoneyPrice())
       file->addPrice(price);
   }
   ft.commit();
   } catch (const MyMoneyException &e) {
-    qDebug("Error %s loading currency", qPrintable(e.what()));
+    qDebug("Error %s loading currency", e.what());
   }
 }
 
 // functions to control the progress bar
 //*********************** setProgressCallback *****************************
 void MyMoneyGncReader::setProgressCallback(void(*callback)(int, int, const QString&))
 {
   m_progressCallback = callback; return ;
 }
 //************************** signalProgress *******************************
 void MyMoneyGncReader::signalProgress(int current, int total, const QString& msg)
 {
   if (m_progressCallback != 0)
     (*m_progressCallback)(current, total, msg);
   return ;
 }
 #endif // _GNCFILEANON
diff --git a/kmymoney/plugins/interfaces/kmmstatementinterface.cpp b/kmymoney/plugins/interfaces/kmmstatementinterface.cpp
index 63b109f42..b8ed8b5f2 100644
--- a/kmymoney/plugins/interfaces/kmmstatementinterface.cpp
+++ b/kmymoney/plugins/interfaces/kmmstatementinterface.cpp
@@ -1,88 +1,88 @@
 /***************************************************************************
                           kmmstatementinterface.cpp
                              -------------------
     begin                : Wed Jan 5 2005
     copyright            : (C) 2005 Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kmmstatementinterface.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneykeyvaluecontainer.h"
 #include "mymoneystatementreader.h"
 
 KMyMoneyPlugin::KMMStatementInterface::KMMStatementInterface(QObject* parent, const char* name) :
     StatementInterface(parent, name)
 {
 }
 
 QStringList KMyMoneyPlugin::KMMStatementInterface::import(const MyMoneyStatement& s, bool silent)
 {
   qDebug("KMyMoneyPlugin::KMMStatementInterface::import start");
   return MyMoneyStatementReader::importStatement(s, silent);
 }
 
 MyMoneyAccount KMyMoneyPlugin::KMMStatementInterface::account(const QString& key, const QString& value) const
 {
   QList<MyMoneyAccount> list;
   QList<MyMoneyAccount>::const_iterator it_a;
   MyMoneyFile::instance()->accountList(list);
   QString accId;
   for (it_a = list.constBegin(); it_a != list.constEnd(); ++it_a) {
     // search in the account's kvp container
     const auto& accountKvpValue = (*it_a).value(key);
     // search in the account's online settings kvp container
     const auto& onlineSettingsKvpValue = (*it_a).onlineBankingSettings().value(key);
     if (accountKvpValue.contains(value) || onlineSettingsKvpValue.contains(value)) {
       if(accId.isEmpty()) {
         accId = (*it_a).id();
       }
     }
     if (accountKvpValue == value || onlineSettingsKvpValue == value) {
       accId = (*it_a).id();
       break;
     }
   }
 
   // return the account found or an empty element
   return MyMoneyFile::instance()->account(accId);
 }
 
 void KMyMoneyPlugin::KMMStatementInterface::setAccountOnlineParameters(const MyMoneyAccount& acc, const MyMoneyKeyValueContainer& kvps) const
 {
   MyMoneyFileTransaction ft;
   try {
     auto oAcc = MyMoneyFile::instance()->account(acc.id());
     oAcc.setOnlineBankingSettings(kvps);
     MyMoneyFile::instance()->modifyAccount(oAcc);
     ft.commit();
 
-  } catch (const MyMoneyException) {
+  } catch (const MyMoneyException &) {
     qDebug("Unable to setup online parameters for account '%s'", qPrintable(acc.name()));
-//    KMessageBox::detailedSorry(0, i18n("Unable to setup online parameters for account '%1'", acc.name()), e.what());
+//    KMessageBox::detailedSorry(0, i18n("Unable to setup online parameters for account '%1'", acc.name()), QString::fromLatin1(e.what()));
   }
 }
diff --git a/kmymoney/plugins/kbanking/kbanking.cpp b/kmymoney/plugins/kbanking/kbanking.cpp
index e3d5294d5..598bac8d9 100644
--- a/kmymoney/plugins/kbanking/kbanking.cpp
+++ b/kmymoney/plugins/kbanking/kbanking.cpp
@@ -1,1520 +1,1520 @@
 /***************************************************************************
  *   Copyright 2004  Martin Preuss aquamaniac@users.sourceforge.net        *
  *   Copyright 2009  Cristian Onet onet.cristian@gmail.com                 *
  *   Copyright 2010  Thomas Baumgart ipwizard@users.sourceforge.net        *
  *   Copyright 2015  Christian David christian-david@web.de                *
  *                                                                         *
  *   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) version 3 or any later version        *
  *   accepted by the membership of KDE e.V. (or its successor approved     *
  *   by the membership of KDE e.V.), which shall act as a proxy            *
  *   defined in Section 14 of version 3 of the license.                    *
  *                                                                         *
  *   This program is distributed in the hope that it will be useful,       *
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program.  If not, see <http://www.gnu.org/licenses/>  *
  ***************************************************************************/
 #include <config-kmymoney.h>
 
 #include "kbanking.h"
 
 #include <memory>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QLayout>
 #include <QRadioButton>
 #include <QStringList>
 #include <QRegExp>
 #include <QCheckBox>
 #include <QLabel>
 #include <QTimer>
 
 #include <QDebug> //! @todo remove @c #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KPluginFactory>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KActionCollection>
 #include <QMenu>
 #include <KIconLoader>
 #include <KGuiItem>
 #include <KLineEdit>
 #include <KComboBox>
 #include <KConfig>
 #include <KConfigGroup>
 
 // ----------------------------------------------------------------------------
 // Library Includes
 
 #include <aqbanking/imexporter.h>
 #include <aqbanking/jobsingletransfer.h>
 #include <aqbanking/jobsepatransfer.h>
 #include <aqbanking/jobgettransactions.h>
 #include <aqbanking/jobgetbalance.h>
 #include <aqbanking/job.h>
 #include <aqbanking/abgui.h>
 #include <aqbanking/dlg_setup.h>
 #include <aqbanking/dlg_importer.h>
 #include <aqbanking/transactionlimits.h>
 #include <gwenhywfar/logger.h>
 #include <gwenhywfar/debug.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoney/onlinejob.h"
 
 #include "kbaccountsettings.h"
 #include "kbmapaccount.h"
 #include "mymoneyfile.h"
 #include "onlinejobadministration.h"
 #include "kmymoneyview.h"
 #include "kbpickstartdate.h"
 #include "mymoneyinstitution.h"
 
 #include "gwenkdegui.h"
 #include "gwenhywfarqtoperators.h"
 #include "aqbankingkmmoperators.h"
 #include "mymoneystatement.h"
 #include "statementinterface.h"
 #include "viewinterface.h"
 
 #ifdef KMM_DEBUG
 // Added an option to open the chipTanDialog from the menu for debugging purposes
 #include "chiptandialog.h"
 #endif
 
 class KBanking::Private
 {
 public:
   Private() :
      passwordCacheTimer(nullptr),
      jobList(),
      fileId()
   {
     QString gwenProxy = QString::fromLocal8Bit(qgetenv("GWEN_PROXY"));
     if (gwenProxy.isEmpty()) {
       std::unique_ptr<KConfig> cfg = std::unique_ptr<KConfig>(new KConfig("kioslaverc"));
       QRegExp exp("(\\w+://)?([^/]{2}.+:\\d+)");
       QString proxy;
 
       KConfigGroup grp = cfg->group("Proxy Settings");
       int type = grp.readEntry("ProxyType", 0);
       switch (type) {
         case 0: // no proxy
           break;
 
         case 1: // manual specified
           proxy = grp.readEntry("httpsProxy");
           qDebug("KDE https proxy setting is '%s'", qPrintable(proxy));
           if (exp.exactMatch(proxy)) {
             proxy = exp.cap(2);
             qDebug("Setting GWEN_PROXY to '%s'", qPrintable(proxy));
             if (!qputenv("GWEN_PROXY", qPrintable(proxy))) {
               qDebug("Unable to setup GWEN_PROXY");
             }
           }
           break;
 
         default: // other currently not supported
           qDebug("KDE proxy setting of type %d not supported", type);
           break;
       }
     }
   }
 
   /**
    * KMyMoney asks for accounts over and over again which causes a lot of "Job not supported with this account" error messages.
    * This function filters messages with that string.
    */
   static int gwenLogHook(GWEN_GUI* gui, const char* domain, GWEN_LOGGER_LEVEL level, const char* message) {
     Q_UNUSED(gui);
     Q_UNUSED(domain);
     Q_UNUSED(level);
 
     const char* messageToFilter = "Job not supported with this account";
     if (strstr(message, messageToFilter) != 0)
       return 1;
     return 0;
   }
 
   QTimer *passwordCacheTimer;
   QMap<QString, QStringList>  jobList;
   QString                     fileId;
 };
 
 
 KBanking::KBanking(QObject *parent, const QVariantList &args) :
   OnlinePluginExtended(parent, "kbanking")
   , d(new Private)
   , m_configAction(nullptr)
   , m_importAction(nullptr)
   , m_kbanking(nullptr)
   , m_accountSettings(nullptr)
 {
   Q_UNUSED(args)
   qDebug("Plugins: kbanking loaded");
 }
 
 KBanking::~KBanking()
 {
   delete d;
   qDebug("Plugins: kbanking unloaded");
 }
 
 void KBanking::plug()
 {
   m_kbanking = new KBankingExt(this, "KMyMoney");
 
   d->passwordCacheTimer = new QTimer(this);
   d->passwordCacheTimer->setSingleShot(true);
   d->passwordCacheTimer->setInterval(60000);
   connect(d->passwordCacheTimer, &QTimer::timeout, this, &KBanking::slotClearPasswordCache);
 
   if (m_kbanking) {
     if (AB_Banking_HasConf4(m_kbanking->getCInterface())) {
       qDebug("KBankingPlugin: No AqB4 config found.");
       if (AB_Banking_HasConf3(m_kbanking->getCInterface())) {
         qDebug("KBankingPlugin: No AqB3 config found.");
         if (!AB_Banking_HasConf2(m_kbanking->getCInterface())) {
           qDebug("KBankingPlugin: AqB2 config found - converting.");
           AB_Banking_ImportConf2(m_kbanking->getCInterface());
         }
       } else {
         qDebug("KBankingPlugin: AqB3 config found - converting.");
         AB_Banking_ImportConf3(m_kbanking->getCInterface());
       }
     }
 
     //! @todo when is gwenKdeGui deleted?
     gwenKdeGui *gui = new gwenKdeGui();
     GWEN_Gui_SetGui(gui->getCInterface());
     GWEN_Logger_SetLevel(0, GWEN_LoggerLevel_Warning);
 
     if (m_kbanking->init() == 0) {
       // Tell the host application to load my GUI component
       setComponentName("kbanking", "KBanking");
       setXMLFile("kbanking.rc");
       qDebug("Plugins: kbanking pluged");
 
       // get certificate handling and dialog settings management
       AB_Gui_Extend(gui->getCInterface(), m_kbanking->getCInterface());
 
       // create actions
       createActions();
 
       // load protocol conversion list
       loadProtocolConversion();
       GWEN_Logger_SetLevel(AQBANKING_LOGDOMAIN, GWEN_LoggerLevel_Warning);
       GWEN_Gui_SetLogHookFn(GWEN_Gui_GetGui(), &KBanking::Private::gwenLogHook);
 
     } else {
       qWarning("Could not initialize KBanking online banking interface");
       delete m_kbanking;
       m_kbanking = 0;
     }
   }
 }
 
 void KBanking::unplug()
 {
   d->passwordCacheTimer->deleteLater();
   if (m_kbanking) {
     m_kbanking->fini();
     delete m_kbanking;
     qDebug("Plugins: kbanking unpluged");
   }
 }
 
 
 void KBanking::loadProtocolConversion()
 {
   if (m_kbanking) {
     m_protocolConversionMap = {
       {"aqhbci", "HBCI"},
       {"aqofxconnect", "OFX"},
       {"aqyellownet", "YellowNet"},
       {"aqgeldkarte", "Geldkarte"},
       {"aqdtaus", "DTAUS"}
     };
   }
 }
 
 
 void KBanking::protocols(QStringList& protocolList) const
 {
   if (m_kbanking) {
     std::list<std::string> list = m_kbanking->getActiveProviders();
     std::list<std::string>::iterator it;
     for (it = list.begin(); it != list.end(); ++it) {
       // skip the dummy
       if (*it == "aqnone")
         continue;
       QMap<QString, QString>::const_iterator it_m;
       it_m = m_protocolConversionMap.find((*it).c_str());
       if (it_m != m_protocolConversionMap.end())
         protocolList << (*it_m);
       else
         protocolList << (*it).c_str();
     }
   }
 }
 
 
 QWidget* KBanking::accountConfigTab(const MyMoneyAccount& acc, QString& name)
 {
   const MyMoneyKeyValueContainer& kvp = acc.onlineBankingSettings();
   name = i18n("Online settings");
   if (m_kbanking) {
     m_accountSettings = new KBAccountSettings(acc, 0);
     m_accountSettings->loadUi(kvp);
     return m_accountSettings;
   }
   QLabel* label = new QLabel(i18n("KBanking module not correctly initialized"), 0);
   label->setAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
   return label;
 }
 
 
 MyMoneyKeyValueContainer KBanking::onlineBankingSettings(const MyMoneyKeyValueContainer& current)
 {
   MyMoneyKeyValueContainer kvp(current);
   kvp["provider"] = objectName().toLower();
   if (m_accountSettings) {
     m_accountSettings->loadKvp(kvp);
   }
   return kvp;
 }
 
 
 void KBanking::createActions()
 {
   QAction *settings_aqbanking = actionCollection()->addAction("settings_aqbanking");
   settings_aqbanking->setText(i18n("Configure Aq&Banking..."));
   connect(settings_aqbanking, &QAction::triggered, this, &KBanking::slotSettings);
 
   QAction *file_import_aqbanking = actionCollection()->addAction("file_import_aqbanking");
   file_import_aqbanking->setText(i18n("AqBanking importer..."));
   connect(file_import_aqbanking, &QAction::triggered, this, &KBanking::slotImport);
 
   Q_CHECK_PTR(viewInterface());
   connect(viewInterface(), &KMyMoneyPlugin::ViewInterface::viewStateChanged, action("file_import_aqbanking"), &QAction::setEnabled);
 
 #ifdef KMM_DEBUG
   QAction *openChipTanDialog = actionCollection()->addAction("open_chiptan_dialog");
   openChipTanDialog->setText("Open ChipTan Dialog");
   connect(openChipTanDialog, &QAction::triggered, [&](){
     auto dlg = new chipTanDialog();
     dlg->setHhdCode("0F04871100030333555414312C32331D");
     dlg->setInfoText("<html><h1>Test Graphic for debugging</h1><p>The encoded data is</p><p>Account Number: <b>335554</b><br/>Amount: <b>1,23</b></p></html>");
     connect(dlg, &QDialog::accepted, dlg, &chipTanDialog::deleteLater);
     connect(dlg, &QDialog::rejected, dlg, &chipTanDialog::deleteLater);
     dlg->show();
   });
 #endif
 }
 
 void KBanking::slotSettings()
 {
   if (m_kbanking) {
     GWEN_DIALOG* dlg = AB_SetupDialog_new(m_kbanking->getCInterface());
     if (dlg == NULL) {
       DBG_ERROR(0, "Could not create setup dialog.");
       return;
     }
 
     if (GWEN_Gui_ExecDialog(dlg, 0) == 0) {
       DBG_ERROR(0, "Aborted by user");
       GWEN_Dialog_free(dlg);
       return;
     }
     GWEN_Dialog_free(dlg);
   }
 }
 
 
 bool KBanking::mapAccount(const MyMoneyAccount& acc, MyMoneyKeyValueContainer& settings)
 {
   bool rc = false;
   if (m_kbanking && !acc.id().isEmpty()) {
     m_kbanking->askMapAccount(acc);
 
     // at this point, the account should be mapped
     // so we search it and setup the account reference in the KMyMoney object
     AB_ACCOUNT* ab_acc;
     ab_acc = aqbAccount(acc);
     if (ab_acc) {
       MyMoneyAccount a(acc);
       setupAccountReference(a, ab_acc);
       settings = a.onlineBankingSettings();
       rc = true;
     }
   }
   return rc;
 }
 
 
 AB_ACCOUNT* KBanking::aqbAccount(const MyMoneyAccount& acc) const
 {
   if (m_kbanking == 0) {
     return 0;
   }
 
   // certainly looking for an expense or income account does not make sense at this point
   // so we better get out right away
   if (acc.isIncomeExpense()) {
     return 0;
   }
 
   AB_ACCOUNT *ab_acc = AB_Banking_GetAccountByAlias(m_kbanking->getCInterface(), m_kbanking->mappingId(acc).toUtf8().data());
   // if the account is not found, we temporarily scan for the 'old' mapping (the one w/o the file id)
   // in case we find it, we setup the new mapping in addition on the fly.
   if (!ab_acc && acc.isAssetLiability()) {
     ab_acc = AB_Banking_GetAccountByAlias(m_kbanking->getCInterface(), acc.id().toUtf8().data());
     if (ab_acc) {
       qDebug("Found old mapping for '%s' but not new. Setup new mapping", qPrintable(acc.name()));
       m_kbanking->setAccountAlias(ab_acc, m_kbanking->mappingId(acc).toUtf8().constData());
       // TODO at some point in time, we should remove the old mapping
     }
   }
   return ab_acc;
 }
 
 
 AB_ACCOUNT* KBanking::aqbAccount(const QString& accountId) const
 {
   MyMoneyAccount account = MyMoneyFile::instance()->account(accountId);
   return aqbAccount(account);
 }
 
 
 QString KBanking::stripLeadingZeroes(const QString& s) const
 {
   QString rc(s);
   QRegExp exp("^(0*)([^0].*)");
   if (exp.exactMatch(s)) {
     rc = exp.cap(2);
   }
   return rc;
 }
 
 void KBanking::setupAccountReference(const MyMoneyAccount& acc, AB_ACCOUNT* ab_acc)
 {
   MyMoneyKeyValueContainer kvp;
 
   if (ab_acc) {
     QString accountNumber = stripLeadingZeroes(AB_Account_GetAccountNumber(ab_acc));
     QString routingNumber = stripLeadingZeroes(AB_Account_GetBankCode(ab_acc));
 
     QString val = QString("%1-%2").arg(routingNumber, accountNumber);
     if (val != acc.onlineBankingSettings().value("kbanking-acc-ref")) {
       kvp.clear();
 
       // make sure to keep our own previous settings
       const QMap<QString, QString>& vals = acc.onlineBankingSettings().pairs();
       QMap<QString, QString>::const_iterator it_p;
       for (it_p = vals.begin(); it_p != vals.end(); ++it_p) {
         if (QString(it_p.key()).startsWith("kbanking-")) {
           kvp.setValue(it_p.key(), *it_p);
         }
       }
 
       kvp.setValue("kbanking-acc-ref", val);
       kvp.setValue("provider", objectName().toLower());
       setAccountOnlineParameters(acc, kvp);
     }
   } else {
     // clear the connection
     setAccountOnlineParameters(acc, kvp);
   }
 }
 
 
 bool KBanking::accountIsMapped(const MyMoneyAccount& acc)
 {
   return aqbAccount(acc) != 0;
 }
 
 
 bool KBanking::updateAccount(const MyMoneyAccount& acc)
 {
   return updateAccount(acc, false);
 }
 
 
 bool KBanking::updateAccount(const MyMoneyAccount& acc, bool moreAccounts)
 {
   if (!m_kbanking)
     return false;
 
   bool rc = false;
 
   if (!acc.id().isEmpty()) {
     AB_JOB *job = 0;
     int rv;
 
     /* get AqBanking account */
     AB_ACCOUNT *ba = aqbAccount(acc);
     // Update the connection between the KMyMoney account and the AqBanking equivalent.
     // If the account is not found anymore ba == 0 and the connection is removed.
     setupAccountReference(acc, ba);
 
     if (!ba) {
       KMessageBox::error(0,
                          i18n("<qt>"
                               "The given application account <b>%1</b> "
                               "has not been mapped to an online "
                               "account."
                               "</qt>",
                               acc.name()),
                          i18n("Account Not Mapped"));
     } else {
       bool enqueJob = true;
       if (acc.onlineBankingSettings().value("kbanking-txn-download") != "no") {
         /* create getTransactions job */
         job = AB_JobGetTransactions_new(ba);
         rv = AB_Job_CheckAvailability(job);
         if (rv) {
           DBG_ERROR(0, "Job \"GetTransactions\" is not available (%d)", rv);
           KMessageBox::error(0,
                              i18n("<qt>"
                                   "The update job is not supported by the "
                                   "bank/account/backend.\n"
                                   "</qt>"),
                              i18n("Job not Available"));
           AB_Job_free(job);
           job = 0;
         }
 
         if (job) {
           int days = AB_JobGetTransactions_GetMaxStoreDays(job);
           QDate qd;
           if (days > 0) {
             GWEN_TIME *ti1;
             GWEN_TIME *ti2;
 
             ti1 = GWEN_CurrentTime();
             ti2 = GWEN_Time_fromSeconds(GWEN_Time_Seconds(ti1) - (60 * 60 * 24 * days));
             GWEN_Time_free(ti1);
             ti1 = ti2;
 
             int year, month, day;
             if (GWEN_Time_GetBrokenDownDate(ti1, &day, &month, &year)) {
               DBG_ERROR(0, "Bad date");
               qd = QDate();
             } else
               qd = QDate(year, month + 1, day);
             GWEN_Time_free(ti1);
           }
 
           // get last statement request date from application account object
           // and start from a few days before if the date is valid
           QDate lastUpdate = QDate::fromString(acc.value("lastImportedTransactionDate"), Qt::ISODate);
           if (lastUpdate.isValid())
             lastUpdate = lastUpdate.addDays(-3);
 
           int dateOption = acc.onlineBankingSettings().value("kbanking-statementDate").toInt();
           switch (dateOption) {
             case 0: // Ask user
               break;
             case 1: // No date
               qd = QDate();
               break;
             case 2: // Last download
               qd = lastUpdate;
               break;
             case 3: // First possible
               // qd is already setup
               break;
           }
 
           // the pick start date option dialog is needed in
           // case the dateOption is 0 or the date option is > 1
           // and the qd is invalid
           if (dateOption == 0 || (dateOption > 1 && !qd.isValid())) {
             QPointer<KBPickStartDate> psd = new KBPickStartDate(m_kbanking, qd, lastUpdate, acc.name(),
                 lastUpdate.isValid() ? 2 : 3, 0, true);
             if (psd->exec() == QDialog::Accepted) {
               qd = psd->date();
             } else {
               enqueJob = false;
             }
             delete psd;
           }
 
           if (enqueJob) {
             if (qd.isValid()) {
               GWEN_TIME *ti1;
 
               ti1 = GWEN_Time_new(qd.year(), qd.month() - 1, qd.day(), 0, 0, 0, 0);
               AB_JobGetTransactions_SetFromTime(job, ti1);
               GWEN_Time_free(ti1);
             }
 
             rv = m_kbanking->enqueueJob(job);
             if (rv) {
               DBG_ERROR(0, "Error %d", rv);
               KMessageBox::error(0,
                                 i18n("<qt>"
                                       "Could not enqueue the job.\n"
                                       "</qt>"),
                                 i18n("Error"));
             }
           }
           AB_Job_free(job);
         }
       }
 
       if (enqueJob) {
         /* create getBalance job */
         job = AB_JobGetBalance_new(ba);
         rv = AB_Job_CheckAvailability(job);
         if (!rv)
           rv = m_kbanking->enqueueJob(job);
         else
           rv = 0;
 
         AB_Job_free(job);
         if (rv) {
           DBG_ERROR(0, "Error %d", rv);
           KMessageBox::error(0,
                              i18n("<qt>"
                                   "Could not enqueue the job.\n"
                                   "</qt>"),
                              i18n("Error"));
         } else {
           rc = true;
           emit queueChanged();
         }
       }
     }
   }
 
   // make sure we have at least one job in the queue before sending it
   if (!moreAccounts && m_kbanking->getEnqueuedJobs().size() > 0)
     executeQueue();
 
   return rc;
 }
 
 
 void KBanking::executeQueue()
 {
   if (m_kbanking && m_kbanking->getEnqueuedJobs().size() > 0) {
     AB_IMEXPORTER_CONTEXT *ctx;
     ctx = AB_ImExporterContext_new();
     int rv = m_kbanking->executeQueue(ctx);
     if (!rv) {
       m_kbanking->importContext(ctx, 0);
     } else {
       DBG_ERROR(0, "Error: %d", rv);
     }
     AB_ImExporterContext_free(ctx);
   }
 }
 
 
 /** @todo improve error handling, e.g. by adding a .isValid to nationalTransfer
  * @todo use new onlineJob system
  */
 void KBanking::sendOnlineJob(QList<onlineJob>& jobs)
 {
   Q_CHECK_PTR(m_kbanking);
 
   m_onlineJobQueue.clear();
   QList<onlineJob> unhandledJobs;
 
   if (!jobs.isEmpty()) {
     foreach (onlineJob job, jobs) {
       if (sepaOnlineTransfer::name() == job.task()->taskName()) {
         onlineJobTyped<sepaOnlineTransfer> typedJob(job);
         enqueTransaction(typedJob);
         job = typedJob;
       } else {
         job.addJobMessage(onlineJobMessage(eMyMoney::OnlineJob::MessageType::Error, "KBanking", "Cannot handle this request"));
         unhandledJobs.append(job);
       }
       m_onlineJobQueue.insert(m_kbanking->mappingId(job), job);
     }
 
     executeQueue();
   }
   jobs = m_onlineJobQueue.values() + unhandledJobs;
   m_onlineJobQueue.clear();
 }
 
 
 QStringList KBanking::availableJobs(QString accountId)
 {
   try {
     MyMoneyAccount acc = MyMoneyFile::instance()->account(accountId);
     QString id = MyMoneyFile::instance()->value("kmm-id");
     if(id != d->fileId) {
       d->jobList.clear();
       d->fileId = id;
     }
-  } catch (const MyMoneyException&) {
+  } catch (const MyMoneyException &) {
     // Exception usually means account was not found
     return QStringList();
   }
 
   if(d->jobList.contains(accountId)) {
     return d->jobList[accountId];
   }
 
   QStringList list;
   AB_ACCOUNT* abAccount = aqbAccount(accountId);
 
   if (!abAccount) {
     return list;
   }
 
   // Check availableJobs
 
   // sepa transfer
   AB_JOB* abJob = AB_JobSepaTransfer_new(abAccount);
   if (AB_Job_CheckAvailability(abJob) == 0)
     list.append(sepaOnlineTransfer::name());
   AB_Job_free(abJob);
 
   d->jobList[accountId] = list;
   return list;
 }
 
 
 /** @brief experimenting with QScopedPointer and aqBanking pointers */
 class QScopedPointerAbJobDeleter
 {
 public:
   static void cleanup(AB_JOB* job) {
     AB_Job_free(job);
   }
 };
 
 
 /** @brief experimenting with QScopedPointer and aqBanking pointers */
 class QScopedPointerAbAccountDeleter
 {
 public:
   static void cleanup(AB_ACCOUNT* account) {
     AB_Account_free(account);
   }
 };
 
 
 IonlineTaskSettings::ptr KBanking::settings(QString accountId, QString taskName)
 {
   AB_ACCOUNT* abAcc = aqbAccount(accountId);
   if (abAcc == 0)
     return IonlineTaskSettings::ptr();
 
   if (sepaOnlineTransfer::name() == taskName) {
     // Get limits for sepaonlinetransfer
     QScopedPointer<AB_JOB, QScopedPointerAbJobDeleter> abJob(AB_JobSepaTransfer_new(abAcc));
     if (AB_Job_CheckAvailability(abJob.data()) != 0)
       return IonlineTaskSettings::ptr();
     const AB_TRANSACTION_LIMITS* limits = AB_Job_GetFieldLimits(abJob.data());
     return AB_TransactionLimits_toSepaOnlineTaskSettings(limits).dynamicCast<IonlineTaskSettings>();
   }
   return IonlineTaskSettings::ptr();
 }
 
 
 bool KBanking::enqueTransaction(onlineJobTyped<sepaOnlineTransfer>& job)
 {
   /* get AqBanking account */
   const QString accId = job.constTask()->responsibleAccount();
 
   AB_ACCOUNT *abAccount = aqbAccount(accId);
   if (!abAccount) {
     job.addJobMessage(onlineJobMessage(eMyMoney::OnlineJob::MessageType::Warning, "KBanking", i18n("<qt>"
                                                                                     "The given application account <b>%1</b> "
                                                                                     "has not been mapped to an online "
                                                                                     "account."
                                                                                     "</qt>",
                                        MyMoneyFile::instance()->account(accId).name())));
     return false;
   }
   //setupAccountReference(acc, ba); // needed?
 
   AB_JOB *abJob = AB_JobSepaTransfer_new(abAccount);
   int rv = AB_Job_CheckAvailability(abJob);
   if (rv) {
     qDebug("AB_ERROR_OFFSET is %i", AB_ERROR_OFFSET);
     job.addJobMessage(onlineJobMessage(eMyMoney::OnlineJob::MessageType::Error, "AqBanking",
                                        QString("Sepa credit transfers for account \"%1\" are not available, error code %2.").arg(MyMoneyFile::instance()->account(accId).name(), rv)
                                        )
                      );
     return false;
   }
   AB_TRANSACTION *AbTransaction = AB_Transaction_new();
 
   // Recipient
   payeeIdentifiers::ibanBic beneficiaryAcc = job.constTask()->beneficiaryTyped();
   AB_Transaction_SetRemoteName(AbTransaction, GWEN_StringList_fromQString(beneficiaryAcc.ownerName()));
   AB_Transaction_SetRemoteIban(AbTransaction, beneficiaryAcc.electronicIban().toUtf8().constData());
   AB_Transaction_SetRemoteBic(AbTransaction, beneficiaryAcc.fullStoredBic().toUtf8().constData());
 
   // Origin Account
   AB_Transaction_SetLocalAccount(AbTransaction, abAccount);
 
   // Purpose
   QStringList qPurpose = job.constTask()->purpose().split('\n');
   GWEN_STRINGLIST *purpose = GWEN_StringList_fromQStringList(qPurpose);
   AB_Transaction_SetPurpose(AbTransaction, purpose);
   GWEN_StringList_free(purpose);
 
   // Reference
   // AqBanking duplicates the string. This should be safe.
   AB_Transaction_SetEndToEndReference(AbTransaction, job.constTask()->endToEndReference().toUtf8().constData());
 
   // Other Fields
   AB_Transaction_SetTextKey(AbTransaction, job.constTask()->textKey());
   AB_Transaction_SetValue(AbTransaction, AB_Value_fromMyMoneyMoney(job.constTask()->value()));
 
   /** @todo LOW remove Debug info */
   qDebug() << "SetTransaction: " << AB_Job_SetTransaction(abJob, AbTransaction);
 
   GWEN_DB_NODE *gwenNode = AB_Job_GetAppData(abJob);
   GWEN_DB_SetCharValue(gwenNode, GWEN_DB_FLAGS_DEFAULT, "kmmOnlineJobId", m_kbanking->mappingId(job).toLatin1().constData());
 
   qDebug() << "Enqueue: " << m_kbanking->enqueueJob(abJob);
 
   //delete localAcc;
   return true;
 }
 
 
 void KBanking::startPasswordTimer()
 {
   if (d->passwordCacheTimer->isActive())
     d->passwordCacheTimer->stop();
   d->passwordCacheTimer->start();
 }
 
 
 void KBanking::slotClearPasswordCache()
 {
   m_kbanking->clearPasswordCache();
 }
 
 
 void KBanking::slotImport()
 {
   if (!m_kbanking->interactiveImport())
     qWarning("Error on import dialog");
 }
 
 
 bool KBanking::importStatement(const MyMoneyStatement& s)
 {
   return !statementInterface()->import(s).isEmpty();
 }
 
 
 MyMoneyAccount KBanking::account(const QString& key, const QString& value) const
 {
   return statementInterface()->account(key, value);
 }
 
 
 void KBanking::setAccountOnlineParameters(const MyMoneyAccount& acc, const MyMoneyKeyValueContainer& kvps) const
 {
   return statementInterface()->setAccountOnlineParameters(acc, kvps);
 }
 
 
 KBankingExt::KBankingExt(KBanking* parent, const char* appname, const char* fname)
     : AB_Banking(appname, fname)
     , m_parent(parent)
     , _jobQueue(0)
 {
   m_sepaKeywords = {QString::fromUtf8("SEPA-BASISLASTSCHRIFT"), QString::fromUtf8("SEPA-ÜBERWEISUNG")};
 }
 
 
 int KBankingExt::init()
 {
   int rv = AB_Banking::init();
   if (rv < 0)
     return rv;
 
   rv = onlineInit();
   if (rv) {
     fprintf(stderr, "Error on online init (%d).\n", rv);
     AB_Banking::fini();
     return rv;
   }
 
   _jobQueue = AB_Job_List2_new();
   return 0;
 }
 
 
 int KBankingExt::fini()
 {
   if (_jobQueue) {
     AB_Job_List2_FreeAll(_jobQueue);
     _jobQueue = 0;
   }
 
   const int rv = onlineFini();
   if (rv) {
     AB_Banking::fini();
     return rv;
   }
   return AB_Banking::fini();
 }
 
 
 int KBankingExt::executeQueue(AB_IMEXPORTER_CONTEXT *ctx)
 {
   m_parent->startPasswordTimer();
 
   int rv = AB_Banking::executeJobs(_jobQueue, ctx);
   if (rv != 0) {
     qDebug() << "Sending queue by aqbanking got error no " << rv;
   }
 
   /** check result of each job */
   AB_JOB_LIST2_ITERATOR* jobIter = AB_Job_List2_First(_jobQueue);
   if (jobIter) {
     AB_JOB* abJob = AB_Job_List2Iterator_Data(jobIter);
 
     while (abJob) {
       GWEN_DB_NODE* gwenNode = AB_Job_GetAppData(abJob);
       if (gwenNode == 0) {
         qWarning("Executed AB_Job without KMyMoney id");
         abJob = AB_Job_List2Iterator_Next(jobIter);
         break;
       }
       QString jobIdent = QString::fromUtf8(GWEN_DB_GetCharValue(gwenNode, "kmmOnlineJobId", 0, ""));
 
       onlineJob job = m_parent->m_onlineJobQueue.value(jobIdent);
       if (job.isNull()) {
         // It should not be possiblie that this will happen (only if AqBanking fails heavily).
         //! @todo correct exception text
         qWarning("Executed a job which was not in queue. Please inform the KMyMoney developers.");
         abJob = AB_Job_List2Iterator_Next(jobIter);
         continue;
       }
 
       AB_JOB_STATUS abStatus = AB_Job_GetStatus(abJob);
 
       if (abStatus == AB_Job_StatusSent
           || abStatus == AB_Job_StatusPending
           || abStatus == AB_Job_StatusFinished
           || abStatus == AB_Job_StatusError
           || abStatus == AB_Job_StatusUnknown)
         job.setJobSend();
 
       if (abStatus == AB_Job_StatusFinished)
         job.setBankAnswer(onlineJob::acceptedByBank);
       else if (abStatus == AB_Job_StatusError || abStatus == AB_Job_StatusUnknown)
         job.setBankAnswer(onlineJob::sendingError);
 
       job.addJobMessage(onlineJobMessage(eMyMoney::OnlineJob::MessageType::Debug, "KBanking", "Job was processed"));
       m_parent->m_onlineJobQueue.insert(jobIdent, job);
       abJob = AB_Job_List2Iterator_Next(jobIter);
     }
     AB_Job_List2Iterator_free(jobIter);
   }
 
   AB_JOB_LIST2 *oldQ = _jobQueue;
   _jobQueue = AB_Job_List2_new();
   AB_Job_List2_FreeAll(oldQ);
 
   emit m_parent->queueChanged();
   m_parent->startPasswordTimer();
 
   return rv;
 }
 
 
 void KBankingExt::clearPasswordCache()
 {
   /* clear password DB */
   GWEN_Gui_SetPasswordStatus(NULL, NULL, GWEN_Gui_PasswordStatus_Remove, 0);
 }
 
 
 std::list<AB_JOB*> KBankingExt::getEnqueuedJobs()
 {
   AB_JOB_LIST2 *ll;
   std::list<AB_JOB*> rl;
 
   ll = _jobQueue;
   if (ll && AB_Job_List2_GetSize(ll)) {
     AB_JOB *j;
     AB_JOB_LIST2_ITERATOR *it;
 
     it = AB_Job_List2_First(ll);
     assert(it);
     j = AB_Job_List2Iterator_Data(it);
     assert(j);
     while (j) {
       rl.push_back(j);
       j = AB_Job_List2Iterator_Next(it);
     }
     AB_Job_List2Iterator_free(it);
   }
   return rl;
 }
 
 
 int KBankingExt::enqueueJob(AB_JOB *j)
 {
   assert(_jobQueue);
   assert(j);
   AB_Job_Attach(j);
   AB_Job_List2_PushBack(_jobQueue, j);
   return 0;
 }
 
 
 int KBankingExt::dequeueJob(AB_JOB *j)
 {
   assert(_jobQueue);
   AB_Job_List2_Remove(_jobQueue, j);
   AB_Job_free(j);
   emit m_parent->queueChanged();
   return 0;
 }
 
 
 void KBankingExt::transfer()
 {
   //m_parent->transfer();
 }
 
 
 bool KBankingExt::askMapAccount(const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QString bankId;
   QString accountId;
   // extract some information about the bank. if we have a sortcode
   // (BLZ) we display it, otherwise the name is enough.
   try {
     const MyMoneyInstitution &bank = file->institution(acc.institutionId());
     bankId = bank.name();
     if (!bank.sortcode().isEmpty())
       bankId = bank.sortcode();
   } catch (const MyMoneyException &e) {
     // no bank assigned, we just leave the field emtpy
   }
 
   // extract account information. if we have an account number
   // we show it, otherwise the name will be displayed
   accountId = acc.number();
   if (accountId.isEmpty())
     accountId = acc.name();
 
   // do the mapping. the return value of this method is either
   // true, when the user mapped the account or false, if he
   // decided to quit the dialog. So not really a great thing
   // to present some more information.
 
   KBMapAccount *w;
   w = new KBMapAccount(this,
                        bankId.toUtf8().constData(),
                        accountId.toUtf8().constData());
   if (w->exec() == QDialog::Accepted) {
     AB_ACCOUNT *a;
 
     a = w->getAccount();
     assert(a);
     DBG_NOTICE(0,
                "Mapping application account \"%s\" to "
                "online account \"%s/%s\"",
                qPrintable(acc.name()),
                AB_Account_GetBankCode(a),
                AB_Account_GetAccountNumber(a));
 
     // TODO remove the following line once we don't need backward compatibility
     setAccountAlias(a, acc.id().toUtf8().constData());
     qDebug("Setup mapping to '%s'", acc.id().toUtf8().constData());
 
     setAccountAlias(a, mappingId(acc).toUtf8().constData());
     qDebug("Setup mapping to '%s'", mappingId(acc).toUtf8().constData());
 
     delete w;
     return true;
   }
 
   delete w;
   return false;
 }
 
 
 QString KBankingExt::mappingId(const MyMoneyObject& object) const
 {
   QString id = MyMoneyFile::instance()->storageId() + QLatin1Char('-') + object.id();
 
   // AqBanking does not handle the enclosing parens, so we remove it
   id.remove('{');
   id.remove('}');
   return id;
 }
 
 
 bool KBankingExt::interactiveImport()
 {
   AB_IMEXPORTER_CONTEXT *ctx;
   GWEN_DIALOG *dlg;
   int rv;
 
   ctx = AB_ImExporterContext_new();
   dlg = AB_ImporterDialog_new(getCInterface(), ctx, NULL);
   if (dlg == NULL) {
     DBG_ERROR(0, "Could not create importer dialog.");
     AB_ImExporterContext_free(ctx);
     return false;
   }
 
   rv = GWEN_Gui_ExecDialog(dlg, 0);
   if (rv == 0) {
     DBG_ERROR(0, "Aborted by user");
     GWEN_Dialog_free(dlg);
     AB_ImExporterContext_free(ctx);
     return false;
   }
 
   if (!importContext(ctx, 0)) {
     DBG_ERROR(0, "Error on importContext");
     GWEN_Dialog_free(dlg);
     AB_ImExporterContext_free(ctx);
     return false;
   }
 
   GWEN_Dialog_free(dlg);
   AB_ImExporterContext_free(ctx);
   return true;
 }
 
 
 const AB_ACCOUNT_STATUS* KBankingExt::_getAccountStatus(AB_IMEXPORTER_ACCOUNTINFO *ai)
 {
   const AB_ACCOUNT_STATUS *ast;
   const AB_ACCOUNT_STATUS *best;
 
   best = 0;
   ast = AB_ImExporterAccountInfo_GetFirstAccountStatus(ai);
   while (ast) {
     if (!best)
       best = ast;
     else {
       const GWEN_TIME *tiBest;
       const GWEN_TIME *ti;
 
       tiBest = AB_AccountStatus_GetTime(best);
       ti = AB_AccountStatus_GetTime(ast);
 
       if (!tiBest) {
         best = ast;
       } else {
         if (ti) {
           double d;
 
           /* we have two times, compare them */
           d = GWEN_Time_Diff(ti, tiBest);
           if (d > 0)
             /* newer */
             best = ast;
         }
       }
     }
     ast = AB_ImExporterAccountInfo_GetNextAccountStatus(ai);
   } /* while */
   return best;
 }
 
 
 void KBankingExt::_xaToStatement(MyMoneyStatement &ks,
                                      const MyMoneyAccount& acc,
                                      const AB_TRANSACTION *t)
 {
   const GWEN_STRINGLIST *sl;
   QString s;
   QString memo;
   const char *p;
   const AB_VALUE *val;
   const GWEN_TIME *ti;
   const GWEN_TIME *startTime = 0;
   MyMoneyStatement::Transaction kt;
   unsigned long h;
 
   kt.m_fees = MyMoneyMoney();
 
   // bank's transaction id
   p = AB_Transaction_GetFiId(t);
   if (p)
     kt.m_strBankID = QString("ID ") + QString::fromUtf8(p);
 
   // payee
   s.truncate(0);
   sl = AB_Transaction_GetRemoteName(t);
   if (sl) {
     GWEN_STRINGLISTENTRY *se;
 
     se = GWEN_StringList_FirstEntry(sl);
     while (se) {
       p = GWEN_StringListEntry_Data(se);
       assert(p);
       s += QString::fromUtf8(p);
       se = GWEN_StringListEntry_Next(se);
     } // while
   }
   kt.m_strPayee = s;
 
   // memo
   // The variable 's' contains the old method of extracting
   // the memo which added a linefeed after each part received
   // from AqBanking. The new variable 'memo' does not have
   // this inserted linefeed. We keep the variable 's' to
   // construct the hash-value to retrieve the reference
   s.truncate(0);
   sl = AB_Transaction_GetPurpose(t);
   if (sl) {
     GWEN_STRINGLISTENTRY *se;
     bool insertLineSep = false;
 
     se = GWEN_StringList_FirstEntry(sl);
     while (se) {
       p = GWEN_StringListEntry_Data(se);
       assert(p);
       if (insertLineSep)
         s += '\n';
       insertLineSep = true;
       s += QString::fromUtf8(p).trimmed();
       memo += QString::fromUtf8(p).trimmed();
       se = GWEN_StringListEntry_Next(se);
     } // while
 
     // Sparda / Netbank hack: the software these banks use stores
     // parts of the payee name in the beginning of the purpose field
     // in case the payee name exceeds the 27 character limit. This is
     // the case, when one of the strings listed in m_sepaKeywords is part
     // of the purpose fields but does not start at the beginning. In this
     // case, the part leading up to the keyword is to be treated as the
     // tail of the payee. Also, a blank is inserted after the keyword.
     QSet<QString>::const_iterator itk;
     for (itk = m_sepaKeywords.constBegin(); itk != m_sepaKeywords.constEnd(); ++itk) {
       int idx = s.indexOf(*itk);
       if (idx >= 0) {
         if (idx > 0) {
           // re-add a possibly removed blank to name
           if (kt.m_strPayee.length() < 27)
             kt.m_strPayee += ' ';
           kt.m_strPayee += s.left(idx);
           s = s.mid(idx);
         }
         s = QString("%1 %2").arg(*itk).arg(s.mid((*itk).length()));
 
         // now do the same for 'memo' except for updating the payee
         idx = memo.indexOf(*itk);
         if (idx >= 0) {
           if (idx > 0) {
             memo = memo.mid(idx);
           }
         }
         memo = QString("%1 %2").arg(*itk).arg(memo.mid((*itk).length()));
         break;
       }
     }
 
     // in case we have some SEPA fields filled with information
     // we add them to the memo field
     p = AB_Transaction_GetEndToEndReference(t);
     if (p) {
       s += QString(", EREF: %1").arg(p);
       if(memo.length())
         memo.append('\n');
       memo.append(QString("EREF: %1").arg(p));
     }
     p = AB_Transaction_GetCustomerReference(t);
     if (p) {
       s += QString(", CREF: %1").arg(p);
       if(memo.length())
         memo.append('\n');
       memo.append(QString("CREF: %1").arg(p));
     }
     p = AB_Transaction_GetMandateId(t);
     if (p) {
       s += QString(", MREF: %1").arg(p);
       if(memo.length())
         memo.append('\n');
       memo.append(QString("MREF: %1").arg(p));
     }
     p = AB_Transaction_GetCreditorSchemeId(t);
     if (p) {
       s += QString(", CRED: %1").arg(p);
       if(memo.length())
         memo.append('\n');
       memo.append(QString("CRED: %1").arg(p));
     }
     p = AB_Transaction_GetOriginatorIdentifier(t);
     if (p) {
       s += QString(", DEBT: %1").arg(p);
       if(memo.length())
         memo.append('\n');
       memo.append(QString("DEBT: %1").arg(p));
     }
   }
   kt.m_strMemo = memo;
 
   // calculate the hash code and start with the payee info
   // and append the memo field
   h = MyMoneyTransaction::hash(kt.m_strPayee.trimmed());
   h = MyMoneyTransaction::hash(s, h);
 
   // see, if we need to extract the payee from the memo field
   const MyMoneyKeyValueContainer& kvp = acc.onlineBankingSettings();
   QString rePayee = kvp.value("kbanking-payee-regexp");
   if (!rePayee.isEmpty() && kt.m_strPayee.isEmpty()) {
     QString reMemo = kvp.value("kbanking-memo-regexp");
     QStringList exceptions = kvp.value("kbanking-payee-exceptions").split(';', QString::SkipEmptyParts);
 
     bool needExtract = true;
     QStringList::const_iterator it_s;
     for (it_s = exceptions.constBegin(); needExtract && it_s != exceptions.constEnd(); ++it_s) {
       QRegExp exp(*it_s, Qt::CaseInsensitive);
       if (exp.indexIn(kt.m_strMemo) != -1) {
         needExtract = false;
       }
     }
     if (needExtract) {
       QRegExp expPayee(rePayee, Qt::CaseInsensitive);
       QRegExp expMemo(reMemo, Qt::CaseInsensitive);
       if (expPayee.indexIn(kt.m_strMemo) != -1) {
         kt.m_strPayee = expPayee.cap(1);
         if (expMemo.indexIn(kt.m_strMemo) != -1) {
           kt.m_strMemo = expMemo.cap(1);
         }
       }
     }
   }
 
   kt.m_strPayee = kt.m_strPayee.trimmed();
 
   // date
   ti = AB_Transaction_GetDate(t);
   if (!ti)
     ti = AB_Transaction_GetValutaDate(t);
   if (ti) {
     int year, month, day;
 
     if (!startTime)
       startTime = ti;
     /*else { dead code
       if (GWEN_Time_Diff(ti, startTime) < 0)
         startTime = ti;
     }*/
 
     if (!GWEN_Time_GetBrokenDownDate(ti, &day, &month, &year)) {
       kt.m_datePosted = QDate(year, month + 1, day);
     }
   } else {
     DBG_WARN(0, "No date for transaction");
   }
 
   // value
   val = AB_Transaction_GetValue(t);
   if (val) {
     if (ks.m_strCurrency.isEmpty()) {
       p = AB_Value_GetCurrency(val);
       if (p)
         ks.m_strCurrency = p;
     } else {
       p = AB_Value_GetCurrency(val);
       if (p)
         s = p;
       if (ks.m_strCurrency.toLower() != s.toLower()) {
         // TODO: handle currency difference
         DBG_ERROR(0, "Mixed currencies currently not allowed");
       }
     }
 
     kt.m_amount = MyMoneyMoney(AB_Value_GetValueAsDouble(val));
     // The initial implementation of this feature was based on
     // a denominator of 100. Since the denominator might be
     // different nowadays, we make sure to use 100 for the
     // duplicate detection
     QString tmpVal = kt.m_amount.formatMoney(100, false);
     tmpVal.remove(QRegExp("[,\\.]"));
     tmpVal += QLatin1String("/100");
     h = MyMoneyTransaction::hash(tmpVal, h);
   } else {
     DBG_WARN(0, "No value for transaction");
   }
 
   if (startTime) {
     int year, month, day;
 
     if (!GWEN_Time_GetBrokenDownDate(startTime, &day, &month, &year)) {
       QDate d(year, month + 1, day);
 
       if (!ks.m_dateBegin.isValid())
         ks.m_dateBegin = d;
       else if (d < ks.m_dateBegin)
         ks.m_dateBegin = d;
 
       if (!ks.m_dateEnd.isValid())
         ks.m_dateEnd = d;
       else if (d > ks.m_dateEnd)
         ks.m_dateEnd = d;
     }
   } else {
     DBG_WARN(0, "No date in current transaction");
   }
 
   // add information about remote account to memo in case we have something
   const char *remoteAcc = AB_Transaction_GetRemoteAccountNumber(t);
   const char *remoteBankCode = AB_Transaction_GetRemoteBankCode(t);
   if (remoteAcc && remoteBankCode) {
     kt.m_strMemo += QString("\n%1/%2").arg(remoteBankCode, remoteAcc);
   }
 
   // make hash value unique in case we don't have one already
   if (kt.m_strBankID.isEmpty()) {
     QString hashBase;
     hashBase.sprintf("%s-%07lx", qPrintable(kt.m_datePosted.toString(Qt::ISODate)), h);
     int idx = 1;
     QString hash;
     for (;;) {
       hash = QString("%1-%2").arg(hashBase).arg(idx);
       QMap<QString, bool>::const_iterator it;
       it = m_hashMap.constFind(hash);
       if (it == m_hashMap.constEnd()) {
         m_hashMap[hash] = true;
         break;
       }
       ++idx;
     }
     kt.m_strBankID = QString("%1-%2").arg(acc.id()).arg(hash);
   }
 
   // store transaction
   ks.m_listTransactions += kt;
 }
 
 
 bool KBankingExt::importAccountInfo(AB_IMEXPORTER_ACCOUNTINFO *ai,
                                         uint32_t /*flags*/)
 {
   const char *p;
 
   DBG_INFO(0, "Importing account...");
 
   // account number
   MyMoneyStatement ks;
   p = AB_ImExporterAccountInfo_GetAccountNumber(ai);
   if (p) {
     ks.m_strAccountNumber = m_parent->stripLeadingZeroes(p);
   }
 
   p = AB_ImExporterAccountInfo_GetBankCode(ai);
   if (p) {
     ks.m_strRoutingNumber = m_parent->stripLeadingZeroes(p);
   }
 
   MyMoneyAccount kacc = m_parent->account("kbanking-acc-ref", QString("%1-%2").arg(ks.m_strRoutingNumber, ks.m_strAccountNumber));
   ks.m_accountId = kacc.id();
 
   // account name
   p = AB_ImExporterAccountInfo_GetAccountName(ai);
   if (p)
     ks.m_strAccountName = p;
 
   // account type
   switch (AB_ImExporterAccountInfo_GetType(ai)) {
     case AB_AccountType_Bank:
       ks.m_eType = eMyMoney::Statement::Type::Savings;
       break;
     case AB_AccountType_CreditCard:
       ks.m_eType = eMyMoney::Statement::Type::CreditCard;
       break;
     case AB_AccountType_Checking:
       ks.m_eType = eMyMoney::Statement::Type::Checkings;
       break;
     case AB_AccountType_Savings:
       ks.m_eType = eMyMoney::Statement::Type::Savings;
       break;
     case AB_AccountType_Investment:
       ks.m_eType = eMyMoney::Statement::Type::Investment;
       break;
     case AB_AccountType_Cash:
     default:
       ks.m_eType = eMyMoney::Statement::Type::None;
   }
 
   // account status
   const AB_ACCOUNT_STATUS* ast = _getAccountStatus(ai);
   if (ast) {
     const AB_BALANCE *bal;
 
     bal = AB_AccountStatus_GetBookedBalance(ast);
     if (!bal)
       bal = AB_AccountStatus_GetNotedBalance(ast);
     if (bal) {
       const AB_VALUE* val = AB_Balance_GetValue(bal);
       if (val) {
         DBG_INFO(0, "Importing balance");
         ks.m_closingBalance = AB_Value_toMyMoneyMoney(val);
         p = AB_Value_GetCurrency(val);
         if (p)
           ks.m_strCurrency = p;
       }
       const GWEN_TIME* ti = AB_Balance_GetTime(bal);
       if (ti) {
         int year, month, day;
 
         if (!GWEN_Time_GetBrokenDownDate(ti, &day, &month, &year))
           ks.m_dateEnd = QDate(year, month + 1, day);
       } else {
         DBG_WARN(0, "No time for balance");
       }
     } else {
       DBG_WARN(0, "No account balance");
     }
   } else {
     DBG_WARN(0, "No account status");
   }
 
   // clear hash map
   m_hashMap.clear();
 
   // get all transactions
   const AB_TRANSACTION* t = AB_ImExporterAccountInfo_GetFirstTransaction(ai);
   while (t) {
     _xaToStatement(ks, kacc, t);
     t = AB_ImExporterAccountInfo_GetNextTransaction(ai);
   }
 
   // import them
   if (!m_parent->importStatement(ks)) {
     if (KMessageBox::warningYesNo(0,
                                   i18n("Error importing statement. Do you want to continue?"),
                                   i18n("Critical Error")) == KMessageBox::No) {
       DBG_ERROR(0, "User aborted");
       return false;
     }
   }
   return true;
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(KBankingFactory, "kbanking.json", registerPlugin<KBanking>();)
 
 #include "kbanking.moc"
diff --git a/kmymoney/plugins/ofx/import/ofximporter.cpp b/kmymoney/plugins/ofx/import/ofximporter.cpp
index 16835ae8b..1270de618 100644
--- a/kmymoney/plugins/ofx/import/ofximporter.cpp
+++ b/kmymoney/plugins/ofx/import/ofximporter.cpp
@@ -1,881 +1,881 @@
 /***************************************************************************
                           ofximporter.cpp
                              -------------------
     begin                : Sat Jan 01 2005
     copyright            : (C) 2005 by Ace Jones
     email                : 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 "ofximporter.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFile>
 #include <QTextStream>
 #include <QRadioButton>
 #include <QSpinBox>
 #include <QByteArray>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KPluginFactory>
 #include <QUrl>
 #include <KMessageBox>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KWallet>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <libofx/libofx.h>
 #include "konlinebankingstatus.h"
 #include "konlinebankingsetupwizard.h"
 #include "kofxdirectconnectdlg.h"
 #include "mymoneyaccount.h"
 #include "mymoneyexception.h"
 #include "mymoneystatement.h"
 #include "statementinterface.h"
 #include "importinterface.h"
 #include "ui_importoption.h"
 
 //#define DEBUG_LIBOFX
 
 using KWallet::Wallet;
 
 class OFXImporter::Private
 {
 public:
   Private() : m_valid(false), m_preferName(PreferId), m_walletIsOpen(false), m_statusDlg(0), m_wallet(0),
               m_updateStartDate(QDate(1900,1,1)) {}
 
   bool m_valid;
   enum NamePreference {
     PreferId = 0,
     PreferName,
     PreferMemo
   } m_preferName;
   bool m_walletIsOpen;
   QList<MyMoneyStatement> m_statementlist;
   QList<MyMoneyStatement::Security> m_securitylist;
   QString m_fatalerror;
   QStringList m_infos;
   QStringList m_warnings;
   QStringList m_errors;
   KOnlineBankingStatus* m_statusDlg;
   Wallet *m_wallet;
   QDate m_updateStartDate;
   QStringList m_importSummary;
 };
 
 
 
 
 OFXImporter::OFXImporter(QObject *parent, const QVariantList &args) :
     KMyMoneyPlugin::Plugin(parent, "ofximporter"),
     /*
      * the string in the line above must be the same as
      * X-KDE-PluginInfo-Name and the provider name assigned in
      * OfxImporterPlugin::onlineBankingSettings()
      */
     KMyMoneyPlugin::ImporterPlugin(),
     d(new Private)
 {
   Q_UNUSED(args)
   setComponentName(QStringLiteral("ofximporter"), i18n("OFX Importer"));
   setXMLFile(QStringLiteral("ofximporter.rc"));
   createActions();
 
   // For ease announce that we have been loaded.
   qDebug("Plugins: ofximporter loaded");
 }
 
 OFXImporter::~OFXImporter()
 {
   delete d;
   qDebug("Plugins: ofximporter unloaded");
 }
 
 void OFXImporter::createActions()
 {
   QAction *action = actionCollection()->addAction("file_import_ofx");
   action->setText(i18n("OFX..."));
   connect(action, &QAction::triggered, this, static_cast<void (OFXImporter::*)()>(&OFXImporter::slotImportFile));
 }
 
 void OFXImporter::slotImportFile()
 {
   QWidget * widget = new QWidget;
   Ui_ImportOption* option = new Ui_ImportOption;
   option->setupUi(widget);
 
   QUrl url = importInterface()->selectFile(i18n("OFX import file selection"),
              QString(),
              QStringLiteral("*.ofx *.qfx *.ofc|OFX files (*.ofx *.qfx *.ofc);;*|All files (*)"),
              QFileDialog::ExistingFile,
              widget);
 
   d->m_preferName = static_cast<OFXImporter::Private::NamePreference>(option->m_preferName->currentIndex());
 
   if (url.isValid()) {
     if (isMyFormat(url.path())) {
       d->m_importSummary.clear();
       slotImportFile(url.path());
 
       if (!d->m_importSummary.isEmpty()) {
         KMessageBox::informationList(nullptr,
                                    i18n("The statement has been processed with the following results:"), d->m_importSummary, i18n("Statement stats"));
         d->m_importSummary.clear();
       }
 
     } else {
       KMessageBox::error(0, i18n("Unable to import %1 using the OFX importer plugin.  This file is not the correct format.", url.toDisplayString()), i18n("Incorrect format"));
     }
   }
   delete option;
   delete widget;
 }
 
 QString OFXImporter::formatName() const
 {
   return QStringLiteral("OFX");
 }
 
 QString OFXImporter::formatFilenameFilter() const
 {
   return QStringLiteral("*.ofx *.qfx *.ofc");
 }
 
 
 bool OFXImporter::isMyFormat(const QString& filename) const
 {
   // filename is considered an Ofx file if it contains
   // the tag "<OFX>" or "<OFC>" in the first 20 lines.
   // which contain some data
   bool result = false;
 
   QFile f(filename);
   if (f.open(QIODevice::ReadOnly | QIODevice::Text)) {
     QTextStream ts(&f);
 
     int lineCount = 20;
     while (!ts.atEnd() && !result  && lineCount != 0) {
       // get a line of data and remove all unnecessary whitepace chars
       QString line = ts.readLine().simplified();
       if (line.contains(QStringLiteral("<OFX>"), Qt::CaseInsensitive)
           || line.contains(QStringLiteral("<OFC>"), Qt::CaseInsensitive))
         result = true;
       // count only lines that contain some non white space chars
       if (!line.isEmpty())
         lineCount--;
     }
     f.close();
   }
 
   return result;
 }
 
 bool OFXImporter::import(const QString& filename)
 {
   d->m_fatalerror = i18n("Unable to parse file");
   d->m_valid = false;
   d->m_errors.clear();
   d->m_warnings.clear();
   d->m_infos.clear();
 
   d->m_statementlist.clear();
   d->m_securitylist.clear();
 
   QByteArray filename_deep = QFile::encodeName(filename);
 
   ofx_STATUS_msg = true;
   ofx_INFO_msg  = true;
   ofx_WARNING_msg = true;
   ofx_ERROR_msg = true;
 
 #ifdef DEBUG_LIBOFX
   ofx_PARSER_msg = true;
   ofx_DEBUG_msg = true;
   ofx_DEBUG1_msg = true;
   ofx_DEBUG2_msg = true;
   ofx_DEBUG3_msg = true;
   ofx_DEBUG4_msg = true;
   ofx_DEBUG5_msg = true;
 #endif
 
   LibofxContextPtr ctx = libofx_get_new_context();
   Q_CHECK_PTR(ctx);
 
   qDebug("setup callback routines");
   ofx_set_transaction_cb(ctx, ofxTransactionCallback, this);
   ofx_set_statement_cb(ctx, ofxStatementCallback, this);
   ofx_set_account_cb(ctx, ofxAccountCallback, this);
   ofx_set_security_cb(ctx, ofxSecurityCallback, this);
   ofx_set_status_cb(ctx, ofxStatusCallback, this);
   qDebug("process data");
   libofx_proc_file(ctx, filename_deep, AUTODETECT);
   libofx_free_context(ctx);
 
   if (d->m_valid) {
     d->m_fatalerror.clear();
     d->m_valid = storeStatements(d->m_statementlist);
   }
   return d->m_valid;
 }
 
 QString OFXImporter::lastError() const
 {
   if (d->m_errors.count() == 0)
     return d->m_fatalerror;
   return d->m_errors.join(QStringLiteral("<p>"));
 }
 
 /* __________________________________________________________________________
  * AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  *
  * Static callbacks for LibOFX
  *
  * YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
  */
 
 int OFXImporter::ofxTransactionCallback(struct OfxTransactionData data, void * pv)
 {
 //   kDebug(2) << Q_FUNC_INFO;
 
   OFXImporter* pofx = reinterpret_cast<OFXImporter*>(pv);
   MyMoneyStatement& s = pofx->back();
 
   MyMoneyStatement::Transaction t;
 
   if (data.date_posted_valid) {
     QDateTime dt;
     dt.setTime_t(data.date_posted);
     t.m_datePosted = dt.date();
   } else if (data.date_initiated_valid) {
     QDateTime dt;
     dt.setTime_t(data.date_initiated);
     t.m_datePosted = dt.date();
   }
   if (t.m_datePosted.isValid()) {
     // verify the transaction date is one we want
     if (t.m_datePosted < pofx->d->m_updateStartDate) {
       //kDebug(0) << "discarding transaction dated" << qPrintable(t.m_datePosted.toString(Qt::ISODate));
       return 0;
     }
   }
 
   if (data.amount_valid) {
     t.m_amount = MyMoneyMoney(data.amount, 1000);
   }
 
   if (data.check_number_valid) {
     t.m_strNumber = QString::fromUtf8(data.check_number);
   }
 
   if (data.fi_id_valid) {
     t.m_strBankID = QStringLiteral("ID ") + QString::fromUtf8(data.fi_id);
   } else if (data.reference_number_valid) {
     t.m_strBankID = QStringLiteral("REF ") + QString::fromUtf8(data.reference_number);
   }
 
   // Decide whether to use NAME, PAYEEID or MEMO to construct the payee
   bool validity[3] = {false, false, false};
   QStringList values;
   switch (pofx->d->m_preferName) {
     case OFXImporter::Private::PreferId:  // PAYEEID
     default:
       validity[0] = data.payee_id_valid;
       validity[1] = data.name_valid;
       validity[2] = data.memo_valid;
       values += QString::fromUtf8(data.payee_id);
       values += QString::fromUtf8(data.name);
       values += QString::fromUtf8(data.memo);
       break;
 
     case OFXImporter::Private::PreferName:  // NAME
       validity[0] = data.name_valid;
       validity[1] = data.payee_id_valid;
       validity[2] = data.memo_valid;
       values += QString::fromUtf8(data.name);
       values += QString::fromUtf8(data.payee_id);
       values += QString::fromUtf8(data.memo);
       break;
 
     case OFXImporter::Private::PreferMemo:  // MEMO
       validity[0] = data.memo_valid;
       validity[1] = data.payee_id_valid;
       validity[2] = data.name_valid;
       values += QString::fromUtf8(data.memo);
       values += QString::fromUtf8(data.payee_id);
       values += QString::fromUtf8(data.name);
       break;
   }
 
   // for investment transactions we don't use the meme as payee
   if (data.invtransactiontype_valid) {
     values.clear();
     validity[0] = data.payee_id_valid;
     validity[1] = data.name_valid;
     validity[2] = false;
     values += QString::fromUtf8(data.payee_id);
     values += QString::fromUtf8(data.name);
   }
 
   for (int idx = 0; idx < 3; ++idx) {
     if (validity[idx]) {
       t.m_strPayee = values[idx];
       break;
     }
   }
 
   // extract memo field if we haven't used it as payee
   if ((data.memo_valid)
       && (pofx->d->m_preferName != OFXImporter::Private::PreferMemo)) {
     t.m_strMemo = QString::fromUtf8(data.memo);
   }
 
   // If the payee or memo fields are blank, set them to
   // the other one which is NOT blank.  (acejones)
   if (t.m_strPayee.isEmpty()) {
     // But we only create a payee for non-investment transactions (ipwizard)
     if (! t.m_strMemo.isEmpty() && data.invtransactiontype_valid == false)
       t.m_strPayee = t.m_strMemo;
   } else {
     if (t.m_strMemo.isEmpty())
       t.m_strMemo = t.m_strPayee;
   }
 
   if (data.security_data_valid) {
     struct OfxSecurityData* secdata = data.security_data_ptr;
 
     if (secdata->ticker_valid) {
       t.m_strSymbol = QString::fromUtf8(secdata->ticker);
     }
 
     if (secdata->secname_valid) {
       t.m_strSecurity = QString::fromUtf8(secdata->secname);
     }
   }
 
   t.m_shares = MyMoneyMoney();
   if (data.units_valid) {
     t.m_shares = MyMoneyMoney(data.units, 100000).reduce();
   }
 
   t.m_price = MyMoneyMoney();
   if (data.unitprice_valid) {
     t.m_price = MyMoneyMoney(data.unitprice, 100000).reduce();
   }
 
   t.m_fees = MyMoneyMoney();
   if (data.fees_valid) {
     t.m_fees += MyMoneyMoney(data.fees, 1000).reduce();
   }
 
   if (data.commission_valid) {
     t.m_fees += MyMoneyMoney(data.commission, 1000).reduce();
   }
 
   bool unhandledtype = false;
   QString type;
 
   if (data.invtransactiontype_valid) {
     switch (data.invtransactiontype) {
       case OFX_BUYDEBT:
       case OFX_BUYMF:
       case OFX_BUYOPT:
       case OFX_BUYOTHER:
       case OFX_BUYSTOCK:
         t.m_eAction = eMyMoney::Transaction::Action::Buy;
         break;
       case OFX_REINVEST:
         t.m_eAction = eMyMoney::Transaction::Action::ReinvestDividend;
         break;
       case OFX_SELLDEBT:
       case OFX_SELLMF:
       case OFX_SELLOPT:
       case OFX_SELLOTHER:
       case OFX_SELLSTOCK:
         t.m_eAction = eMyMoney::Transaction::Action::Sell;
         break;
       case OFX_INCOME:
         t.m_eAction = eMyMoney::Transaction::Action::CashDividend;
         // NOTE: With CashDividend, the amount of the dividend should
         // be in data.amount.  Since I've never seen an OFX file with
         // cash dividends, this is an assumption on my part. (acejones)
         break;
 
         //
         // These types are all not handled.  We will generate a warning for them.
         //
       case OFX_CLOSUREOPT:
         unhandledtype = true;
         type = QStringLiteral("CLOSUREOPT (Close a position for an option)");
         break;
       case OFX_INVEXPENSE:
         unhandledtype = true;
         type = QStringLiteral("INVEXPENSE (Misc investment expense that is associated with a specific security)");
         break;
       case OFX_JRNLFUND:
         unhandledtype = true;
         type = QStringLiteral("JRNLFUND (Journaling cash holdings between subaccounts within the same investment account)");
         break;
       case OFX_MARGININTEREST:
         unhandledtype = true;
         type = QStringLiteral("MARGININTEREST (Margin interest expense)");
         break;
       case OFX_RETOFCAP:
         unhandledtype = true;
         type = QStringLiteral("RETOFCAP (Return of capital)");
         break;
       case OFX_SPLIT:
         unhandledtype = true;
         type = QStringLiteral("SPLIT (Stock or mutial fund split)");
         break;
       case OFX_TRANSFER:
         unhandledtype = true;
         type = QStringLiteral("TRANSFER (Transfer holdings in and out of the investment account)");
         break;
       default:
         unhandledtype = true;
         type = QString("UNKNOWN %1").arg(data.invtransactiontype);
         break;
     }
   } else
     t.m_eAction = eMyMoney::Transaction::Action::None;
 
   // In the case of investment transactions, the 'total' is supposed to the total amount
   // of the transaction.  units * unitprice +/- commission.  Easy, right?  Sadly, it seems
   // some ofx creators do not follow this in all circumstances.  Therefore, we have to double-
   // check the total here and adjust it if it's wrong.
 
 #if 0
   // Even more sadly, this logic is BROKEN.  It consistently results in bogus total
   // values, because of rounding errors in the price.  A more through solution would
   // be to test if the comission alone is causing a discrepency, and adjust in that case.
 
   if (data.invtransactiontype_valid && data.unitprice_valid) {
     double proper_total = t.m_dShares * data.unitprice + t.m_moneyFees;
     if (proper_total != t.m_moneyAmount) {
       pofx->addWarning(QString("Transaction %1 has an incorrect total of %2. Using calculated total of %3 instead.").arg(t.m_strBankID).arg(t.m_moneyAmount).arg(proper_total));
       t.m_moneyAmount = proper_total;
     }
   }
 #endif
 
   if (unhandledtype)
     pofx->addWarning(QString("Transaction %1 has an unsupported type (%2).").arg(t.m_strBankID, type));
   else
     s.m_listTransactions += t;
 
 //   kDebug(2) << Q_FUNC_INFO << "return 0 ";
 
   return 0;
 }
 
 int OFXImporter::ofxStatementCallback(struct OfxStatementData data, void* pv)
 {
 //   kDebug(2) << Q_FUNC_INFO;
 
   OFXImporter* pofx = reinterpret_cast<OFXImporter*>(pv);
   MyMoneyStatement& s = pofx->back();
 
   pofx->setValid();
 
   if (data.currency_valid) {
     s.m_strCurrency = QString::fromUtf8(data.currency);
   }
   if (data.account_id_valid) {
     s.m_strAccountNumber = QString::fromUtf8(data.account_id);
   }
 
   if (data.date_start_valid) {
     QDateTime dt;
     dt.setTime_t(data.date_start);
     s.m_dateBegin = dt.date();
   }
 
   if (data.date_end_valid) {
     QDateTime dt;
     dt.setTime_t(data.date_end);
     s.m_dateEnd = dt.date();
   }
 
   if (data.ledger_balance_valid && data.ledger_balance_date_valid) {
     s.m_closingBalance = MyMoneyMoney(data.ledger_balance);
     QDateTime dt;
     dt.setTime_t(data.ledger_balance_date);
     s.m_dateEnd = dt.date();
   }
 
 //   kDebug(2) << Q_FUNC_INFO << " return 0";
 
   return 0;
 }
 
 int OFXImporter::ofxAccountCallback(struct OfxAccountData data, void * pv)
 {
 //   kDebug(2) << Q_FUNC_INFO;
 
   OFXImporter* pofx = reinterpret_cast<OFXImporter*>(pv);
   pofx->addnew();
   MyMoneyStatement& s = pofx->back();
 
   // Having any account at all makes an ofx statement valid
   pofx->d->m_valid = true;
 
   if (data.account_id_valid) {
     s.m_strAccountName = QString::fromUtf8(data.account_name);
     s.m_strAccountNumber = QString::fromUtf8(data.account_id);
   }
   if (data.bank_id_valid) {
     s.m_strRoutingNumber = QString::fromUtf8(data.bank_id);
   }
   if (data.broker_id_valid) {
     s.m_strRoutingNumber = QString::fromUtf8(data.broker_id);
   }
   if (data.currency_valid) {
     s.m_strCurrency = QString::fromUtf8(data.currency);
   }
 
   if (data.account_type_valid) {
     switch (data.account_type) {
       case OfxAccountData::OFX_CHECKING : s.m_eType = eMyMoney::Statement::Type::Checkings;
         break;
       case OfxAccountData::OFX_SAVINGS : s.m_eType = eMyMoney::Statement::Type::Savings;
         break;
       case OfxAccountData::OFX_MONEYMRKT : s.m_eType = eMyMoney::Statement::Type::Investment;
         break;
       case OfxAccountData::OFX_CREDITLINE : s.m_eType = eMyMoney::Statement::Type::CreditCard;
         break;
       case OfxAccountData::OFX_CMA : s.m_eType = eMyMoney::Statement::Type::CreditCard;
         break;
       case OfxAccountData::OFX_CREDITCARD : s.m_eType = eMyMoney::Statement::Type::CreditCard;
         break;
       case OfxAccountData::OFX_INVESTMENT : s.m_eType = eMyMoney::Statement::Type::Investment;
         break;
     }
   }
 
   // ask KMyMoney for an account id
   s.m_accountId = pofx->account(QStringLiteral("kmmofx-acc-ref"), QString("%1-%2").arg(s.m_strRoutingNumber, s.m_strAccountNumber)).id();
 
   // copy over the securities
   s.m_listSecurities = pofx->d->m_securitylist;
 
 //   kDebug(2) << Q_FUNC_INFO << " return 0";
 
   return 0;
 }
 
 int OFXImporter::ofxSecurityCallback(struct OfxSecurityData data, void* pv)
 {
   //   kDebug(2) << Q_FUNC_INFO;
 
   OFXImporter* pofx = reinterpret_cast<OFXImporter*>(pv);
   MyMoneyStatement::Security sec;
 
   if (data.unique_id_valid) {
     sec.m_strId = QString::fromUtf8(data.unique_id);
   }
   if (data.secname_valid) {
     sec.m_strName = QString::fromUtf8(data.secname);
   }
   if (data.ticker_valid) {
     sec.m_strSymbol = QString::fromUtf8(data.ticker);
   }
 
   pofx->d->m_securitylist += sec;
 
   return 0;
 }
 
 int OFXImporter::ofxStatusCallback(struct OfxStatusData data, void * pv)
 {
 //   kDebug(2) << Q_FUNC_INFO;
 
   OFXImporter* pofx = reinterpret_cast<OFXImporter*>(pv);
   QString message;
 
   // if we got this far, we know we were able to parse the file.
   // so if it fails after here it can only because there were no actual
   // accounts in the file!
   pofx->d->m_fatalerror = i18n("No accounts found.");
 
   if (data.ofx_element_name_valid)
     message.prepend(QString("%1: ").arg(QString::fromUtf8(data.ofx_element_name)));
 
   if (data.code_valid)
     message += QString("%1 (Code %2): %3").arg(QString::fromUtf8(data.name)).arg(data.code).arg(QString::fromUtf8(data.description));
 
   if (data.server_message_valid)
     message += QString(" (%1)").arg(QString::fromUtf8(data.server_message));
 
   if (data.severity_valid) {
     switch (data.severity) {
       case OfxStatusData::INFO:
         pofx->addInfo(message);
         break;
       case OfxStatusData::ERROR:
         pofx->addError(message);
         break;
       case OfxStatusData::WARN:
         pofx->addWarning(message);
         break;
       default:
         pofx->addWarning(message);
         pofx->addWarning(QStringLiteral("Previous message was an unknown type.  'WARNING' was assumed."));
         break;
     }
   }
 
 //   kDebug(2) << Q_FUNC_INFO << " return 0 ";
 
   return 0;
 }
 
 QStringList OFXImporter::importStatement(const MyMoneyStatement &s)
 {
   qDebug("OfxImporterPlugin::importStatement start");
   return statementInterface()->import(s, true);
 }
 
 MyMoneyAccount OFXImporter::account(const QString& key, const QString& value) const
 {
   return statementInterface()->account(key, value);
 }
 
 void OFXImporter::protocols(QStringList& protocolList) const
 {
   protocolList.clear();
   protocolList << QStringLiteral("OFX");
 }
 
 QWidget* OFXImporter::accountConfigTab(const MyMoneyAccount& acc, QString& name)
 {
   name = i18n("Online settings");
   d->m_statusDlg = new KOnlineBankingStatus(acc, 0);
   return d->m_statusDlg;
 }
 
 MyMoneyKeyValueContainer OFXImporter::onlineBankingSettings(const MyMoneyKeyValueContainer& current)
 {
   MyMoneyKeyValueContainer kvp(current);
   // keep the provider name in sync with the one found in kmm_ofximport.desktop
   kvp[QStringLiteral("provider")] = objectName().toLower();
   if (d->m_statusDlg) {
     kvp.deletePair(QStringLiteral("appId"));
     kvp.deletePair(QStringLiteral("kmmofx-headerVersion"));
     kvp.deletePair(QStringLiteral("password"));
 
     d->m_wallet = openSynchronousWallet();
     if (d->m_wallet && (d->m_wallet->hasFolder(KWallet::Wallet::PasswordFolder()) ||
                         d->m_wallet->createFolder(KWallet::Wallet::PasswordFolder())) &&
         d->m_wallet->setFolder(KWallet::Wallet::PasswordFolder())) {
       QString key = OFX_PASSWORD_KEY(kvp.value(QStringLiteral("url")), kvp.value(QStringLiteral("uniqueId")));
       if (d->m_statusDlg->m_storePassword->isChecked()) {
         d->m_wallet->writePassword(key, d->m_statusDlg->m_password->text());
       } else {
         if (d->m_wallet->hasEntry(key)) {
           d->m_wallet->removeEntry(key);
         }
       }
     } else {
       if (d->m_statusDlg->m_storePassword->isChecked()) {
         kvp.setValue(QStringLiteral("password"), d->m_statusDlg->m_password->text());
       }
     }
 
     if (!d->m_statusDlg->appId().isEmpty())
       kvp.setValue(QStringLiteral("appId"), d->m_statusDlg->appId());
     kvp.setValue(QStringLiteral("kmmofx-headerVersion"), d->m_statusDlg->headerVersion());
     kvp.setValue(QStringLiteral("kmmofx-numRequestDays"), QString::number(d->m_statusDlg->m_numdaysSpin->value()));
     kvp.setValue(QStringLiteral("kmmofx-todayMinus"), QString::number(d->m_statusDlg->m_todayRB->isChecked()));
     kvp.setValue(QStringLiteral("kmmofx-lastUpdate"), QString::number(d->m_statusDlg->m_lastUpdateRB->isChecked()));
     kvp.setValue(QStringLiteral("kmmofx-pickDate"), QString::number(d->m_statusDlg->m_pickDateRB->isChecked()));
     kvp.setValue(QStringLiteral("kmmofx-specificDate"), d->m_statusDlg->m_specificDate->date().toString());
     kvp.setValue(QStringLiteral("kmmofx-preferName"), QString::number(d->m_statusDlg->m_preferredPayee->currentIndex()));
     if (!d->m_statusDlg->m_clientUidEdit->text().isEmpty())
       kvp.setValue(QStringLiteral("clientUid"), d->m_statusDlg->m_clientUidEdit->text());
     else
       kvp.deletePair(QStringLiteral("clientUid"));
     // get rid of pre 4.6 values
     kvp.deletePair(QStringLiteral("kmmofx-preferPayeeid"));
   }
   return kvp;
 }
 
 bool OFXImporter::mapAccount(const MyMoneyAccount& acc, MyMoneyKeyValueContainer& settings)
 {
   Q_UNUSED(acc);
 
   bool rc = false;
   QPointer<KOnlineBankingSetupWizard> wiz = new KOnlineBankingSetupWizard(0);
   if (wiz->isInit()) {
     if (wiz->exec() == QDialog::Accepted) {
       rc = wiz->chosenSettings(settings);
     }
   }
 
   delete wiz;
 
   return rc;
 }
 
 bool OFXImporter::updateAccount(const MyMoneyAccount& acc, bool moreAccounts)
 {
   Q_UNUSED(moreAccounts);
 
   qDebug("OfxImporterPlugin::updateAccount");
   try {
     if (!acc.id().isEmpty()) {
       // Save the value of preferName to be used by ofxTransactionCallback
       d->m_preferName = static_cast<OFXImporter::Private::NamePreference>(acc.onlineBankingSettings().value(QStringLiteral("kmmofx-preferName")).toInt());
       QPointer<KOfxDirectConnectDlg> dlg = new KOfxDirectConnectDlg(acc);
       d->m_importSummary.clear();
 
       connect(dlg.data(), &KOfxDirectConnectDlg::statementReady, this, static_cast<void (OFXImporter::*)(const QString &)>(&OFXImporter::slotImportFile));
 
       // get the date of the earliest transaction that we are interested in
       // from the settings for this account
       MyMoneyKeyValueContainer settings = acc.onlineBankingSettings();
       if (!settings.value(QStringLiteral("provider")).isEmpty()) {
         if ((settings.value(QStringLiteral("kmmofx-todayMinus")).toInt() != 0) && !settings.value(QStringLiteral("kmmofx-numRequestDays")).isEmpty()) {
           //kDebug(0) << "start date = today minus";
           d->m_updateStartDate = QDate::currentDate().addDays(-settings.value(QStringLiteral("kmmofx-numRequestDays")).toInt());
         } else if ((settings.value(QStringLiteral("kmmofx-lastUpdate")).toInt() != 0) && !acc.value(QStringLiteral("lastImportedTransactionDate")).isEmpty()) {
           //kDebug(0) << "start date = last update";
           d->m_updateStartDate = QDate::fromString(acc.value(QStringLiteral("lastImportedTransactionDate")), Qt::ISODate);
         } else if ((settings.value(QStringLiteral("kmmofx-pickDate")).toInt() != 0) && !settings.value(QStringLiteral("kmmofx-specificDate")).isEmpty()) {
           //kDebug(0) << "start date = pick date";
           d->m_updateStartDate = QDate::fromString(settings.value(QStringLiteral("kmmofx-specificDate")));
         }
         else {
           //kDebug(0) << "start date = today - 2 months";
           d->m_updateStartDate = QDate::currentDate().addMonths(-2);
         }
       }
       //kDebug(0) << "ofx plugin: account" << acc.name() << "earliest transaction date to process =" << qPrintable(d->m_updateStartDate.toString(Qt::ISODate));
 
       if (dlg->init())
         dlg->exec();
       delete dlg;
 
       if (!d->m_importSummary.isEmpty()) {
         KMessageBox::informationList(nullptr,
                                    i18n("The statement has been processed with the following results:"), d->m_importSummary, i18n("Statement stats"));
         d->m_importSummary.clear();
       }
 
       // reset the earliest-interesting-transaction date to the non-specific account setting
       d->m_updateStartDate = QDate(1900,1,1);
 
     }
   } catch (const MyMoneyException &e) {
-    KMessageBox::information(0 , i18n("Error connecting to bank: %1", e.what()));
+    KMessageBox::information(0 , i18n("Error connecting to bank: %1", QString::fromLatin1(e.what())));
   }
 
   return false;
 }
 
 void OFXImporter::slotImportFile(const QString& url)
 {
   qDebug("OfxImporterPlugin::slotImportFile");
   if (!import(url)) {
     KMessageBox::error(0, QString("<qt>%1</qt>").arg(i18n("<p>Unable to import <b>'%1'</b> using the OFX importer plugin.  The plugin returned the following error:</p><p>%2</p>", url, lastError())), i18n("Importing error"));
   }
 }
 
 bool OFXImporter::storeStatements(const QList<MyMoneyStatement> &statements)
 {
   if (statements.isEmpty())
     return true;
   auto ok = true;
   auto abort = false;
 
   // FIXME Deal with warnings/errors coming back from plugins
   /*if ( ofx.errors().count() )
   {
     if ( KMessageBox::warningContinueCancelList(this,i18n("The following errors were returned from your bank"),ofx.errors(),i18n("OFX Errors")) == KMessageBox::Cancel )
       abort = true;
   }
 
   if ( ofx.warnings().count() )
   {
     if ( KMessageBox::warningContinueCancelList(this,i18n("The following warnings were returned from your bank"),ofx.warnings(),i18n("OFX Warnings"),KStandardGuiItem::cont(),"ofxwarnings") == KMessageBox::Cancel )
       abort = true;
   }*/
 
   qDebug("OfxImporterPlugin::storeStatements() with %d statements called", statements.count());
 
   for (const auto& statement : statements) {
     if (abort)
       break;
     const auto importSummary = importStatement(statement);
     if (importSummary.isEmpty())
       ok = false;
 
     d->m_importSummary.append(importSummary);
   }
 
   if (!ok)
     KMessageBox::error(nullptr, i18n("Importing process terminated unexpectedly."), i18n("Failed to import all statements."));
 
   return ok;
 }
 
 void OFXImporter::addnew()
 {
   d->m_statementlist.push_back(MyMoneyStatement());
 }
 MyMoneyStatement& OFXImporter::back()
 {
   return d->m_statementlist.back();
 }
 bool OFXImporter::isValid() const
 {
   return d->m_valid;
 }
 void OFXImporter::setValid()
 {
   d->m_valid = true;
 }
 void OFXImporter::addInfo(const QString& _msg)
 {
   d->m_infos += _msg;
 }
 void OFXImporter::addWarning(const QString& _msg)
 {
   d->m_warnings += _msg;
 }
 void OFXImporter::addError(const QString& _msg)
 {
   d->m_errors += _msg;
 }
 const QStringList& OFXImporter::infos() const          // krazy:exclude=spelling
 {
   return d->m_infos;
 }
 const QStringList& OFXImporter::warnings() const
 {
   return d->m_warnings;
 }
 const QStringList& OFXImporter::errors() const
 {
   return d->m_errors;
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(OFXImporterFactory, "ofximporter.json", registerPlugin<OFXImporter>();)
 
 #include "ofximporter.moc"
diff --git a/kmymoney/plugins/onlinejobpluginmockup/onlinejobpluginmockup.cpp b/kmymoney/plugins/onlinejobpluginmockup/onlinejobpluginmockup.cpp
index c3380cd7b..4d32ec7eb 100644
--- a/kmymoney/plugins/onlinejobpluginmockup/onlinejobpluginmockup.cpp
+++ b/kmymoney/plugins/onlinejobpluginmockup/onlinejobpluginmockup.cpp
@@ -1,105 +1,105 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014-2015 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "onlinejobpluginmockup.h"
 
 #include <QDebug>
 
 #include <KPluginFactory>
 
 #include "mymoneyfile.h"
 #include "onlinejobadministration.h"
 
 #include "plugins/onlinetasks/sepa/tasks/sepaonlinetransfer.h"
 #include "sepacredittransfersettingsmockup.h"
 
 onlineJobPluginMockup::onlineJobPluginMockup(QObject *parent, const QVariantList &args) :
   OnlinePluginExtended(parent, "onlinejobpluginmockup")
 {
   Q_UNUSED(args);
   qDebug("onlineJobPluginMockup should be used during development only!");
 }
 
 onlineJobPluginMockup::~onlineJobPluginMockup()
 {
 }
 
 void onlineJobPluginMockup::protocols(QStringList& protocolList) const
 {
   protocolList << QLatin1String("Imaginary debugging protocol");
 }
 
 QWidget* onlineJobPluginMockup::accountConfigTab(const MyMoneyAccount&, QString&)
 {
   return 0;
 }
 
 bool onlineJobPluginMockup::mapAccount(const MyMoneyAccount& acc, MyMoneyKeyValueContainer& onlineBankingSettings)
 {
   Q_UNUSED(acc);
 
   onlineBankingSettings.setValue("provider", objectName().toLower());
   return true;
 }
 
 MyMoneyKeyValueContainer onlineJobPluginMockup::onlineBankingSettings(const MyMoneyKeyValueContainer& current)
 {
   MyMoneyKeyValueContainer nextKvp(current);
   nextKvp.setValue("provider", objectName().toLower());
   return nextKvp;
 }
 
 bool onlineJobPluginMockup::updateAccount(const MyMoneyAccount& acc, bool moreAccounts)
 {
   Q_UNUSED(moreAccounts);
   if (acc.onlineBankingSettings().value("provider").toLower() == objectName().toLower())
     return true;
   return false;
 }
 
 QStringList onlineJobPluginMockup::availableJobs(QString accountId)
 {
   try {
     if (MyMoneyFile::instance()->account(accountId).onlineBankingSettings().value("provider").toLower() == objectName().toLower())
       return onlineJobAdministration::instance()->availableOnlineTasks();
-  } catch (MyMoneyException&) {
+  } catch (const MyMoneyException &) {
   }
 
   return QStringList();
 }
 
 IonlineTaskSettings::ptr onlineJobPluginMockup::settings(QString accountId, QString taskName)
 {
   try {
     if (taskName == sepaOnlineTransfer::name() && MyMoneyFile::instance()->account(accountId).onlineBankingSettings().value("provider").toLower() == objectName().toLower())
       return IonlineTaskSettings::ptr(new sepaCreditTransferSettingsMockup);
-  } catch (MyMoneyException&) {
+  } catch (const MyMoneyException &) {
   }
   return IonlineTaskSettings::ptr();
 }
 
 void onlineJobPluginMockup::sendOnlineJob(QList< onlineJob >& jobs)
 {
   foreach (const onlineJob& job, jobs) {
     qDebug() << "Pretend to send: " << job.taskIid() << job.id();
   }
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(onlineJobPluginMockupFactory, "onlinejobpluginmockup.json", registerPlugin<onlineJobPluginMockup>();)
 
 #include "onlinejobpluginmockup.moc"
diff --git a/kmymoney/plugins/onlinetasks/sepa/tasks/sepaonlinetransferimpl.cpp b/kmymoney/plugins/onlinetasks/sepa/tasks/sepaonlinetransferimpl.cpp
index 443fb213c..c9c9390dd 100644
--- a/kmymoney/plugins/onlinetasks/sepa/tasks/sepaonlinetransferimpl.cpp
+++ b/kmymoney/plugins/onlinetasks/sepa/tasks/sepaonlinetransferimpl.cpp
@@ -1,380 +1,381 @@
 /*
   This file is part of KMyMoney, A Personal Finance Manager by KDE
   Copyright (C) 2013 Christian Dávid <christian-david@web.de>
 
   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.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "sepaonlinetransferimpl.h"
 
 #include <QSqlError>
 #include <QSqlQuery>
 
 #include "mymoneyutils.h"
 #include "mymoneyaccount.h"
 #include "mymoneyinstitution.h"
 #include "mymoney/mymoneyfile.h"
 #include "mymoneypayee.h"
 #include "mymoney/onlinejobadministration.h"
 #include "misc/validators.h"
 #include "payeeidentifiertyped.h"
 #include "ibanbic.h"
 #include "tasks/sepaonlinetransfer.h"
 
 static const unsigned short defaultTextKey = 51;
 static const unsigned short defaultSubTextKey = 0;
 
 /**
  * @brief Fallback if plugin fails to create settings correctly
  */
 class sepaOnlineTransferSettingsFallback : public sepaOnlineTransfer::settings
 {
 public:
   // Limits getter
   int purposeMaxLines() const final override {
     return 1;
   }
   int purposeLineLength() const final override {
     return 27;
   }
   int purposeMinLength() const final override {
     return 0;
   }
 
   int recipientNameLineLength() const final override {
     return 1;
   }
   int recipientNameMinLength() const final override {
     return 0;
   }
 
   int payeeNameLineLength() const final override {
     return 0;
   }
   int payeeNameMinLength() const final override {
     return 0;
   }
 
   QString allowedChars() const final override {
     return QString();
   }
 
   // Checker
   bool checkPurposeCharset(const QString&) const final override {
     return false;
   }
   bool checkPurposeLineLength(const QString&) const final override {
     return false;
   }
   validators::lengthStatus checkPurposeLength(const QString&) const final override {
     return validators::tooLong;
   }
   bool checkPurposeMaxLines(const QString&) const final override {
     return false;
   }
 
   validators::lengthStatus checkNameLength(const QString&) const final override {
     return validators::tooLong;
   }
   bool checkNameCharset(const QString&) const final override{
     return false;
   }
 
   validators::lengthStatus checkRecipientLength(const QString&) const final override {
     return validators::tooLong;
   }
   bool checkRecipientCharset(const QString&) const final override {
     return false;
   }
 
   int endToEndReferenceLength() const final override {
     return 0;
   }
   validators::lengthStatus checkEndToEndReferenceLength(const QString&) const final override {
     return validators::tooLong;
   }
   virtual bool isIbanValid(const QString&) const {
     return false;
   }
 
   bool checkRecipientBic(const QString&) const final override {
     return false;
   }
 
   bool isBicMandatory(const QString&, const QString&) const final override {
     return true;
   }
 };
 
 sepaOnlineTransferImpl::sepaOnlineTransferImpl()
     : sepaOnlineTransfer(),
     _settings(QSharedPointer<const settings>()),
     _originAccount(QString()),
     _value(0),
     _purpose(QString("")),
     _endToEndReference(QString("")),
     _beneficiaryAccount(payeeIdentifiers::ibanBic()),
     _textKey(defaultTextKey),
     _subTextKey(defaultSubTextKey)
 {
 
 }
 
 sepaOnlineTransferImpl::sepaOnlineTransferImpl(const sepaOnlineTransferImpl& other)
     : sepaOnlineTransfer(other),
     _settings(other._settings),
     _originAccount(other._originAccount),
     _value(other._value),
     _purpose(other._purpose),
     _endToEndReference(other._endToEndReference),
     _beneficiaryAccount(other._beneficiaryAccount),
     _textKey(other._textKey),
     _subTextKey(other._subTextKey)
 {
 
 }
 
 sepaOnlineTransfer *sepaOnlineTransferImpl::clone() const
 {
   sepaOnlineTransfer *transfer = new sepaOnlineTransferImpl(*this);
   return transfer;
 }
 
 //! @todo add validation of local name
 bool sepaOnlineTransferImpl::isValid() const
 {
   QString iban;
   try {
     payeeIdentifier ident = originAccountIdentifier();
     iban = ident.data<payeeIdentifiers::ibanBic>()->electronicIban();
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 
   QSharedPointer<const sepaOnlineTransfer::settings> localSettings = getSettings();
   if (localSettings->checkPurposeLength(_purpose) == validators::ok
       && localSettings->checkPurposeMaxLines(_purpose)
       && localSettings->checkPurposeLineLength(_purpose)
       && localSettings->checkPurposeCharset(_purpose)
       && localSettings->checkEndToEndReferenceLength(_endToEndReference) == validators::ok
       //&& settings->checkRecipientCharset( _beneficiaryAccount.ownerName() )
       //&& settings->checkRecipientLength( _beneficiaryAccount.ownerName()) == validators::ok
       && _beneficiaryAccount.isIbanValid() // do not check the BIC, maybe it is not needed
       && (!localSettings->isBicMandatory(iban, _beneficiaryAccount.electronicIban()) || (localSettings->checkRecipientBic(_beneficiaryAccount.bic()) && _beneficiaryAccount.isValid() /** @todo double check of BIC here, fix that */))
       && value().isPositive()
      )
     return true;
   return false;
 }
 
 payeeIdentifier sepaOnlineTransferImpl::originAccountIdentifier() const
 {
   if (!_originAccount.isEmpty()) {
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> ident = payeeIdentifierTyped<payeeIdentifiers::ibanBic>(new payeeIdentifiers::ibanBic);
     auto acc = MyMoneyFile::instance()->account(_originAccount);
     ident->setIban(acc.value(QStringLiteral("iban")));
 
     if (!acc.institutionId().isEmpty()) {
       const auto institution = MyMoneyFile::instance()->institution(acc.institutionId());
       ident->setBic(institution.value(QStringLiteral("bic")));
     }
 
     ident->setOwnerName(MyMoneyFile::instance()->user().name());
     return ident;
   }
   return payeeIdentifier(new payeeIdentifiers::ibanBic);
 }
 
 MyMoneySecurity sepaOnlineTransferImpl::currency() const
 {
   if (!_originAccount.isEmpty()) {
     const QString currencyId = MyMoneyFile::instance()->account(_originAccount).currencyId();
     return MyMoneyFile::instance()->security(currencyId);
   }
   return MyMoneyFile::instance()->baseCurrency();
 }
 
 /**
  * @internal To ensure that we never return a nullptr, @a sepaOnlineTransferSettingsFallback is used if the online plugin fails
  * to give us an correct value
  */
 QSharedPointer<const sepaOnlineTransfer::settings> sepaOnlineTransferImpl::getSettings() const
 {
   if (_settings.isNull()) {
     _settings = onlineJobAdministration::instance()->taskSettings<sepaOnlineTransferImpl::settings>(name(), _originAccount);
 
     if (_settings.isNull())
       _settings = QSharedPointer< const sepaOnlineTransfer::settings >(new sepaOnlineTransferSettingsFallback);
   }
   Q_CHECK_PTR(_settings);
   return _settings;
 }
 
 void sepaOnlineTransferImpl::setOriginAccount(const QString &accountId)
 {
   if (_originAccount != accountId) {
     _originAccount = accountId;
     _settings = QSharedPointer<const sepaOnlineTransferImpl::settings>();
   }
 }
 
 void sepaOnlineTransferImpl::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   Q_UNUSED(document);
   parent.setAttribute("originAccount", _originAccount);
   parent.setAttribute("value", _value.toString());
   parent.setAttribute("textKey", _textKey);
   parent.setAttribute("subTextKey", _subTextKey);
 
   if (!_purpose.isEmpty()) {
     parent.setAttribute("purpose", _purpose);
   }
 
   if (!_endToEndReference.isEmpty()) {
     parent.setAttribute("endToEndReference", _endToEndReference);
   }
 
   QDomElement beneficiaryEl = document.createElement("beneficiary");
   _beneficiaryAccount.writeXML(document, beneficiaryEl);
   parent.appendChild(beneficiaryEl);
 }
 
 sepaOnlineTransfer* sepaOnlineTransferImpl::createFromXml(const QDomElement& element) const
 {
   sepaOnlineTransferImpl* task = new sepaOnlineTransferImpl();
   task->setOriginAccount(element.attribute("originAccount", QString()));
   task->setValue(MyMoneyMoney(MyMoneyUtils::QStringEmpty(element.attribute("value", QString()))));
   task->_textKey = element.attribute("textKey", QString().setNum(defaultTextKey)).toUShort();
   task->_subTextKey = element.attribute("subTextKey", QString().setNum(defaultSubTextKey)).toUShort();
   task->setPurpose(element.attribute("purpose", QString()));
   task->setEndToEndReference(element.attribute("endToEndReference", QString()));
 
   payeeIdentifiers::ibanBic beneficiary;
   payeeIdentifiers::ibanBic* beneficiaryPtr = 0;
   QDomElement beneficiaryEl = element.firstChildElement("beneficiary");
   if (!beneficiaryEl.isNull()) {
     beneficiaryPtr = beneficiary.createFromXml(beneficiaryEl);
   }
 
   if (beneficiaryPtr == 0) {
     task->_beneficiaryAccount = beneficiary;
   } else {
     task->_beneficiaryAccount = *beneficiaryPtr;
   }
 
   delete beneficiaryPtr;
   return task;
 }
 
 onlineTask* sepaOnlineTransferImpl::createFromSqlDatabase(QSqlDatabase connection, const QString& onlineJobId) const
 {
   Q_ASSERT(!onlineJobId.isEmpty());
   Q_ASSERT(connection.isOpen());
 
   QSqlQuery query = QSqlQuery(
                       "SELECT originAccount, value, purpose, endToEndReference, beneficiaryName, beneficiaryIban, "
                       " beneficiaryBic, textKey, subTextKey FROM kmmSepaOrders WHERE id = ?",
                       connection
                     );
   query.bindValue(0, onlineJobId);
   if (query.exec() && query.next()) {
     sepaOnlineTransferImpl* task = new sepaOnlineTransferImpl();
     task->setOriginAccount(query.value(0).toString());
     task->setValue(MyMoneyMoney(query.value(1).toString()));
     task->setPurpose(query.value(2).toString());
     task->setEndToEndReference(query.value(3).toString());
     task->_textKey = query.value(7).toUInt();
     task->_subTextKey = query.value(8).toUInt();
 
     payeeIdentifiers::ibanBic beneficiary;
     beneficiary.setOwnerName(query.value(4).toString());
     beneficiary.setIban(query.value(5).toString());
     beneficiary.setBic(query.value(6).toString());
     task->_beneficiaryAccount = beneficiary;
     return task;
   }
 
   return 0;
 }
 
 void sepaOnlineTransferImpl::bindValuesToQuery(QSqlQuery& query, const QString& id) const
 {
   query.bindValue(":id", id);
   query.bindValue(":originAccount", _originAccount);
   query.bindValue(":value", _value.toString());
   query.bindValue(":purpose", _purpose);
   query.bindValue(":endToEndReference", (_endToEndReference.isEmpty()) ? QVariant() : QVariant::fromValue(_endToEndReference));
   query.bindValue(":beneficiaryName", _beneficiaryAccount.ownerName());
   query.bindValue(":beneficiaryIban", _beneficiaryAccount.electronicIban());
   query.bindValue(":beneficiaryBic", (_beneficiaryAccount.storedBic().isEmpty()) ? QVariant() : QVariant::fromValue(_beneficiaryAccount.storedBic()));
   query.bindValue(":textKey", _textKey);
   query.bindValue(":subTextKey", _subTextKey);
 }
 
 bool sepaOnlineTransferImpl::sqlSave(QSqlDatabase databaseConnection, const QString& onlineJobId) const
 {
   QSqlQuery query = QSqlQuery(databaseConnection);
   query.prepare("INSERT INTO kmmSepaOrders ("
                 " id, originAccount, value, purpose, endToEndReference, beneficiaryName, beneficiaryIban, "
                 " beneficiaryBic, textKey, subTextKey) "
                 " VALUES( :id, :originAccount, :value, :purpose, :endToEndReference, :beneficiaryName, :beneficiaryIban, "
                 "         :beneficiaryBic, :textKey, :subTextKey ) "
                );
   bindValuesToQuery(query, onlineJobId);
   if (!query.exec()) {
     qWarning("Error while saving sepa order '%s': %s", qPrintable(onlineJobId), qPrintable(query.lastError().text()));
     return false;
   }
   return true;
 }
 
 bool sepaOnlineTransferImpl::sqlModify(QSqlDatabase databaseConnection, const QString& onlineJobId) const
 {
   QSqlQuery query = QSqlQuery(databaseConnection);
   query.prepare(
     "UPDATE kmmSepaOrders SET"
     " originAccount = :originAccount,"
     " value = :value,"
     " purpose = :purpose,"
     " endToEndReference = :endToEndReference,"
     " beneficiaryName = :beneficiaryName,"
     " beneficiaryIban = :beneficiaryIban,"
     " beneficiaryBic = :beneficiaryBic,"
     " textKey = :textKey,"
     " subTextKey = :subTextKey "
     " WHERE id = :id");
   bindValuesToQuery(query, onlineJobId);
   if (!query.exec()) {
     qWarning("Could not modify sepaOnlineTransfer '%s': %s", qPrintable(onlineJobId), qPrintable(query.lastError().text()));
     return false;
   }
   return true;
 }
 
 bool sepaOnlineTransferImpl::sqlRemove(QSqlDatabase databaseConnection, const QString& onlineJobId) const
 {
   QSqlQuery query = QSqlQuery(databaseConnection);
   query.prepare("DELETE FROM kmmSepaOrders WHERE id = ?");
   query.bindValue(0, onlineJobId);
   return query.exec();
 }
 
 bool sepaOnlineTransferImpl::hasReferenceTo(const QString& id) const
 {
   return (id == _originAccount);
 }
 
 QString sepaOnlineTransferImpl::jobTypeName() const
 {
    return QLatin1String("SEPA Credit Transfer");
 }
diff --git a/kmymoney/plugins/onlinetasks/sepa/ui/sepacredittransferedit.cpp b/kmymoney/plugins/onlinetasks/sepa/ui/sepacredittransferedit.cpp
index 044274195..e766949aa 100644
--- a/kmymoney/plugins/onlinetasks/sepa/ui/sepacredittransferedit.cpp
+++ b/kmymoney/plugins/onlinetasks/sepa/ui/sepacredittransferedit.cpp
@@ -1,535 +1,540 @@
 /*
   This file is part of KMyMoney, A Personal Finance Manager by KDE
   Copyright (C) 2013 Christian Dávid <christian-david@web.de>
 
   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.
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "sepacredittransferedit.h"
 #include "ui_sepacredittransferedit.h"
 
 #include <QCompleter>
 #include <QSortFilterProxyModel>
 #include <QTreeView>
 
 #include <KDescendantsProxyModel>
 
 #include "kguiutils.h"
 
 #include "mymoney/payeeidentifiermodel.h"
 #include "onlinetasks/sepa/tasks/sepaonlinetransfer.h"
 #include "payeeidentifier/ibanandbic/widgets/ibanvalidator.h"
 #include "payeeidentifier/ibanandbic/widgets/bicvalidator.h"
 #include "payeeidentifier/payeeidentifiertyped.h"
 #include "misc/charvalidator.h"
 #include "payeeidentifier/ibanandbic/ibanbic.h"
 #include "styleditemdelegateforwarder.h"
 #include "payeeidentifier/ibanandbic/widgets/ibanbicitemdelegate.h"
 #include "onlinejobtyped.h"
 #include "mymoneyaccount.h"
 #include "widgetenums.h"
 
 class ibanBicCompleterDelegate : public StyledItemDelegateForwarder
 {
   Q_OBJECT
 
 public:
   ibanBicCompleterDelegate(QObject *parent)
       : StyledItemDelegateForwarder(parent) {}
 
 protected:
   QAbstractItemDelegate* getItemDelegate(const QModelIndex &index) const final override {
     static QPointer<QAbstractItemDelegate> defaultDelegate;
     static QPointer<QAbstractItemDelegate> ibanBicDelegate;
 
     const bool ibanBicRequested = index.model()->data(index, payeeIdentifierModel::isPayeeIdentifier).toBool();
 
     QAbstractItemDelegate* delegate = (ibanBicRequested)
                                       ? ibanBicDelegate
                                       : defaultDelegate;
 
     if (delegate == 0) {
       if (ibanBicRequested) {
         // Use this->parent() as parent because "this" is const
         ibanBicDelegate = new ibanBicItemDelegate(this->parent());
         delegate = ibanBicDelegate;
       } else {
         // Use this->parent() as parent because "this" is const
         defaultDelegate = new QStyledItemDelegate(this->parent());
         delegate = defaultDelegate;
       }
       connectSignals(delegate, Qt::UniqueConnection);
     }
     Q_CHECK_PTR(delegate);
     return delegate;
   }
 };
 
 class payeeIdentifierCompleterPopup : public QTreeView
 {
   Q_OBJECT
 
 public:
   payeeIdentifierCompleterPopup(QWidget* parent = 0)
       : QTreeView(parent) {
     setRootIsDecorated(false);
     setAlternatingRowColors(true);
     setAnimated(true);
     setHeaderHidden(true);
     setUniformRowHeights(false);
     expandAll();
   }
 };
 
 class ibanBicFilterProxyModel : public QSortFilterProxyModel
 {
   Q_OBJECT
 
 public:
   enum roles {
     payeeIban = payeeIdentifierModel::payeeIdentifierUserRole, /**< electornic IBAN of payee */
   };
 
   ibanBicFilterProxyModel(QObject* parent = 0)
       : QSortFilterProxyModel(parent) {}
 
   QVariant data(const QModelIndex &index, int role) const final override {
     if (role == payeeIban) {
       if (!index.isValid())
         return QVariant();
 
       try {
         payeeIdentifierTyped<payeeIdentifiers::ibanBic> iban = payeeIdentifierTyped<payeeIdentifiers::ibanBic>(
               index.model()->data(index, payeeIdentifierModel::payeeIdentifier).value<payeeIdentifier>()
             );
         return iban->electronicIban();
-      } catch (payeeIdentifier::exception&) {
+      } catch (const payeeIdentifier::empty &) {
+        return QVariant();
+      } catch (const payeeIdentifier::badCast &) {
         return QVariant();
       }
     }
 
     return QSortFilterProxyModel::data(index, role);
   }
 
   bool filterAcceptsRow(int source_row, const QModelIndex& source_parent) const final override {
     if (!source_parent.isValid())
       return true;
 
     QModelIndex index = source_parent.model()->index(source_row, 0, source_parent);
     return (source_parent.model()->data(index, payeeIdentifierModel::payeeIdentifierType).toString() == payeeIdentifiers::ibanBic::staticPayeeIdentifierIid());
   }
 };
 
 class ibanBicCompleter : public QCompleter
 {
   Q_OBJECT
 
 public:
   ibanBicCompleter(QObject* parent = 0);
 
 Q_SIGNALS:
   void activatedName(const QString& name) const;
   void highlightedName(const QString& name) const;
 
   void activatedBic(const QString& bic) const;
   void highlightedBic(const QString& bic) const;
 
   void activatedIban(const QString& iban) const;
   void highlightedIban(const QString& iban) const;
 
 private Q_SLOTS:
   void slotActivated(const QModelIndex& index) const;
   void slotHighlighted(const QModelIndex& index) const;
 };
 
 ibanBicCompleter::ibanBicCompleter(QObject *parent)
     : QCompleter(parent)
 {
   connect(this, SIGNAL(activated(QModelIndex)), SLOT(slotActivated(QModelIndex)));
   connect(this, SIGNAL(highlighted(QModelIndex)), SLOT(slotHighlighted(QModelIndex)));
 }
 
 void ibanBicCompleter::slotActivated(const QModelIndex &index) const
 {
   if (!index.isValid())
     return;
 
   emit activatedName(index.model()->data(index, payeeIdentifierModel::payeeName).toString());
   try {
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> iban = payeeIdentifierTyped<payeeIdentifiers::ibanBic>(
           index.model()->data(index, payeeIdentifierModel::payeeIdentifier).value<payeeIdentifier>()
         );
     emit activatedIban(iban->electronicIban());
     emit activatedBic(iban->storedBic());
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 }
 
 void ibanBicCompleter::slotHighlighted(const QModelIndex &index) const
 {
   if (!index.isValid())
     return;
 
   emit highlightedName(index.model()->data(index, payeeIdentifierModel::payeeName).toString());
   try {
     payeeIdentifierTyped<payeeIdentifiers::ibanBic> iban = payeeIdentifierTyped<payeeIdentifiers::ibanBic>(
           index.model()->data(index, payeeIdentifierModel::payeeIdentifier).value<payeeIdentifier>()
         );
     emit highlightedIban(iban->electronicIban());
     emit highlightedBic(iban->storedBic());
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 }
 
 sepaCreditTransferEdit::sepaCreditTransferEdit(QWidget *parent, QVariantList args) :
     IonlineJobEdit(parent, args),
     ui(new Ui::sepaCreditTransferEdit),
     m_onlineJob(onlineJobTyped<sepaOnlineTransfer>()),
     m_requiredFields(new KMandatoryFieldGroup(this)),
     m_readOnly(false),
     m_showAllErrors(false)
 {
   ui->setupUi(this);
 
   m_requiredFields->add(ui->beneficiaryIban);
   m_requiredFields->add(ui->value);
   // Other required fields are set in updateSettings()
 
   connect(m_requiredFields, SIGNAL(stateChanged(bool)), this, SLOT(requiredFieldsCompleted(bool)));
 
   connect(ui->beneficiaryName, SIGNAL(textChanged(QString)), this, SLOT(beneficiaryNameChanged(QString)));
   connect(ui->beneficiaryIban, SIGNAL(textChanged(QString)), this, SLOT(beneficiaryIbanChanged(QString)));
   connect(ui->beneficiaryBankCode, SIGNAL(textChanged(QString)), this, SLOT(beneficiaryBicChanged(QString)));
   connect(ui->value, SIGNAL(valueChanged(QString)), this, SLOT(valueChanged()));
   connect(ui->sepaReference, SIGNAL(textChanged(QString)), this, SLOT(endToEndReferenceChanged(QString)));
   connect(ui->purpose, SIGNAL(textChanged()), this, SLOT(purposeChanged()));
 
   connect(qApp, SIGNAL(focusChanged(QWidget*,QWidget*)), this, SLOT(updateEveryStatus()));
 
   connect(ui->beneficiaryName, SIGNAL(textChanged(QString)), this, SIGNAL(onlineJobChanged()));
   connect(ui->beneficiaryIban, SIGNAL(textChanged(QString)), this, SIGNAL(onlineJobChanged()));
   connect(ui->beneficiaryBankCode, SIGNAL(textChanged(QString)), this, SIGNAL(onlineJobChanged()));
   connect(ui->value, SIGNAL(valueChanged(QString)), this, SIGNAL(onlineJobChanged()));
   connect(ui->sepaReference, SIGNAL(textChanged(QString)), this, SIGNAL(onlineJobChanged()));
   connect(ui->purpose, SIGNAL(textChanged()), this, SIGNAL(onlineJobChanged()));
 
   // Connect signals for read only
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->beneficiaryName, SLOT(setReadOnly(bool)));
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->beneficiaryIban, SLOT(setReadOnly(bool)));
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->beneficiaryBankCode, SLOT(setReadOnly(bool)));
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->value, SLOT(setReadOnly(bool)));
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->sepaReference, SLOT(setReadOnly(bool)));
   connect(this, SIGNAL(readOnlyChanged(bool)), ui->purpose, SLOT(setReadOnly(bool)));
 
   // Create models for completers
   payeeIdentifierModel* identModel = new payeeIdentifierModel(this);
   identModel->setTypeFilter(payeeIdentifiers::ibanBic::staticPayeeIdentifierIid());
 
   ibanBicFilterProxyModel* filterModel = new ibanBicFilterProxyModel(this);
   filterModel->setSourceModel(identModel);
 
   KDescendantsProxyModel* descendantsModel = new KDescendantsProxyModel(this);
   descendantsModel->setSourceModel(filterModel);
 
   // Set completers popup and bind them to the corresponding fields
   {
     // Beneficiary name field
     ibanBicCompleter* completer = new ibanBicCompleter(this);
     completer->setModel(descendantsModel);
     completer->setCompletionRole(payeeIdentifierModel::payeeName);
     completer->setCaseSensitivity(Qt::CaseInsensitive);
 
     connect(completer, SIGNAL(activatedIban(QString)), ui->beneficiaryIban, SLOT(setText(QString)));
     connect(completer, SIGNAL(activatedBic(QString)), ui->beneficiaryBankCode, SLOT(setText(QString)));
 
     ui->beneficiaryName->setCompleter(completer);
 
     QAbstractItemView *itemView = new payeeIdentifierCompleterPopup();
     completer->setPopup(itemView);
 
     // setPopup() resets the delegate
     itemView->setItemDelegate(new ibanBicCompleterDelegate(this));
   }
   {
     // IBAN field
     ibanBicCompleter* ibanCompleter = new ibanBicCompleter(this);
     ibanCompleter->setModel(descendantsModel);
     ibanCompleter->setCompletionRole(ibanBicFilterProxyModel::payeeIban);
     ibanCompleter->setCaseSensitivity(Qt::CaseInsensitive);
 
     connect(ibanCompleter, SIGNAL(activatedName(QString)), ui->beneficiaryName, SLOT(setText(QString)));
     connect(ibanCompleter, SIGNAL(activatedBic(QString)), ui->beneficiaryBankCode, SLOT(setText(QString)));
 
     ui->beneficiaryIban->setCompleter(ibanCompleter);
 
     QAbstractItemView *itemView = new payeeIdentifierCompleterPopup();
     ibanCompleter->setPopup(itemView);
 
     // setPopup() resets the delegate
     itemView->setItemDelegate(new ibanBicCompleterDelegate(this));
   }
 }
 
 sepaCreditTransferEdit::~sepaCreditTransferEdit()
 {
   delete ui;
 }
 
 void sepaCreditTransferEdit::showEvent(QShowEvent* event)
 {
   updateEveryStatus();
   QWidget::showEvent(event);
 }
 
 void sepaCreditTransferEdit::showAllErrorMessages(const bool state)
 {
   if (m_showAllErrors != state) {
     m_showAllErrors = state;
     updateEveryStatus();
   }
 }
 
 onlineJobTyped<sepaOnlineTransfer> sepaCreditTransferEdit::getOnlineJobTyped() const
 {
   onlineJobTyped<sepaOnlineTransfer> sepaJob(m_onlineJob);
 
   sepaJob.task()->setValue(ui->value->value());
   sepaJob.task()->setPurpose(ui->purpose->toPlainText());
   sepaJob.task()->setEndToEndReference(ui->sepaReference->text());
 
   payeeIdentifiers::ibanBic accIdent;
   accIdent.setOwnerName(ui->beneficiaryName->text());
   accIdent.setIban(ui->beneficiaryIban->text());
   accIdent.setBic(ui->beneficiaryBankCode->text());
   sepaJob.task()->setBeneficiary(accIdent);
 
   return sepaJob;
 }
 
 void sepaCreditTransferEdit::setOnlineJob(const onlineJobTyped<sepaOnlineTransfer>& job)
 {
   m_onlineJob = job;
   updateSettings();
   setReadOnly(!job.isEditable());
 
   ui->purpose->setText(job.task()->purpose());
   ui->sepaReference->setText(job.task()->endToEndReference());
   ui->value->setValue(job.task()->value());
   ui->beneficiaryName->setText(job.task()->beneficiaryTyped().ownerName());
   ui->beneficiaryIban->setText(job.task()->beneficiaryTyped().paperformatIban());
   ui->beneficiaryBankCode->setText(job.task()->beneficiaryTyped().storedBic());
 }
 
 bool sepaCreditTransferEdit::setOnlineJob(const onlineJob& job)
 {
   if (!job.isNull() && job.task()->taskName() == sepaOnlineTransfer::name()) {
     setOnlineJob(onlineJobTyped<sepaOnlineTransfer>(job));
     return true;
   }
   return false;
 }
 
 void sepaCreditTransferEdit::setOriginAccount(const QString& accountId)
 {
   m_onlineJob.task()->setOriginAccount(accountId);
   updateSettings();
 }
 
 void sepaCreditTransferEdit::updateEveryStatus()
 {
   beneficiaryNameChanged(ui->beneficiaryName->text());
   beneficiaryIbanChanged(ui->beneficiaryIban->text());
   beneficiaryBicChanged(ui->beneficiaryBankCode->text());
   purposeChanged();
   valueChanged();
   endToEndReferenceChanged(ui->sepaReference->text());
 }
 
 void sepaCreditTransferEdit::setReadOnly(const bool& readOnly)
 {
   // Only set writeable if it changes something and if it is possible
   if (readOnly != m_readOnly && (readOnly == true || getOnlineJobTyped().isEditable())) {
     m_readOnly = readOnly;
     emit readOnlyChanged(m_readOnly);
   }
 }
 
 void sepaCreditTransferEdit::updateSettings()
 {
   QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
   // Reference
   ui->sepaReference->setMaxLength(settings->endToEndReferenceLength());
   if (settings->endToEndReferenceLength() == 0)
     ui->sepaReference->setEnabled(false);
   else
     ui->sepaReference->setEnabled(true);
 
   // Purpose
   ui->purpose->setAllowedChars(settings->allowedChars());
   ui->purpose->setMaxLineLength(settings->purposeLineLength());
   ui->purpose->setMaxLines(settings->purposeMaxLines());
   if (settings->purposeMinLength())
     m_requiredFields->add(ui->purpose);
   else
     m_requiredFields->remove(ui->purpose);
 
   // Beneficiary Name
   ui->beneficiaryName->setValidator(new charValidator(ui->beneficiaryName, settings->allowedChars()));
   ui->beneficiaryName->setMaxLength(settings->recipientNameLineLength());
 
   if (settings->recipientNameMinLength() != 0)
     m_requiredFields->add(ui->beneficiaryName);
   else
     m_requiredFields->remove(ui->beneficiaryName);
 
   updateEveryStatus();
 }
 
 void sepaCreditTransferEdit::beneficiaryIbanChanged(const QString& iban)
 {
   // Check IBAN
   QPair<eWidgets::ValidationFeedback::MessageType, QString> answer = ibanValidator::validateWithMessage(iban);
   if (m_showAllErrors || iban.length() > 5 || (!ui->beneficiaryIban->hasFocus() && !iban.isEmpty()))
     ui->feedbackIban->setFeedback(answer.first, answer.second);
   else
     ui->feedbackIban->removeFeedback();
 
   // Check if BIC is mandatory
   QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
 
   QString payeeIban;
   try {
     payeeIdentifier ident = getOnlineJobTyped().task()->originAccountIdentifier();
     payeeIban = ident.data<payeeIdentifiers::ibanBic>()->electronicIban();
-  } catch (payeeIdentifier::exception&) {
+  } catch (const payeeIdentifier::empty &) {
+  } catch (const payeeIdentifier::badCast &) {
   }
 
   if (settings->isBicMandatory(payeeIban, iban)) {
     m_requiredFields->add(ui->beneficiaryBankCode);
     beneficiaryBicChanged(ui->beneficiaryBankCode->text());
   } else {
     m_requiredFields->remove(ui->beneficiaryBankCode);
     beneficiaryBicChanged(ui->beneficiaryBankCode->text());
   }
 }
 
 void sepaCreditTransferEdit::beneficiaryBicChanged(const QString& bic)
 {
   if (bic.isEmpty() && !ui->beneficiaryIban->text().isEmpty()) {
     QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
 
     const payeeIdentifier payee = getOnlineJobTyped().task()->originAccountIdentifier();
     QString iban;
     try {
       iban = payee.data<payeeIdentifiers::ibanBic>()->electronicIban();
-    } catch (payeeIdentifier::badCast&) {
+    } catch (const payeeIdentifier::badCast &) {
     }
 
     if (settings->isBicMandatory(iban , ui->beneficiaryIban->text())) {
       ui->feedbackBic->setFeedback(eWidgets::ValidationFeedback::MessageType::Error, i18n("For this beneficiary's country the BIC is mandatory."));
       return;
     }
   }
 
   QPair<eWidgets::ValidationFeedback::MessageType, QString> answer = bicValidator::validateWithMessage(bic);
   if (m_showAllErrors || bic.length() >= 8 || (!ui->beneficiaryBankCode->hasFocus() && !bic.isEmpty()))
     ui->feedbackBic->setFeedback(answer.first, answer.second);
   else
     ui->feedbackBic->removeFeedback();
 }
 
 void sepaCreditTransferEdit::beneficiaryNameChanged(const QString& name)
 {
   QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
   if (name.length() < settings->recipientNameMinLength() && (m_showAllErrors || (!ui->beneficiaryName->hasFocus() && !name.isEmpty()))) {
     ui->feedbackName->setFeedback(eWidgets::ValidationFeedback::MessageType::Error, i18np("A beneficiary name is needed.", "The beneficiary name must be at least %1 characters long",
                                   settings->recipientNameMinLength()
                                                                           ));
   } else {
     ui->feedbackName->removeFeedback();
   }
 }
 
 void sepaCreditTransferEdit::valueChanged()
 {
   if ((!ui->value->isValid() && (m_showAllErrors || (!ui->value->hasFocus() && ui->value->value().toDouble() != 0))) || (!ui->value->value().isPositive() && ui->value->value().toDouble() != 0)) {
     ui->feedbackAmount->setFeedback(eWidgets::ValidationFeedback::MessageType::Error, i18n("A positive amount to transfer is needed."));
     return;
   }
 
   if (!ui->value->isValid())
     return;
 
   const MyMoneyAccount account = getOnlineJob().responsibleMyMoneyAccount();
   const MyMoneyMoney expectedBalance = account.balance() - ui->value->value();
 
   if (expectedBalance < MyMoneyMoney(account.value("maxCreditAbsolute"))) {
     ui->feedbackAmount->setFeedback(eWidgets::ValidationFeedback::MessageType::Warning, i18n("After this credit transfer the account's balance will be below your credit limit."));
   } else if (expectedBalance < MyMoneyMoney(account.value("minBalanceAbsolute"))) {
     ui->feedbackAmount->setFeedback(eWidgets::ValidationFeedback::MessageType::Information, i18n("After this credit transfer the account's balance will be below the minimal balance."));
   } else {
     ui->feedbackAmount->removeFeedback();
   }
 }
 
 void sepaCreditTransferEdit::endToEndReferenceChanged(const QString& reference)
 {
   QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
   if (settings->checkEndToEndReferenceLength(reference) == validators::tooLong) {
     ui->feedbackReference->setFeedback(eWidgets::ValidationFeedback::MessageType::Error, i18np("The end-to-end reference cannot contain more than one character.",
                                        "The end-to-end reference cannot contain more than %1 characters.",
                                        settings->endToEndReferenceLength()
                                                                                ));
   } else {
     ui->feedbackReference->removeFeedback();
   }
 }
 
 void sepaCreditTransferEdit::purposeChanged()
 {
   const QString purpose = ui->purpose->toPlainText();
   QSharedPointer<const sepaOnlineTransfer::settings> settings = taskSettings();
 
   QString message;
   if (!settings->checkPurposeLineLength(purpose))
     message = i18np("The maximal line length of %1 character per line is exceeded.", "The maximal line length of %1 characters per line is exceeded.",
                     settings->purposeLineLength())
               .append('\n');
   if (!settings->checkPurposeCharset(purpose))
     message.append(i18n("The purpose can only contain the letters A-Z, spaces and ':?.,-()+ and /")).append('\n');
   if (!settings->checkPurposeMaxLines(purpose)) {
     message.append(i18np("In the purpose only a single line is allowed.", "The purpose cannot contain more than %1 lines.",
                          settings->purposeMaxLines()))
     .append('\n');
   } else if (settings->checkPurposeLength(purpose) == validators::tooShort) {
     message.append(i18np("A purpose is needed.", "The purpose must be at least %1 characters long.", settings->purposeMinLength()))
     .append('\n');
   }
 
   // Remove the last '\n'
   message.chop(1);
 
   if (!message.isEmpty()) {
     ui->feedbackPurpose->setFeedback(eWidgets::ValidationFeedback::MessageType::Error, message);
   } else {
     ui->feedbackPurpose->removeFeedback();
   }
 }
 
 QSharedPointer< const sepaOnlineTransfer::settings > sepaCreditTransferEdit::taskSettings()
 {
   return getOnlineJobTyped().constTask()->getSettings();
 }
 
 #include "sepacredittransferedit.moc"
diff --git a/kmymoney/plugins/qif/config/mymoneyqifprofile.cpp b/kmymoney/plugins/qif/config/mymoneyqifprofile.cpp
index 647d56d41..c04b216d7 100644
--- a/kmymoney/plugins/qif/config/mymoneyqifprofile.cpp
+++ b/kmymoney/plugins/qif/config/mymoneyqifprofile.cpp
@@ -1,1003 +1,1003 @@
 /***************************************************************************
                           mymoneyqifprofile.cpp  -  description
                              -------------------
     begin                : Tue Dec 24 2002
     copyright            : (C) 2002 by Thomas Baumgart
     email                : thb@net-bembel.de
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyqifprofile.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QRegExp>
 #include <QVector>
 #include <QLocale>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneymoney.h"
 #include "mymoneyenums.h"
 
 /*
  * CENTURY_BREAK is used to identfy the century for a two digit year
  *
  * if yr is < CENTURY_BREAK it is in 2000
  * if yr is >= CENTURY_BREAK it is in 1900
  *
  * so with CENTURY_BREAK being 70 the following will happen:
  *
  *  00..69  ->  2000..2069
  *  70..99  ->  1970..1999
  */
 const int CENTURY_BREAK = 70;
 
 class MyMoneyQifProfile::Private
 {
 public:
   Private() :
       m_changeCount(3, 0),
       m_lastValue(3, 0),
       m_largestValue(3, 0) { }
 
   void getThirdPosition();
   void dissectDate(QVector<QString>& parts, const QString& txt) const;
 
   QVector<int>    m_changeCount;
   QVector<int>    m_lastValue;
   QVector<int>    m_largestValue;
   QMap<QChar, int>     m_partPos;
 };
 
 void MyMoneyQifProfile::Private::dissectDate(QVector<QString>& parts, const QString& txt) const
 {
   QRegExp nonDelimChars("[ 0-9a-zA-Z]");
   int part = 0;                 // the current part we scan
   int pos;             // the current scan position
   int maxPartSize = txt.length() > 6 ? 4 : 2;
   // the maximum size of a part
   // some fu... up MS-Money versions write two delimiter in a row
   // so we need to keep track of them. Example: D14/12/'08
   bool lastWasDelim = false;
 
   // separate the parts of the date and keep the locations of the delimiters
   for (pos = 0; pos < txt.length() && part < 3; ++pos) {
     if (nonDelimChars.indexIn(txt[pos]) == -1) {
       if (!lastWasDelim) {
         ++part;
         maxPartSize = 0;         // make sure to pick the right one depending if next char is numeric or not
         lastWasDelim = true;
       }
     } else {
       lastWasDelim = false;
       // check if the part is over and we did not see a delimiter
       if ((maxPartSize != 0) && (parts[part].length() == maxPartSize)) {
         ++part;
         maxPartSize = 0;
       }
       if (maxPartSize == 0) {
         maxPartSize = txt[pos].isDigit() ? 2 : 3;
         if (part == 2)
           maxPartSize = 4;
       }
       if (part < 3)
         parts[part] += txt[pos];
     }
   }
 
   if (part == 3) { // invalid date
     for (int i = 0; i < 3; ++i) {
       parts[i] = '0';
     }
   }
 }
 
 
 void MyMoneyQifProfile::Private::getThirdPosition()
 {
   // if we have detected two parts we can calculate the third and its position
   if (m_partPos.count() == 2) {
     QList<QChar> partsPresent = m_partPos.keys();
     QStringList partsAvail = QString("d,m,y").split(',');
     int missingIndex = -1;
     int value = 0;
     for (int i = 0; i < 3; ++i) {
       if (!partsPresent.contains(partsAvail[i][0])) {
         missingIndex = i;
       } else {
         value += m_partPos[partsAvail[i][0]];
       }
     }
     m_partPos[partsAvail[missingIndex][0]] = 3 - value;
   }
 }
 
 
 
 MyMoneyQifProfile::MyMoneyQifProfile() :
     d(new Private),
     m_isDirty(false)
 {
   clear();
 }
 
 MyMoneyQifProfile::MyMoneyQifProfile(const QString& name) :
     d(new Private),
     m_isDirty(false)
 {
   loadProfile(name);
 }
 
 MyMoneyQifProfile::~MyMoneyQifProfile()
 {
   delete d;
 }
 
 void MyMoneyQifProfile::clear()
 {
   m_dateFormat = "%d.%m.%yyyy";
   m_apostropheFormat = "2000-2099";
   m_valueMode = "";
   m_filterScriptImport = "";
   m_filterScriptExport = "";
   m_filterFileType = "*.qif";
 
   m_decimal.clear();
   m_decimal['$'] =
     m_decimal['Q'] =
       m_decimal['T'] =
         m_decimal['O'] =
           m_decimal['I'] = QLocale().decimalPoint();
 
   m_thousands.clear();
   m_thousands['$'] =
     m_thousands['Q'] =
       m_thousands['T'] =
         m_thousands['O'] =
           m_thousands['I'] = QLocale().groupSeparator();
 
   m_openingBalanceText = "Opening Balance";
   m_voidMark = "VOID ";
   m_accountDelimiter = '[';
 
   m_profileName = "";
   m_profileDescription = "";
   m_profileType = "Bank";
 
   m_attemptMatchDuplicates = true;
 }
 
 void MyMoneyQifProfile::loadProfile(const QString& name)
 {
   KSharedConfigPtr config = KSharedConfig::openConfig();
   KConfigGroup grp = config->group(name);
 
   clear();
 
   m_profileName = name;
   m_profileDescription = grp.readEntry("Description", m_profileDescription);
   m_profileType = grp.readEntry("Type", m_profileType);
   m_dateFormat = grp.readEntry("DateFormat", m_dateFormat);
   m_apostropheFormat = grp.readEntry("ApostropheFormat", m_apostropheFormat);
   m_accountDelimiter = grp.readEntry("AccountDelimiter", m_accountDelimiter);
   m_openingBalanceText = grp.readEntry("OpeningBalance", m_openingBalanceText);
   m_voidMark = grp.readEntry("VoidMark", m_voidMark);
   m_filterScriptImport = grp.readEntry("FilterScriptImport", m_filterScriptImport);
   m_filterScriptExport = grp.readEntry("FilterScriptExport", m_filterScriptExport);
   m_filterFileType = grp.readEntry("FilterFileType", m_filterFileType);
 
   m_attemptMatchDuplicates = grp.readEntry("AttemptMatchDuplicates", m_attemptMatchDuplicates);
 
   // make sure, we remove any old stuff for now
   grp.deleteEntry("FilterScript");
 
   QString tmp = QString(m_decimal['Q']) + m_decimal['T'] + m_decimal['I'] +
                 m_decimal['$'] + m_decimal['O'];
   tmp = grp.readEntry("Decimal", tmp);
   m_decimal['Q'] = tmp[0];
   m_decimal['T'] = tmp[1];
   m_decimal['I'] = tmp[2];
   m_decimal['$'] = tmp[3];
   m_decimal['O'] = tmp[4];
 
   tmp = QString(m_thousands['Q']) + m_thousands['T'] + m_thousands['I'] +
         m_thousands['$'] + m_thousands['O'];
   tmp = grp.readEntry("Thousand", tmp);
   m_thousands['Q'] = tmp[0];
   m_thousands['T'] = tmp[1];
   m_thousands['I'] = tmp[2];
   m_thousands['$'] = tmp[3];
   m_thousands['O'] = tmp[4];
 
   m_isDirty = false;
 }
 
 void MyMoneyQifProfile::saveProfile()
 {
   if (m_isDirty == true) {
     KSharedConfigPtr config = KSharedConfig::openConfig();
     KConfigGroup grp = config->group(m_profileName);
 
     grp.writeEntry("Description", m_profileDescription);
     grp.writeEntry("Type", m_profileType);
     grp.writeEntry("DateFormat", m_dateFormat);
     grp.writeEntry("ApostropheFormat", m_apostropheFormat);
     grp.writeEntry("AccountDelimiter", m_accountDelimiter);
     grp.writeEntry("OpeningBalance", m_openingBalanceText);
     grp.writeEntry("VoidMark", m_voidMark);
     grp.writeEntry("FilterScriptImport", m_filterScriptImport);
     grp.writeEntry("FilterScriptExport", m_filterScriptExport);
     grp.writeEntry("FilterFileType", m_filterFileType);
     grp.writeEntry("AttemptMatchDuplicates", m_attemptMatchDuplicates);
 
     QString tmp;
 
     tmp = QString(m_decimal['Q']) + m_decimal['T'] + m_decimal['I'] +
           m_decimal['$'] + m_decimal['O'];
     grp.writeEntry("Decimal", tmp);
     tmp = QString(m_thousands['Q']) + m_thousands['T'] + m_thousands['I'] +
           m_thousands['$'] + m_thousands['O'];
     grp.writeEntry("Thousand", tmp);
   }
   m_isDirty = false;
 }
 
 void MyMoneyQifProfile::setProfileName(const QString& name)
 {
   if (m_profileName != name)
     m_isDirty = true;
 
   m_profileName = name;
 }
 
 void MyMoneyQifProfile::setProfileDescription(const QString& desc)
 {
   if (m_profileDescription != desc)
     m_isDirty = true;
 
   m_profileDescription = desc;
 }
 
 void MyMoneyQifProfile::setProfileType(const QString& type)
 {
   if (m_profileType != type)
     m_isDirty = true;
   m_profileType = type;
 }
 
 void MyMoneyQifProfile::setOutputDateFormat(const QString& dateFormat)
 {
   if (m_dateFormat != dateFormat)
     m_isDirty = true;
 
   m_dateFormat = dateFormat;
 }
 
 void MyMoneyQifProfile::setInputDateFormat(const QString& dateFormat)
 {
   int j = -1;
   if (dateFormat.length() > 0) {
     for (int i = 0; i < dateFormat.length() - 1; ++i) {
       if (dateFormat[i] == '%') {
         d->m_partPos[dateFormat[++i]] = ++j;
       }
     }
   }
 }
 
 void MyMoneyQifProfile::setApostropheFormat(const QString& apostropheFormat)
 {
   if (m_apostropheFormat != apostropheFormat)
     m_isDirty = true;
 
   m_apostropheFormat = apostropheFormat;
 }
 
 void MyMoneyQifProfile::setAmountDecimal(const QChar& def, const QChar& chr)
 {
   QChar ch(chr);
   if (ch == QChar())
     ch = ' ';
 
   if (m_decimal[def] != ch)
     m_isDirty = true;
 
   m_decimal[def] = ch;
 }
 
 void MyMoneyQifProfile::setAmountThousands(const QChar& def, const QChar& chr)
 {
   QChar ch(chr);
   if (ch == QChar())
     ch = ' ';
 
   if (m_thousands[def] != ch)
     m_isDirty = true;
 
   m_thousands[def] = ch;
 }
 
 const QChar MyMoneyQifProfile::amountDecimal(const QChar& def) const
 {
   QChar chr = m_decimal[def];
   return chr;
 }
 
 const QChar MyMoneyQifProfile::amountThousands(const QChar& def) const
 {
   QChar chr = m_thousands[def];
   return chr;
 }
 
 void MyMoneyQifProfile::setAccountDelimiter(const QString& delim)
 {
   QString txt(delim);
 
   if (txt.isEmpty())
     txt = ' ';
   else if (txt[0] != '[')
     txt = '[';
 
   if (m_accountDelimiter[0] != txt[0])
     m_isDirty = true;
   m_accountDelimiter = txt[0];
 }
 
 void MyMoneyQifProfile::setOpeningBalanceText(const QString& txt)
 {
   if (m_openingBalanceText != txt)
     m_isDirty = true;
   m_openingBalanceText = txt;
 }
 
 void MyMoneyQifProfile::setVoidMark(const QString& txt)
 {
   if (m_voidMark != txt)
     m_isDirty = true;
   m_voidMark = txt;
 }
 
 const QString MyMoneyQifProfile::accountDelimiter() const
 {
   QString rc;
   if (m_accountDelimiter[0] == ' ')
     rc = ' ';
   else
     rc = "[]";
   return rc;
 }
 
 const QString MyMoneyQifProfile::date(const QDate& datein) const
 {
   QString::const_iterator format = m_dateFormat.begin();;
   QString buffer;
   QChar delim;
   int maskLen;
   QChar maskChar;
 
   while (format != m_dateFormat.end()) {
     if (*format == '%') {
       maskLen = 0;
       maskChar = *(++format);
       while ((format != m_dateFormat.end()) && (*format == maskChar)) {
         ++maskLen;
         ++format;
       }
 
       if (maskChar == 'd') {
         if (! delim.isNull())
           buffer += delim;
         buffer += QString::number(datein.day()).rightJustified(2, '0');
 
       } else if (maskChar == 'm') {
         if (! delim.isNull())
           buffer += delim;
         if (maskLen == 3)
           buffer += QLocale().monthName(datein.month(), QLocale::ShortFormat);
         else
           buffer += QString::number(datein.month()).rightJustified(2, '0');
       } else if (maskChar == 'y') {
         if (maskLen == 2) {
           buffer += twoDigitYear(delim, datein.year());
         } else {
           if (! delim.isNull())
             buffer += delim;
           buffer += QString::number(datein.year());
         }
         break;
       } else {
-        throw MYMONEYEXCEPTION("Invalid char in QifProfile date field");
+        throw MYMONEYEXCEPTION_CSTRING("Invalid char in QifProfile date field");
       }
       delim = 0;
     } else {
       if (! delim.isNull())
         buffer += delim;
       delim = *format++;
     }
   }
   return buffer;
 }
 
 const QDate MyMoneyQifProfile::date(const QString& datein) const
 {
   // in case we don't know the format, we return an invalid date
   if (d->m_partPos.count() != 3)
     return QDate();
 
   QVector<QString> scannedParts(3);
   d->dissectDate(scannedParts, datein);
 
   int yr, mon, day;
   bool ok;
   yr = scannedParts[d->m_partPos['y']].toInt();
   mon = scannedParts[d->m_partPos['m']].toInt(&ok);
   if (!ok) {
     QStringList monthNames = QString("jan,feb,mar,apr,may,jun,jul,aug,sep,oct,nov,dec").split(',');
     int j;
     for (j = 1; j <= 12; ++j) {
       if ((QLocale().monthName(j, QLocale::ShortFormat).toLower() == scannedParts[d->m_partPos['m']].toLower())
           || (monthNames[j-1] == scannedParts[d->m_partPos['m']].toLower())) {
         mon = j;
         break;
       }
     }
     if (j == 13) {
       qWarning("Unknown month '%s'", qPrintable(scannedParts[d->m_partPos['m']]));
       return QDate();
     }
   }
 
   day = scannedParts[d->m_partPos['d']].toInt();
   if (yr < 100) { // two digit year information?
     if (yr < CENTURY_BREAK)  // less than the CENTURY_BREAK we assume this century
       yr += 2000;
     else
       yr += 1900;
   }
   return QDate(yr, mon, day);
 
 #if 0
   QString scannedDelim[2];
   QString formatParts[3];
   QString formatDelim[2];
   int part;
   int delim;
   unsigned int i, j;
 
   part = -1;
   delim = 0;
   for (i = 0; i < m_dateFormat.length(); ++i) {
     if (m_dateFormat[i] == '%') {
       ++part;
       if (part == 3) {
         qWarning("MyMoneyQifProfile::date(const QString& datein) Too many parts in date format");
         return QDate();
       }
       ++i;
     }
     switch (m_dateFormat[i].toLatin1()) {
       case 'm':
       case 'd':
       case 'y':
         formatParts[part] += m_dateFormat[i];
         break;
       case '/':
       case '-':
       case '.':
       case '\'':
         if (delim == 2) {
           qWarning("MyMoneyQifProfile::date(const QString& datein) Too many delimiters in date format");
           return QDate();
         }
         formatDelim[delim] = m_dateFormat[i];
         ++delim;
         break;
       default:
         qWarning("MyMoneyQifProfile::date(const QString& datein) Invalid char in date format");
         return QDate();
     }
   }
 
 
   part = 0;
   delim = 0;
   bool prevWasChar = false;
   for (i = 0; i < datein.length(); ++i) {
     switch (datein[i].toLatin1()) {
       case '/':
       case '.':
       case '-':
       case '\'':
         if (delim == 2) {
           qWarning("MyMoneyQifProfile::date(const QString& datein) Too many delimiters in date field");
           return QDate();
         }
         scannedDelim[delim] = datein[i];
         ++delim;
         ++part;
         prevWasChar = false;
         break;
 
       default:
         if (prevWasChar && datein[i].isDigit()) {
           ++part;
           prevWasChar = false;
         }
         if (datein[i].isLetter())
           prevWasChar = true;
         // replace blank with 0
         scannedParts[part] += (datein[i] == ' ') ? QChar('0') : datein[i];
         break;
     }
   }
 
   int day = 1,
             mon = 1,
                   yr = 1900;
   bool ok = false;
   for (i = 0; i < 2; ++i) {
     if (scannedDelim[i] != formatDelim[i]
         && scannedDelim[i] != QChar('\'')) {
       qWarning("MyMoneyQifProfile::date(const QString& datein) Invalid delimiter '%s' when '%s' was expected",
                scannedDelim[i].toLatin1(), formatDelim[i].toLatin1());
       return QDate();
     }
   }
 
   QString msg;
   for (i = 0; i < 3; ++i) {
     switch (formatParts[i][0].toLatin1()) {
       case 'd':
         day = scannedParts[i].toUInt(&ok);
         if (!ok)
           msg = "Invalid numeric character in day string";
         break;
       case 'm':
         if (formatParts[i].length() != 3) {
           mon = scannedParts[i].toUInt(&ok);
           if (!ok)
             msg = "Invalid numeric character in month string";
         } else {
           for (j = 1; j <= 12; ++j) {
             if (QLocale().monthName(j, 2000, true).toLower() == formatParts[i].toLower()) {
               mon = j;
               ok = true;
               break;
             }
           }
           if (j == 13) {
             msg = "Unknown month '" + scannedParts[i] + "'";
           }
         }
         break;
       case 'y':
         ok = false;
         if (scannedParts[i].length() == formatParts[i].length()) {
           yr = scannedParts[i].toUInt(&ok);
           if (!ok)
             msg = "Invalid numeric character in month string";
           if (yr < 100) {     // two digit year info
             if (i > 1) {
               ok = true;
               if (scannedDelim[i-1] == QChar('\'')) {
                 if (m_apostropheFormat == "1900-1949") {
                   if (yr < 50)
                     yr += 1900;
                   else
                     yr += 2000;
                 } else if (m_apostropheFormat == "1900-1999") {
                   yr += 1900;
                 } else if (m_apostropheFormat == "2000-2099") {
                   yr += 2000;
                 } else {
                   msg = "Unsupported apostropheFormat!";
                   ok = false;
                 }
               } else {
                 if (m_apostropheFormat == "1900-1949") {
                   if (yr < 50)
                     yr += 2000;
                   else
                     yr += 1900;
                 } else if (m_apostropheFormat == "1900-1999") {
                   yr += 2000;
                 } else if (m_apostropheFormat == "2000-2099") {
                   yr += 1900;
                 } else {
                   msg = "Unsupported apostropheFormat!";
                   ok = false;
                 }
               }
             } else {
               msg = "Year as first parameter is not supported!";
             }
           } else if (yr < 1900) {
             msg = "Year not in range < 100 or >= 1900!";
           } else {
             ok = true;
           }
         } else {
           msg = QString("Length of year (%1) does not match expected length (%2).")
                 .arg(scannedParts[i].length()).arg(formatParts[i].length());
         }
         break;
     }
     if (!msg.isEmpty()) {
       qWarning("MyMoneyQifProfile::date(const QString& datein) %s", msg.toLatin1());
       return QDate();
     }
   }
   return QDate(yr, mon, day);
 #endif
 }
 
 const QString MyMoneyQifProfile::twoDigitYear(const QChar& delim, int yr) const
 {
   QChar realDelim = delim;
   QString buffer;
   if (!delim.isNull()) {
     if ((m_apostropheFormat == "1900-1949" && yr <= 1949)
         || (m_apostropheFormat == "1900-1999" && yr <= 1999)
         || (m_apostropheFormat == "2000-2099" && yr >= 2000))
       realDelim = '\'';
     buffer += realDelim;
   }
   yr -= 1900;
   if (yr > 100)
     yr -= 100;
 
   if (yr < 10)
     buffer += '0';
 
   buffer += QString::number(yr);
   return buffer;
 }
 
 const QString MyMoneyQifProfile::value(const QChar& def, const MyMoneyMoney& valuein) const
 {
   QChar _decimalSeparator;
   QChar _thousandsSeparator;
   QString res;
 
   _decimalSeparator = MyMoneyMoney::decimalSeparator();
   _thousandsSeparator = MyMoneyMoney::thousandSeparator();
   eMyMoney::Money::signPosition _signPosition = MyMoneyMoney::negativeMonetarySignPosition();
 
   MyMoneyMoney::setDecimalSeparator(amountDecimal(def).toLatin1());
   MyMoneyMoney::setThousandSeparator(amountThousands(def).toLatin1());
   MyMoneyMoney::setNegativeMonetarySignPosition(eMyMoney::Money::BeforeQuantityMoney);
   res = valuein.formatMoney("", 2);
 
   MyMoneyMoney::setDecimalSeparator(_decimalSeparator);
   MyMoneyMoney::setThousandSeparator(_thousandsSeparator);
   MyMoneyMoney::setNegativeMonetarySignPosition(_signPosition);
 
   return res;
 }
 
 const MyMoneyMoney MyMoneyQifProfile::value(const QChar& def, const QString& valuein) const
 {
   QChar _decimalSeparator;
   QChar _thousandsSeparator;
   MyMoneyMoney res;
 
   _decimalSeparator = MyMoneyMoney::decimalSeparator();
   _thousandsSeparator = MyMoneyMoney::thousandSeparator();
   eMyMoney::Money::signPosition _signPosition = MyMoneyMoney::negativeMonetarySignPosition();
 
   MyMoneyMoney::setDecimalSeparator(amountDecimal(def).toLatin1());
   MyMoneyMoney::setThousandSeparator(amountThousands(def).toLatin1());
   MyMoneyMoney::setNegativeMonetarySignPosition(eMyMoney::Money::BeforeQuantityMoney);
 
   res = MyMoneyMoney(valuein);
 
   MyMoneyMoney::setDecimalSeparator(_decimalSeparator);
   MyMoneyMoney::setThousandSeparator(_thousandsSeparator);
   MyMoneyMoney::setNegativeMonetarySignPosition(_signPosition);
 
   return res;
 }
 
 void MyMoneyQifProfile::setFilterScriptImport(const QString& script)
 {
   if (m_filterScriptImport != script)
     m_isDirty = true;
 
   m_filterScriptImport = script;
 }
 
 void MyMoneyQifProfile::setFilterScriptExport(const QString& script)
 {
   if (m_filterScriptExport != script)
     m_isDirty = true;
 
   m_filterScriptExport = script;
 }
 
 void MyMoneyQifProfile::setFilterFileType(const QString& txt)
 {
   if (m_filterFileType != txt)
     m_isDirty = true;
 
   m_filterFileType = txt;
 }
 
 void MyMoneyQifProfile::setAttemptMatchDuplicates(bool f)
 {
   if (m_attemptMatchDuplicates != f)
     m_isDirty = true;
 
   m_attemptMatchDuplicates = f;
 }
 
 const QString MyMoneyQifProfile::inputDateFormat() const
 {
   QStringList list;
   possibleDateFormats(list);
   if (list.count() == 1)
     return list.first();
   return QString();
 }
 
 void MyMoneyQifProfile::possibleDateFormats(QStringList& list) const
 {
   QStringList defaultList = QString("y,m,d:y,d,m:m,d,y:m,y,d:d,m,y:d,y,m").split(':');
   list.clear();
   QStringList::const_iterator it_d;
   for (it_d = defaultList.constBegin(); it_d != defaultList.constEnd(); ++it_d) {
     const QStringList parts = (*it_d).split(',', QString::SkipEmptyParts);
     int i;
     for (i = 0; i < 3; ++i) {
       if (d->m_partPos.contains(parts[i][0])) {
         if (d->m_partPos[parts[i][0]] != i)
           break;
       }
       // months can't be larger than 12
       if (parts[i] == "m" && d->m_largestValue[i] > 12)
         break;
       // days can't be larger than 31
       if (parts[i] == "d" && d->m_largestValue[i] > 31)
         break;
     }
     // matches all tests
     if (i == 3) {
       QString format = *it_d;
       format.replace('y', "%y");
       format.replace('m', "%m");
       format.replace('d', "%d");
       format.replace(',', " ");
       list << format;
     }
   }
   // if we haven't found any, then there's something wrong.
   // in this case, we present the full list and let the user decide
   if (list.count() == 0) {
     for (it_d = defaultList.constBegin(); it_d != defaultList.constEnd(); ++it_d) {
       QString format = *it_d;
       format.replace('y', "%y");
       format.replace('m', "%m");
       format.replace('d', "%d");
       format.replace(',', " ");
       list << format;
     }
   }
 }
 
 void MyMoneyQifProfile::autoDetect(const QStringList& lines)
 {
   m_dateFormat.clear();
   m_decimal.clear();
   m_thousands.clear();
 
   QString numericRecords = "BT$OIQ";
   QStringList::const_iterator it;
   int datesScanned = 0;
   // section: used to switch between different QIF sections,
   // because the Record identifiers are ambigous between sections
   // eg. in transaction records, T identifies a total amount, in
   // account sections it's the type.
   //
   // 0 - unknown
   // 1 - account
   // 2 - transactions
   // 3 - prices
   int section = 0;
   QRegExp price("\"(.*)\",(.*),\"(.*)\"");
   for (it = lines.begin(); it != lines.end(); ++it) {
     QChar c((*it)[0]);
     if (c == '!') {
       QString sname = (*it).toLower();
       if (!sname.startsWith(QLatin1String("!option:"))) {
         section = 0;
         if (sname.startsWith(QLatin1String("!account")))
           section = 1;
         else if (sname.startsWith(QLatin1String("!type"))) {
           if (sname.startsWith(QLatin1String("!type:cat"))
               || sname.startsWith(QLatin1String("!type:payee"))
               || sname.startsWith(QLatin1String("!type:security"))
               || sname.startsWith(QLatin1String("!type:class"))) {
             section = 0;
           } else if (sname.startsWith(QLatin1String("!type:price"))) {
             section = 3;
           } else
             section = 2;
         }
       }
     }
 
     switch (section) {
       case 1:
         if (c == 'B') {
           scanNumeric((*it).mid(1), m_decimal[c], m_thousands[c]);
         }
         break;
       case 2:
         if (numericRecords.contains(c)) {
           scanNumeric((*it).mid(1), m_decimal[c], m_thousands[c]);
         } else if ((c == 'D') && (m_dateFormat.isEmpty())) {
           if (d->m_partPos.count() != 3) {
             scanDate((*it).mid(1));
             ++datesScanned;
             if (d->m_partPos.count() == 2) {
               // if we have detected two parts we can calculate the third and its position
               d->getThirdPosition();
             }
           }
         }
         break;
       case 3:
         if (price.indexIn(*it) != -1) {
           scanNumeric(price.cap(2), m_decimal['P'], m_thousands['P']);
           scanDate(price.cap(3));
           ++datesScanned;
         }
         break;
     }
   }
 
   // the following algorithm is only applied if we have more
   // than 20 dates found. Smaller numbers have shown that the
   // results are inaccurate which leads to a reduced number of
   // date formats presented to choose from.
   if (d->m_partPos.count() != 3 && datesScanned > 20) {
     QMap<int, int> sortedPos;
     // make sure to reset the known parts for the following algorithm
     if (d->m_partPos.contains('y')) {
       d->m_changeCount[d->m_partPos['y']] = -1;
       for (int i = 0; i < 3; ++i) {
         if (d->m_partPos['y'] == i)
           continue;
         // can we say for sure that we hit the day field?
         if (d->m_largestValue[i] > 12) {
           d->m_partPos['d'] = i;
         }
       }
     }
     if (d->m_partPos.contains('d'))
       d->m_changeCount[d->m_partPos['d']] = -1;
     if (d->m_partPos.contains('m'))
       d->m_changeCount[d->m_partPos['m']] = -1;
 
     for (int i = 0; i < 3; ++i) {
       if (d->m_changeCount[i] != -1) {
         sortedPos[d->m_changeCount[i]] = i;
       }
     }
 
     QMap<int, int>::const_iterator it_a;
     QMap<int, int>::const_iterator it_b;
     switch (sortedPos.count()) {
       case 1: // all the same
         // let the user decide, we can't figure it out
         break;
 
       case 2: // two are the same, we treat the largest as the day
         // if it's 20% larger than the other one and let the
         // user pick the other two
         {
           it_b = sortedPos.constBegin();
           it_a = it_b;
           ++it_b;
           double a = d->m_changeCount[*it_a];
           double b = d->m_changeCount[*it_b];
           if (b > (a * 1.2)) {
             d->m_partPos['d'] = *it_b;
           }
         }
         break;
 
       case 3: // three different, we check if they are 20% apart each
         it_b = sortedPos.constBegin();
         for (int i = 0; i < 2; ++i) {
           it_a = it_b;
           ++it_b;
           double a = d->m_changeCount[*it_a];
           double b = d->m_changeCount[*it_b];
           if (b > (a * 1.2)) {
             switch (i) {
               case 0:
                 d->m_partPos['y'] = *it_a;
                 break;
               case 1:
                 d->m_partPos['d'] = *it_b;
                 break;
             }
           }
         }
         break;
     }
     // extract the last if necessary and possible date position
     d->getThirdPosition();
   }
 }
 
 void MyMoneyQifProfile::scanNumeric(const QString& txt, QChar& decimal, QChar& thousands) const
 {
   QChar first, second;
   QRegExp numericChars("[0-9-()]");
   for (int i = 0; i < txt.length(); ++i) {
     const QChar& c = txt[i];
     if (numericChars.indexIn(c) == -1) {
       if (c == '.' || c == ',') {
         first = second;
         second = c;
       }
     }
   }
   if (!second.isNull())
     decimal = second;
   if (!first.isNull())
     thousands = first;
 }
 
 void MyMoneyQifProfile::scanDate(const QString& txt) const
 {
   // extract the parts from the txt
   QVector<QString> parts(3);             // the various parts of the date
   d->dissectDate(parts, txt);
 
   // now analyze the parts
   for (int i = 0; i < 3; ++i) {
     bool ok;
     int value = parts[i].toInt(&ok);
     if (!ok) { // this should happen only if the part is non-numeric -> month
       d->m_partPos['m'] = i;
     } else if (value != 0) {
       if (value != d->m_lastValue[i]) {
         d->m_changeCount[i]++;
         d->m_lastValue[i] = value;
         if (value > d->m_largestValue[i])
           d->m_largestValue[i] = value;
       }
       // if it's > 31 it can only be years
       if (value > 31) {
         d->m_partPos['y'] = i;
       }
       // and if it's in between 12 and 32 and we already identified the
       // position for the year it must be days
       if ((value > 12) && (value < 32) && d->m_partPos.contains('y')) {
         d->m_partPos['d'] = i;
       }
     }
   }
 }
diff --git a/kmymoney/plugins/qif/export/mymoneyqifwriter.cpp b/kmymoney/plugins/qif/export/mymoneyqifwriter.cpp
index 781c53c02..f4aaefc29 100644
--- a/kmymoney/plugins/qif/export/mymoneyqifwriter.cpp
+++ b/kmymoney/plugins/qif/export/mymoneyqifwriter.cpp
@@ -1,471 +1,468 @@
 /***************************************************************************
                           mymoneyqifwriter.cpp  -  description
                              -------------------
     begin                : Sun Jan 5 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>
                            Allan Anderson agander93@gmail.com
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneyqifwriter.h"
 
 // ----------------------------------------------------------------------------
 // QT Headers
 
 #include <QFile>
 #include <QList>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <kmessagebox.h>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Headers
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneysplit.h"
 #include "mymoneymoney.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 MyMoneyQifWriter::MyMoneyQifWriter()
 {
 }
 
 MyMoneyQifWriter::~MyMoneyQifWriter()
 {
 }
 
 void MyMoneyQifWriter::write(const QString& filename, const QString& profile,
                              const QString& accountId, const bool accountData,
                              const bool categoryData,
                              const QDate& startDate, const QDate& endDate)
 {
   m_qifProfile.loadProfile("Profile-" + profile);
 
   QFile qifFile(filename);
   if (qifFile.open(QIODevice::WriteOnly)) {
     QTextStream s(&qifFile);
     s.setCodec("UTF-8");
 
     try {
       if (categoryData) {
         writeCategoryEntries(s);
       }
 
       if (accountData) {
         writeAccountEntry(s, accountId, startDate, endDate);
       }
       emit signalProgress(-1, -1);
 
     } catch (const MyMoneyException &e) {
-      QString errMsg = i18n("Unexpected exception '%1' thrown in %2, line %3 "
-                            "caught in MyMoneyQifWriter::write()", e.what(), e.file(), e.line());
-
-      KMessageBox::error(0, errMsg);
+      KMessageBox::error(nullptr, i18n("Unexpected exception '%1'", QString::fromLatin1(e.what())));
     }
 
     qifFile.close();
     qDebug() << "Export completed.\n";
   } else {
     KMessageBox::error(0, i18n("Unable to open file '%1' for writing", filename));
   }
 }
 
 void MyMoneyQifWriter::writeAccountEntry(QTextStream& s, const QString& accountId, const QDate& startDate, const QDate& endDate)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount account;
 
   account = file->account(accountId);
   MyMoneyTransactionFilter filter(accountId);
 
   QString openingBalanceTransactionId;
   QString type = m_qifProfile.profileType();
 
   s << "!Type:" << type << endl;
   if (type == "Invst") {
     extractInvestmentEntries(s, accountId, startDate, endDate);
   } else {
     filter.setDateFilter(startDate, endDate);
     QList<MyMoneyTransaction> list = file->transactionList(filter);
     if (!startDate.isValid() || startDate <= account.openingDate()) {
       s << "D" << m_qifProfile.date(account.openingDate()) << endl;
       openingBalanceTransactionId = file->openingBalanceTransaction(account);
       MyMoneySplit split;
       if (!openingBalanceTransactionId.isEmpty()) {
         MyMoneyTransaction openingBalanceTransaction = file->transaction(openingBalanceTransactionId);
         split = openingBalanceTransaction.splitByAccount(account.id(), true /* match */);
       }
       s << "T" << m_qifProfile.value('T', split.value()) << endl;
     } else {
       s << "D" << m_qifProfile.date(startDate) << endl;
       s << "T" << m_qifProfile.value('T', file->balance(accountId, startDate.addDays(-1))) << endl;
     }
     s << "CX" << endl;
     s << "P" << m_qifProfile.openingBalanceText() << endl;
     s << "L";
     if (m_qifProfile.accountDelimiter().length())
       s << m_qifProfile.accountDelimiter()[0];
     s << account.name();
     if (m_qifProfile.accountDelimiter().length() > 1)
       s << m_qifProfile.accountDelimiter()[1];
     s << endl;
     s << "^" << endl;
 
     QList<MyMoneyTransaction>::ConstIterator it;
     signalProgress(0, list.count());
     int count = 0;
     for (it = list.constBegin(); it != list.constEnd(); ++it) {
       // don't include the openingBalanceTransaction again
       if ((*it).id() != openingBalanceTransactionId)
         writeTransactionEntry(s, *it, accountId);
       signalProgress(++count, 0);
     }
   }
 }
 
 void MyMoneyQifWriter::writeCategoryEntries(QTextStream &s)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount income;
   MyMoneyAccount expense;
 
   income = file->income();
   expense = file->expense();
 
   s << "!Type:Cat" << endl;
   QStringList list = income.accountList() + expense.accountList();
   emit signalProgress(0, list.count());
   QStringList::Iterator it;
   int count = 0;
   for (it = list.begin(); it != list.end(); ++it) {
     writeCategoryEntry(s, *it, "");
     emit signalProgress(++count, 0);
   }
 }
 
 void MyMoneyQifWriter::writeCategoryEntry(QTextStream &s, const QString& accountId, const QString& leadIn)
 {
   MyMoneyAccount acc = MyMoneyFile::instance()->account(accountId);
   QString name = acc.name();
 
   s << "N" << leadIn << name << endl;
   s << (acc.accountGroup() == eMyMoney::Account::Type::Expense ? "E" : "I") << endl;
   s << "^" << endl;
 
   QStringList list = acc.accountList();
   QStringList::Iterator it;
   name += ':';
   for (it = list.begin(); it != list.end(); ++it) {
     writeCategoryEntry(s, *it, name);
   }
 }
 
 void MyMoneyQifWriter::writeTransactionEntry(QTextStream &s, const MyMoneyTransaction& t, const QString& accountId)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneySplit split = t.splitByAccount(accountId);
 
   s << "D" << m_qifProfile.date(t.postDate()) << endl;
 
   switch (split.reconcileFlag()) {
     case eMyMoney::Split::State::Cleared:
       s << "C*" << endl;
       break;
 
     case eMyMoney::Split::State::Reconciled:
     case eMyMoney::Split::State::Frozen:
       s << "CX" << endl;
       break;
 
     default:
       break;
   }
 
   if (split.memo().length() > 0) {
     QString m = split.memo();
     m.replace('\n', "\\n");
     s << "M" << m << endl;
   }
 
   s << "T" << m_qifProfile.value('T', split.value()) << endl;
 
   if (split.number().length() > 0)
     s << "N" << split.number() << endl;
 
   if (!split.payeeId().isEmpty()) {
     MyMoneyPayee payee = file->payee(split.payeeId());
     s << "P" << payee.name() << endl;
   }
 
   QList<MyMoneySplit> list = t.splits();
   if (list.count() > 1) {
     MyMoneySplit sp = t.splitByAccount(accountId, false);
     MyMoneyAccount acc = file->account(sp.accountId());
     if (acc.accountGroup() != eMyMoney::Account::Type::Income
         && acc.accountGroup() != eMyMoney::Account::Type::Expense) {
       s << "L" << m_qifProfile.accountDelimiter()[0]
       << MyMoneyFile::instance()->accountToCategory(sp.accountId())
       << m_qifProfile.accountDelimiter()[1] << endl;
     } else {
       s << "L" << file->accountToCategory(sp.accountId()) << endl;
     }
     if (list.count() > 2) {
       QList<MyMoneySplit>::ConstIterator it;
       for (it = list.constBegin(); it != list.constEnd(); ++it) {
         if (!((*it) == split)) {
           writeSplitEntry(s, *it);
         }
       }
     }
   }
   s << "^" << endl;
 }
 
 void MyMoneyQifWriter::writeSplitEntry(QTextStream& s, const MyMoneySplit& split)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   s << "S";
   MyMoneyAccount acc = file->account(split.accountId());
   if (acc.accountGroup() != eMyMoney::Account::Type::Income
       && acc.accountGroup() != eMyMoney::Account::Type::Expense) {
     s << m_qifProfile.accountDelimiter()[0]
     << file->accountToCategory(split.accountId())
     << m_qifProfile.accountDelimiter()[1];
   } else {
     s << file->accountToCategory(split.accountId());
   }
   s << endl;
 
   if (split.memo().length() > 0) {
     QString m = split.memo();
     m.replace('\n', "\\n");
     s << "E" << m << endl;
   }
 
   s << "$" << m_qifProfile.value('$', -split.value()) << endl;
 }
 
 void MyMoneyQifWriter::extractInvestmentEntries(QTextStream &s, const QString& accountId, const QDate& startDate, const QDate& endDate)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<QString> accList = file->account(accountId).accountList();
   QList<QString>::ConstIterator itAcc;
   for (itAcc = accList.constBegin(); itAcc != accList.constEnd(); ++itAcc) {
     MyMoneyTransactionFilter filter((*itAcc));
     filter.setDateFilter(startDate, endDate);
     QList<MyMoneyTransaction> list = file->transactionList(filter);
     QList<MyMoneyTransaction>::ConstIterator it;
     signalProgress(0, list.count());
     int count = 0;
     for (it = list.constBegin(); it != list.constEnd(); ++it) {
       writeInvestmentEntry(s, *it, ++count);
       signalProgress(count, 0);
     }
   }
 }
 
 void MyMoneyQifWriter::writeInvestmentEntry(QTextStream& stream, const MyMoneyTransaction& t, const int count)
 {
   QString s;
   QString memo;
   MyMoneyFile* file = MyMoneyFile::instance();
   QString chkAccnt;
   bool isXfer = false;
   bool noError = true;
   QList<MyMoneySplit> lst = t.splits();
   QList<MyMoneySplit>::Iterator it;
   eMyMoney::Account::Type typ;
   QString chkAccntId;
   MyMoneyMoney qty;
   MyMoneyMoney value;
   QMap<eMyMoney::Account::Type, QString> map;
 
   for (int i = 0; i < lst.count(); i++) {
     QString actionType = lst[i].action();
     MyMoneyAccount acc = file->account(lst[i].accountId());
     QString accName = acc.name();
     typ = acc.accountType();
     map.insert(typ, lst[i].accountId());
     if (typ == eMyMoney::Account::Type::Stock) {
       memo = lst[i].memo();
     }
   }
   //
   //  Add date.
   //
   if (noError) {
     s += 'D' + m_qifProfile.date(t.postDate()) + '\n';
   }
   for (it = lst.begin(); it != lst.end(); ++it) {
     QString accName;
     QString actionType = (*it).action();
     MyMoneyAccount acc = file->account((*it).accountId());
     typ = acc.accountType();
     //
     //  eMyMoney::Account::Type::Checkings.
     //
     if ((acc.accountType() == eMyMoney::Account::Type::Checkings) || (acc.accountType() == eMyMoney::Account::Type::Cash)) {
       chkAccntId = (*it).accountId();
       chkAccnt = file->account(chkAccntId).name();
     } else if (acc.accountType() == eMyMoney::Account::Type::Income) {
       //
       //  eMyMoney::Account::Type::Income.
       //
     } else if (acc.accountType() == eMyMoney::Account::Type::Expense) {
       //
       //  eMyMoney::Account::Type::Expense.
       //
     } else if (acc.accountType() == eMyMoney::Account::Type::Stock) {
       //
       //  eMyMoney::Account::Type::Stock.
       //
       qty = (*it).shares();
       value = (*it).value();
 
       accName = acc.name();
       if ((actionType == "Dividend") || (actionType == "Buy") || (actionType == "IntIncome")) {
         isXfer = true;
       }
       //
       //  Actions.
       //
       QString action;
       if ((*it).action() == "Dividend") {
         action = "DivX";
       } else if ((*it).action() == "IntIncome") {
         action = "IntIncX";
       }
       if ((action == "DivX") || (action == "IntIncX")) {
         if (map.value(eMyMoney::Account::Type::Checkings).isEmpty()) {
           KMessageBox::sorry(0,
                              QString("<qt>%1</qt>").arg(i18n("Transaction number <b>%1</b> is missing an account assignment.\nTransaction dropped.", count)),
                              i18n("Invalid transaction"));
           noError = false;
           return;
         }
         MyMoneySplit sp = t.splitByAccount(map.value(eMyMoney::Account::Type::Checkings), true);
         QString txt = sp.value().formatMoney("", 2);
         if (noError) {
           s += 'T' + txt + '\n';
         }
       } else if ((*it).action() == "Buy") {
 
         if (qty.isNegative()) {
           action = "Sell";
         } else {
           action = "Buy";
         }
       } else if ((*it).action() == "Add") {
         qty = (*it).shares();
         if (qty.isNegative()) {
           action = "Shrsout";
         } else {
           action = "Shrsin";
         }
       } else if ((*it).action() == "Reinvest") {
         action = "ReinvDiv";
       } else {
         action = (*it).action();
       }
 
       //
       //  Add action.
       //
       if (noError) {
         s += 'N' + action + '\n';
       }
       QString txt;
       if ((action == "Buy") || (action == "Sell") || (action == "ReinvDiv")) {
         //
         //  Add total.
         //
         txt = value.formatMoney("", 2);
         if (action == "Sell") {
           value = -value;
           txt = value.formatMoney("", 2);
         }
         if (noError) {
           s += 'T' + txt + '\n';
         }
         //
         //  Add price.
         //
         txt = (*it).price().formatMoney("", 6);
         if (noError) {
           s += 'I' + txt + '\n';
         }
         if (!qty.isZero()) {
           //
           //  Add quantity.
           //
           if (noError) {
             if (action == "Sell") {
               qty = -qty;
             }
             s += 'Q' + m_qifProfile.value('Q', qty) + '\n';
           }
         }
       } else if ((action == "Shrsin") || (action == "Shrsout")) {
         //
         //  Add quantity for "Shrsin" || "Shrsout".
         //
         if (noError) {
           if (action == "Shrsout") {
             qty = -qty;
           }
           s += 'Q' + m_qifProfile.value('Q', qty) + '\n';
         }
       }
     }
     if (!accName.isEmpty()) {
       if (noError) {
         s += 'Y' + accName + '\n';
       }
     }
   }
   if (!memo.isEmpty()) {
     if (noError) {
       memo.replace('\n', "\\n");
       s += 'M' + memo + '\n';
     }
   }
   if ((!chkAccnt.isEmpty()) && isXfer) {
     //
     //  Add account - including its hierarchy.
     //
     if (noError) {
       s += 'L' + m_qifProfile.accountDelimiter()[0] + file->accountToCategory(chkAccntId)
            + m_qifProfile.accountDelimiter()[1] + '\n';
       stream << s;
     } else {
       // Don't output the transaction
     }
   } else {
     stream << s;
   }
   stream << '^' << '\n';
 }
diff --git a/kmymoney/plugins/qif/import/mymoneyqifreader.cpp b/kmymoney/plugins/qif/import/mymoneyqifreader.cpp
index e9f852678..8d02087c8 100644
--- a/kmymoney/plugins/qif/import/mymoneyqifreader.cpp
+++ b/kmymoney/plugins/qif/import/mymoneyqifreader.cpp
@@ -1,2083 +1,2083 @@
 /***************************************************************************
                           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 "mymoneyqifreader.h"
 
 // ----------------------------------------------------------------------------
 // QT Headers
 
 #include <QFile>
 #include <QStringList>
 #include <QTimer>
 #include <QRegExp>
 #include <QBuffer>
 #include <QByteArray>
 #include <QInputDialog>
 #include <QDir>
 
 // ----------------------------------------------------------------------------
 // KDE Headers
 
 #include <kmessagebox.h>
 #include <kconfig.h>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KLocalizedString>
 #include "kjobwidgets.h"
 #include "kio/job.h"
 
 // ----------------------------------------------------------------------------
 // Project Headers
 
 #include "mymoneyfile.h"
 #include "mymoneysecurity.h"
 #include "mymoneysplit.h"
 #include "mymoneyexception.h"
 #include "kmymoneysettings.h"
 
 #include "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
 #ifdef __GNUC__
 #warning "DEBUG_IMPORT defined --> external filter not available!!!!!!!"
 #endif
 #endif
 
 class MyMoneyQifReader::Private
 {
 public:
   Private() :
       accountType(eMyMoney::Account::Type::Checkings),
       firstTransaction(true),
       mapCategories(true),
       transactionType(MyMoneyQifReader::QifEntryTypeE::EntryUnknown)
   {}
 
   const QString accountTypeToQif(eMyMoney::Account::Type type) const;
 
   /**
    * finalize the current statement and add it to the statement list
    */
   void finishStatement();
 
   bool isTransfer(QString& name, const QString& leftDelim, const QString& rightDelim);
 
   /**
    * Converts the QIF specific N-record of investment transactions into
    * a category name
    */
   const QString typeToAccountName(const QString& type) const;
 
   /**
    * Converts the QIF reconcile state to the KMyMoney reconcile state
    */
   eMyMoney::Split::State 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
    */
   QList<MyMoneyStatement> statements;
 
   /**
    * a list of already used hashes in this file
    */
   QMap<QString, bool> m_hashMap;
 
   QString st_AccountName;
   QString st_AccountId;
   eMyMoney::Account::Type accountType;
   bool     firstTransaction;
   bool     mapCategories;
   MyMoneyQifReader::QifEntryTypeE  transactionType;
 };
 
 void MyMoneyQifReader::Private::fixMultiLineMemo(QString& memo) const
 {
   memo.replace("\\n", "\n");
 }
 
 void MyMoneyQifReader::Private::finishStatement()
 {
   // 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());
   }
   eMyMoney::Statement::Type type = st.m_eType; //stash type and...
   // start with a fresh statement
   st = MyMoneyStatement();
   st.m_skipCategoryMatching = !mapCategories;
   st.m_eType = type;
 }
 
 const QString MyMoneyQifReader::Private::accountTypeToQif(eMyMoney::Account::Type type) const
 {
   QString rc = "Bank";
 
   switch (type) {
     default:
       break;
     case eMyMoney::Account::Type::Cash:
       rc = "Cash";
       break;
     case eMyMoney::Account::Type::CreditCard:
       rc = "CCard";
       break;
     case eMyMoney::Account::Type::Asset:
       rc = "Oth A";
       break;
     case eMyMoney::Account::Type::Liability:
       rc = "Oth L";
       break;
     case eMyMoney::Account::Type::Investment:
       rc = "Port";
       break;
   }
   return rc;
 }
 
 const QString MyMoneyQifReader::Private::typeToAccountName(const QString& type) const
 {
   if (type == "reinvint")
     return i18nc("Category name", "Reinvested interest");
 
   if (type == "reinvdiv")
     return i18nc("Category name", "Reinvested dividend");
 
   if (type == "reinvlg")
     return i18nc("Category name", "Reinvested dividend (long term)");
 
   if (type == "reinvsh")
     return i18nc("Category name", "Reinvested dividend (short term)");
 
   if (type == "div")
     return i18nc("Category name", "Dividend");
 
   if (type == "intinc")
     return i18nc("Category name", "Interest");
 
   if (type == "cgshort")
     return i18nc("Category name", "Capital Gain (short term)");
 
   if (type == "cgmid")
     return i18nc("Category name", "Capital Gain (mid term)");
 
   if (type == "cglong")
     return i18nc("Category name", "Capital Gain (long term)");
 
   if (type == "rtrncap")
     return i18nc("Category name", "Returned capital");
 
   if (type == "miscinc")
     return i18nc("Category name", "Miscellaneous income");
 
   if (type == "miscexp")
     return i18nc("Category name", "Miscellaneous expense");
 
   if (type == "sell" || type == "buy")
     return i18nc("Category name", "Investment fees");
 
   return i18n("Unknown QIF type %1", 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          (The '/' is the Quicken class symbol)
   //
   // 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.indexIn(tmp) != -1)) == true) {
     tmp = exp.cap(1) + exp.cap(2);
     tmp = tmp.trimmed();
   }
   return rc;
 }
 
 eMyMoney::Split::State MyMoneyQifReader::Private::reconcileState(const QString& state) const
 {
   if (state == "X" || state == "R")       // Reconciled
     return eMyMoney::Split::State::Reconciled;
 
   if (state == "*")                     // Cleared
     return eMyMoney::Split::State::Cleared;
 
   return eMyMoney::Split::State::NotReconciled;
 }
 
 
 MyMoneyQifReader::MyMoneyQifReader() :
     d(new Private),
     m_file(nullptr),
     m_extractedLine(0),
     m_autoCreatePayee(true),
     m_pos(0),
     m_linenumber(0),
     m_ft(nullptr)
 {
   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(bytesWritten(qint64)), this, SLOT(slotSendDataToFilter()));
   connect(&m_filter, SIGNAL(readyReadStandardOutput()), this, SLOT(slotReceivedDataFromFilter()));
   connect(&m_filter, SIGNAL(finished(int,QProcess::ExitStatus)), this, SLOT(slotImportFinished()));
   connect(&m_filter, SIGNAL(readyReadStandardError()), this, SLOT(slotReceivedErrorFromFilter()));
 }
 
 MyMoneyQifReader::~MyMoneyQifReader()
 {
   delete m_file;
   delete d;
 }
 
 void MyMoneyQifReader::setCategoryMapping(bool map)
 {
   d->mapCategories = map;
 }
 
 void MyMoneyQifReader::setURL(const QUrl &url)
 {
   m_url = url;
 }
 
 void MyMoneyQifReader::setProfile(const QString& profile)
 {
   m_qifProfile.loadProfile("Profile-" + profile);
 }
 
 void MyMoneyQifReader::slotSendDataToFilter()
 {
   long len;
 
   if (m_file->atEnd()) {
     m_filter.closeWriteChannel();
   } else {
     len = m_file->read(m_buffer, sizeof(m_buffer));
     if (len == -1) {
       qWarning("Failed to read block from QIF import file");
       m_filter.closeWriteChannel();
       m_filter.kill();
     } else {
       m_filter.write(m_buffer, len);
     }
   }
 }
 
 void MyMoneyQifReader::slotReceivedErrorFromFilter()
 {
   qWarning("%s", qPrintable(QString(m_filter.readAllStandardError())));
 }
 
 void MyMoneyQifReader::slotReceivedDataFromFilter()
 {
   parseReceivedData(m_filter.readAllStandardOutput());
 }
 
 void MyMoneyQifReader::parseReceivedData(const QByteArray& data)
 {
   const char* buff = data.data();
   int len = data.length();
 
   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.trimmed());
       }
       m_lineBuffer = QByteArray();
     } else {
       // collect all others
       m_lineBuffer += (*buff);
     }
     ++buff;
     --len;
   }
 }
 
 void MyMoneyQifReader::slotImportFinished()
 {
   // check if the last EOL char was missing and add the trailing line
   if (!m_lineBuffer.isEmpty()) {
     m_qifLines << QString::fromUtf8(m_lineBuffer.trimmed());
   }
   qDebug("Read %ld bytes", m_pos);
   QTimer::singleShot(0, this, SLOT(slotProcessData()));
 }
 
 void MyMoneyQifReader::slotProcessData()
 {
   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);
   QString format;
   if (dateFormats.count() > 1) {
     bool ok;
     format = QInputDialog::getItem(0, i18n("Date format selection"), i18n("Pick the date format that suits your input file"), dateFormats, 05, false, &ok);
     if (!ok) {
       m_userAbort = true;
     }
   } else
     format = dateFormats.first();
 
   if (!format.isEmpty()) {
     m_qifProfile.setInputDateFormat(format);
     qDebug("Selected date format: '%s'", qPrintable(format));
   } else {
     // cancel the process because there is probably nothing to work with
     m_userAbort = true;
   }
 
   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 statementsReady(d->statements);
 }
 
 bool MyMoneyQifReader::startImport()
 {
   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.clear();
   m_data.clear();
 
   if (m_url.isEmpty()) {
     return rc;
   } else if (m_url.isLocalFile()) {
     m_filename = m_url.toLocalFile();
   } else {
     m_filename = QDir::tempPath();
     if(!m_filename.endsWith(QDir::separator()))
       m_filename += QDir::separator();
     m_filename += m_url.fileName();
     qDebug() << "Source:" << m_url.toDisplayString() << "Destination:" << m_filename;
     KIO::FileCopyJob *job = KIO::file_copy(m_url, QUrl::fromUserInput(m_filename), -1, KIO::Overwrite);
 //    KJobWidgets::setWindow(job, kmymoney);
     if (job->exec() && job->error()) {
       KMessageBox::detailedError(0, i18n("Error while loading file '%1'.", m_url.toDisplayString()),
                                  job->errorString(),
                                  i18n("File access error"));
       return rc;
     }
   }
 
   m_file = new QFile(m_filename);
   if (m_file->open(QIODevice::ReadOnly)) {
 
 #ifdef DEBUG_IMPORT
     qint64 len;
 
     while (!m_file->atEnd()) {
       len = m_file->read(m_buffer, sizeof(m_buffer));
       if (len == -1) {
         qWarning("Failed to read block from QIF import file");
       } else {
         parseReceivedData(QByteArray(m_buffer, len));
       }
     }
     QTimer::singleShot(0, this, SLOT(slotImportFinished()));
     rc = true;
 #else
     QString program;
     QStringList arguments;
     program.clear();
     arguments.clear();
     // start filter process, use 'cat -' as the default filter
     if (m_qifProfile.filterScriptImport().isEmpty()) {
 #ifdef Q_OS_WIN32                   //krazy:exclude=cpp
     // this is the Windows equivalent of 'cat -' but since 'type' does not work with stdin
     // we pass the filename converted to native separators as a parameter
     program = "cmd.exe";
     arguments << "/c";
     arguments << "type";
     arguments << QDir::toNativeSeparators(m_filename);
 #else
     program = "cat";
     arguments << "-";
 #endif
     } else {
       arguments << m_qifProfile.filterScriptImport().split(' ', QString::KeepEmptyParts);
       program = arguments.takeFirst();
     }
     m_entryType = EntryUnknown;
 
     m_filter.setProcessChannelMode(QProcess::MergedChannels);
     m_filter.start(program, arguments);
     if (m_filter.waitForStarted()) {
       signalProgress(0, m_file->size(), i18n("Reading QIF..."));
       slotSendDataToFilter();
       rc = true;
 //      emit statementsReady(d->statements);
     } else {
       KMessageBox::detailedError(0, i18n("Error while running the filter '%1'.", m_filter.program()),
                                  m_filter.errorString(),
                                  i18n("Filter error"));
     }
 #endif
   }
   return rc;
 }
 
 void MyMoneyQifReader::processQifSpecial(const QString& _line)
 {
   QString line = _line.mid(1);   // get rid of exclamation mark
   if (line.left(5).toLower() == QString("type:")) {
     line = line.mid(5);
 
     // exportable accounts
     if (line.toLower() == "ccard" || KMyMoneySettings::qifCreditCard().toLower().contains(line.toLower())) {
       d->accountType = eMyMoney::Account::Type::CreditCard;
       d->firstTransaction = true;
       d->transactionType = m_entryType = EntryTransaction;
 
     } else if (line.toLower() == "bank" || KMyMoneySettings::qifBank().toLower().contains(line.toLower())) {
       d->accountType = eMyMoney::Account::Type::Checkings;
       d->firstTransaction = true;
       d->transactionType = m_entryType = EntryTransaction;
 
     } else if (line.toLower() == "cash" || KMyMoneySettings::qifCash().toLower().contains(line.toLower())) {
       d->accountType = eMyMoney::Account::Type::Cash;
       d->firstTransaction = true;
       d->transactionType = m_entryType = EntryTransaction;
 
     } else if (line.toLower() == "oth a" || KMyMoneySettings::qifAsset().toLower().contains(line.toLower())) {
       d->accountType = eMyMoney::Account::Type::Asset;
       d->firstTransaction = true;
       d->transactionType = m_entryType = EntryTransaction;
 
     } else if (line.toLower() == "oth l" || line.toLower() == i18nc("QIF tag for liability account", "Oth L").toLower()) {
       d->accountType = eMyMoney::Account::Type::Liability;
       d->firstTransaction = true;
       d->transactionType = m_entryType = EntryTransaction;
 
     } else if (line.toLower() == "invst" || line.toLower() == i18nc("QIF tag for investment account", "Invst").toLower()) {
       d->accountType = eMyMoney::Account::Type::Investment;
       d->transactionType = m_entryType = EntryInvestmentTransaction;
 
     } else if (line.toLower() == "invoice" || KMyMoneySettings::qifInvoice().toLower().contains(line.toLower())) {
       m_entryType = EntrySkip;
 
     } else if (line.toLower() == "tax") {
       m_entryType = EntrySkip;
 
     } else if (line.toLower() == "bill") {
       m_entryType = EntrySkip;
 
       // exportable lists
     } else if (line.toLower() == "cat" || line.toLower() == i18nc("QIF tag for category", "Cat").toLower()) {
       m_entryType = EntryCategory;
 
     } else if (line.toLower() == "security" || line.toLower() == i18nc("QIF tag for security", "Security").toLower()) {
       m_entryType = EntrySecurity;
 
     } else if (line.toLower() == "prices" || line.toLower() == i18nc("QIF tag for prices", "Prices").toLower()) {
       m_entryType = EntryPrice;
 
     } else if (line.toLower() == "payee") {
       m_entryType = EntryPayee;
 
     } else if (line.toLower() == "memorized") {
       m_entryType = EntryMemorizedTransaction;
 
     } else if (line.toLower() == "class" || line.toLower() == i18nc("QIF tag for a class", "Class").toLower()) {
       m_entryType = EntryClass;
 
     } else if (line.toLower() == "budget") {
       m_entryType = EntrySkip;
 
     } else if (line.toLower() == "invitem") {
       m_entryType = EntrySkip;
 
     } else if (line.toLower() == "template") {
       m_entryType = EntrySkip;
 
     } else {
       qWarning("Unknown type code '%s' in QIF file on line %d", qPrintable(line), m_linenumber);
       m_entryType = EntrySkip;
     }
 
     // option headers
   } else if (line.toLower() == "account") {
     m_entryType = EntryAccount;
 
   } else if (line.toLower() == "option:autoswitch") {
     m_entryType = EntryAccount;
 
   } else if (line.toLower() == "clear:autoswitch") {
     m_entryType = d->transactionType;
   }
 }
 
 void MyMoneyQifReader::processQifEntry()
 {
   // This method processes a 'QIF Entry' which is everything between two caret
   // signs
   //
   try {
     switch (m_entryType) {
       case EntryCategory:
         processCategoryEntry();
         break;
 
       case EntryUnknown:
         qDebug() << "Line " << m_linenumber << ": Warning: Found an entry without a type being specified. Checking assumed.";
         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:
         qDebug() << "Line " << m_linenumber << ": Classes are not yet supported!";
         break;
 
       case EntryMemorizedTransaction:
         qDebug() << "Line " << m_linenumber << ": Memorized transactions are not yet implemented!";
         break;
 
       case EntrySkip:
         break;
 
       default:
         qDebug() << "Line " << m_linenumber << ": EntryType " << m_entryType << " not yet implemented!";
         break;
     }
   } catch (const MyMoneyException &e) {
-    if (e.what() != "USERABORT") {
+    if (QString::fromLatin1(e.what()).contains("USERABORT")) {
       qDebug() << "Line " << m_linenumber << ": Unhandled error: " << e.what();
     } else {
       m_userAbort = true;
     }
   }
 }
 
 const QString MyMoneyQifReader::extractLine(const QChar& id, int cnt)
 {
   QStringList::ConstIterator it;
 
   m_extractedLine = -1;
   for (it = m_qifEntry.constBegin(); it != m_qifEntry.constEnd(); ++it) {
     ++m_extractedLine;
     if ((*it)[0] == id) {
       if (cnt-- == 1) {
         return (*it).mid(1);
       }
     }
   }
   m_extractedLine = -1;
   return QString();
 }
 
 bool MyMoneyQifReader::extractSplits(QList<qSplit>& listqSplits) const
 {
 //     *** With apologies to QString MyMoneyQifReader::extractLine ***
 
   QStringList::ConstIterator it;
   bool ret = false;
   bool memoPresent = false;
   int neededCount = 0;
   qSplit q;
 
   for (it = m_qifEntry.constBegin(); it != m_qifEntry.constEnd(); ++it) {
     if (((*it)[0] == 'S') || ((*it)[0] == '$') || ((*it)[0] == 'E')) {
       memoPresent = false;  //                      in case no memo line in this split
       if ((*it)[0] == 'E') {
         q.m_strMemo = (*it).mid(1);  //             'E' = Memo
         d->fixMultiLineMemo(q.m_strMemo);
         memoPresent = true;  //                     This transaction contains memo
       } else if ((*it)[0] == 'S') {
         q.m_strCategoryName = (*it).mid(1);  //   'S' = CategoryName
         neededCount ++;
       } else if ((*it)[0] == '$') {
         q.m_amount = (*it).mid(1);  //            '$' = Amount
         neededCount ++;
       }
       if (neededCount > 1) {  //                         CategoryName & Amount essential
         listqSplits += q;  //                       Add valid split
         if (!memoPresent) {  //                     If no memo, clear previous
           q.m_strMemo.clear();
         }
         q = qSplit();  //                               Start new split
         neededCount = 0;
         ret = true;
       }
     }
   }
   return ret;
 }
 
 #if 0
 void MyMoneyQifReader::processMSAccountEntry(const eMyMoney::Account::Type accountType)
 {
   if (extractLine('P').toLower() == m_qifProfile.openingBalanceText().toLower()) {
     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(
                 KMyMoneyUtils::mainWindow(),
                 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?", m_account.name(), split.shares().formatMoney(m_account, sec), balance.formatMoney(m_account, sec)),
                 i18n("Overwrite opening balance"),
                 KStandardGuiItem::yes(),
                 KStandardGuiItem::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()
 {
   // TODO
 }
 
 void MyMoneyQifReader::processCategoryEntry()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount account = MyMoneyAccount();
   account.setName(extractLine('N'));
   account.setDescription(extractLine('D'));
 
   MyMoneyAccount parentAccount;
   //The extractline routine will more than likely return 'empty',
   // so also have to test that either the 'I' or 'E' was detected
   //and set up accounts accordingly.
   if ((!extractLine('I').isEmpty()) || (m_extractedLine != -1)) {
     account.setAccountType(eMyMoney::Account::Type::Income);
     parentAccount = file->income();
   } else if ((!extractLine('E').isEmpty()) || (m_extractedLine != -1)) {
     account.setAccountType(eMyMoney::Account::Type::Expense);
     parentAccount = file->expense();
   }
 
   // check if we can find the account already in the file
   auto acc = findAccount(account, MyMoneyAccount());
 
   // if not, we just create it
   if (acc.id().isEmpty()) {
     MyMoneyAccount brokerage;
     file->createAccount(account, parentAccount, brokerage, MyMoneyMoney());
   }
 }
 
 MyMoneyAccount MyMoneyQifReader::findAccount(const MyMoneyAccount& acc, const MyMoneyAccount& parent) const
 {
   static MyMoneyAccount nullAccount;
 
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<MyMoneyAccount> parents;
   try {
     // search by id
     if (!acc.id().isEmpty()) {
       return file->account(acc.id());
     }
     // collect the parents. in case parent does not have an id, we scan the all top-level accounts
     if (parent.id().isEmpty()) {
       parents << file->asset();
       parents << file->liability();
       parents << file->income();
       parents << file->expense();
       parents << file->equity();
     } else {
       parents << parent;
     }
     QList<MyMoneyAccount>::const_iterator it_p;
     for (it_p = parents.constBegin(); it_p != parents.constEnd(); ++it_p) {
       MyMoneyAccount parentAccount = *it_p;
       // search by name (allow hierarchy)
       int pos;
       // check for ':' in the name and use it as separator for a hierarchy
       QString name = acc.name();
       bool notFound = false;
       while ((pos = name.indexOf(MyMoneyFile::AccountSeparator)) != -1) {
         QString part = name.left(pos);
         QString remainder = name.mid(pos + 1);
         const auto existingAccount = file->subAccountByName(parentAccount, part);
         // if account has not been found, continue with next top level parent
         if (existingAccount.id().isEmpty()) {
           notFound = true;
           break;
         }
         parentAccount = existingAccount;
         name = remainder;
       }
       if (notFound)
         continue;
       const auto existingAccount = file->subAccountByName(parentAccount, name);
       if (!existingAccount.id().isEmpty()) {
         if (acc.accountType() != eMyMoney::Account::Type::Unknown) {
           if (acc.accountType() != existingAccount.accountType())
             continue;
         }
         return existingAccount;
       }
     }
   } catch (const MyMoneyException &e) {
-    KMessageBox::error(0, i18n("Unable to find account: %1", e.what()));
+    KMessageBox::error(0, i18n("Unable to find account: %1", QString::fromLatin1(e.what())));
   }
   return nullAccount;
 }
 
 const QString MyMoneyQifReader::transferAccount(const 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() == eMyMoney::Account::Type::Investment)) {
     m_qifEntry.clear();               // and construct a temp entry to create/search the account
     m_qifEntry << QString("N%1").arg(acc.brokerageName());
     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(eMyMoney::Account::Type 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");
     }
     auto b = d->isTransfer(name, m_qifProfile.accountDelimiter().left(1), m_qifProfile.accountDelimiter().mid(1, 1));
     Q_UNUSED(b)
     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.", 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 (const MyMoneyException &e) {
-    KMessageBox::detailedError(0,
+    KMessageBox::detailedError(nullptr,
                                i18n("Error while creating opening balance transaction"),
-                               QString("%1(%2):%3").arg(e.file()).arg(e.line()).arg(e.what()),
+                               e.what(),
                                i18n("File access error"));
   }
 }
 
 void MyMoneyQifReader::processTransactionEntry()
 {
   ++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", qPrintable(m_qifProfile.date(extractLine('D')).toString(Qt::ISODate)), 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.constFind(hash);
     if (it == d->m_hashMap.constEnd()) {
       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.toLower() == "opening balance") || KMyMoneySettings::qifOpeningBalance().toLower().contains(payee.toLower()))) {
       createOpeningBalance(d->accountType);
       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;
   switch (d->accountType) {
   case eMyMoney::Account::Type::Checkings:
     d->st.m_eType=eMyMoney::Statement::Type::Checkings;
     break;
   case eMyMoney::Account::Type::Savings:
     d->st.m_eType=eMyMoney::Statement::Type::Savings;
     break;
   case eMyMoney::Account::Type::Investment:
     d->st.m_eType=eMyMoney::Statement::Type::Investment;
     break;
   case eMyMoney::Account::Type::CreditCard:
     d->st.m_eType=eMyMoney::Statement::Type::CreditCard;
     break;
   default:
     d->st.m_eType=eMyMoney::Statement::Type::None;
     break;
   }
 
   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.", extractLine('D'), m_qifProfile.inputDateFormat()),
              i18n("Invalid date format"));
     switch (rc) {
       case KMessageBox::Continue:
         tr.m_datePosted = (QDate::currentDate());
         break;
 
       case KMessageBox::Cancel:
-        throw MYMONEYEXCEPTION("USERABORT");
+        throw MYMONEYEXCEPTION_CSTRING("USERABORT");
         break;
     }
   }
 
   tmp = extractLine('L');
   pos = tmp.lastIndexOf("--");
   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);
 
   //             split transaction
   //      ****** ensure each field is ******
   //      *   attached to correct split    *
   QList<qSplit> listqSplits;
   if (! extractSplits(listqSplits)) {
     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.trimmed();
       accountId = file->checkCategory(tmp, s1.m_amount, s2.m_amount);
     }
 
     if (!accountId.isEmpty()) {
       try {
         account = file->account(accountId);
         // FIXME: check that the type matches and ask if not
 
         if (account.accountType() == eMyMoney::Account::Type::Investment) {
           qDebug() << "Line " << m_linenumber << ": Cannot transfer to/from an investment account. Transaction ignored.";
           return;
         }
         if (account.id() == m_account.id()) {
           qDebug() << "Line " << m_linenumber << ": Cannot transfer to the same account. Transfer ignored.";
           accountId.clear();
         }
 
       } catch (const MyMoneyException &) {
         qDebug() << "Line " << m_linenumber << ": Account with id " << accountId.data() << " not found";
         accountId.clear();
       }
     }
 
     if (!accountId.isEmpty()) {
       s2.m_accountId = accountId;
       s2.m_strCategoryName = tmp;
       tr.m_listSplits.append(s2);
     }
 
   } else {
     int   count;
     for (count = 1; count <= listqSplits.count(); ++count) {                     // Use true splits 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.lastIndexOf("--");
         if (pos != -1) {
           tmp = tmp.left(pos);
         }
         tmp = tmp.trimmed();
         accountId = file->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() == eMyMoney::Account::Type::Investment) {
             qDebug() << "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()) {
             qDebug() << "Line " << m_linenumber << ": Cannot transfer to the same account. Transfer ignored.";
             accountId.clear();
           }
 
         } catch (const MyMoneyException &) {
           qDebug() << "Line " << m_linenumber << ": Account with id " << accountId.data() << " not found";
           accountId.clear();
         }
       }
       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()
 {
 //   qDebug() << "Investment Transaction:" << m_qifEntry.count() << " lines";
   /*
   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.
 
   */
 
   MyMoneyStatement::Transaction tr;
   d->st.m_eType = eMyMoney::Statement::Type::Investment;
 
 //  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.", extractLine('D'), m_qifProfile.inputDateFormat()),
              i18n("Invalid date format"));
     switch (rc) {
       case KMessageBox::Continue:
         tr.m_datePosted = QDate::currentDate();
         break;
 
       case KMessageBox::Cancel:
-        throw MYMONEYEXCEPTION("USERABORT");
+        throw MYMONEYEXCEPTION_CSTRING("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", qPrintable(m_qifProfile.date(extractLine('D')).toString(Qt::ISODate)), 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.constFind(hash);
     if (it == d->m_hashMap.constEnd()) {
       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').toLower();
   if (securityname.isEmpty()) {
     qDebug() << "Line " << m_linenumber << ": Investment transaction without a security is not supported.";
     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().toLower();
     QString name = security.name().toLower();
 
     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) {
     qDebug() << "Line " << m_linenumber << ": Security " << securityname << " not found in this account.  Transaction ignored.";
 
     // 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.", securityname),
                              i18n("Security not found"),
                              QString("MissingSecurity%1").arg(securityname.trimmed()));
     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').toLower();
 
   // remove trailing X, which seems to have no purpose (?!)
   bool xAction = false;
   if (action.endsWith('x')) {
     action = action.left(action.length() - 1);
     xAction = true;
   }
 
   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)) {
     tmp = tmp.remove(QRegExp("[\\[\\]]"));                 //  xAction != true so ignore any'[ and ]'
     if (!tmp.isEmpty()) {                                  // use 'L' record name
       tr.m_strBrokerageAccount = tmp;
       transferAccount(tmp);                                // make sure the account exists
     } else {
       tr.m_strBrokerageAccount = m_account.brokerageName();// use brokerage account
       transferAccount(m_account.brokerageName());          // make sure the account exists
     }
   } else {
     tmp = tmp.remove(QRegExp("[\\[\\]]"));                 //  xAction != true so ignore any'[ and ]'
     tr.m_strInterestCategory = tmp;
     tr.m_strBrokerageAccount = m_account.brokerageName();
   }
 
   // Whether to create a cash split for the other side of the value
   QString accountname; //= extractLine('L');
   if (action == "reinvint" || action == "reinvdiv" || action == "reinvlg" || action == "reinvsh") {
     d->st.m_listPrices += price;
     tr.m_shares = quantity;
     tr.m_eAction = (eMyMoney::Transaction::Action::ReinvestDividend);
     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 = (eMyMoney::Transaction::Action::CashDividend);
 
     // 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 -= 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 = (eMyMoney::Transaction::Action::Interest);
     if (action == "miscexp")
       tr.m_eAction = (eMyMoney::Transaction::Action::Fees);
 
     // 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);
     }
 
     if (action == "intinc") {
       MyMoneyMoney priceValue = m_qifProfile.value('I', extractLine('I'));
       tr.m_amount -= tr.m_fees;
       if ((!quantity.isZero()) && (!priceValue.isZero()))
         tr.m_amount = -(quantity * priceValue);
     } else
       // 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))).trimmed();
   } else if (action == "xin" || action == "xout") {
     QString payee = extractLine('P');
     if (!payee.isEmpty() && ((payee.toLower() == "opening balance") || KMyMoneySettings::qifOpeningBalance().toLower().contains(payee.toLower()))) {
       createOpeningBalance(eMyMoney::Account::Type::Investment);
       return;
     }
 
     tr.m_eAction = (eMyMoney::Transaction::Action::None);
     MyMoneyStatement::Split s2;
     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") {
     d->st.m_listPrices += price;
     tr.m_price = m_qifProfile.value('I', extractLine('I'));
     tr.m_shares = quantity;
     tr.m_amount = -amount;
     tr.m_eAction = (eMyMoney::Transaction::Action::Buy);
   } else if (action == "sell") {
     d->st.m_listPrices += price;
     tr.m_price = m_qifProfile.value('I', extractLine('I'));
     tr.m_shares = -quantity;
     tr.m_amount = amount;
     tr.m_eAction = (eMyMoney::Transaction::Action::Sell);
   } else if (action == "shrsin") {
     tr.m_shares = quantity;
     tr.m_eAction = (eMyMoney::Transaction::Action::Shrsin);
   } else if (action == "shrsout") {
     tr.m_shares = -quantity;
     tr.m_eAction = (eMyMoney::Transaction::Action::Shrsout);
   } else if (action == "stksplit") {
     MyMoneyMoney splitfactor = (quantity / MyMoneyMoney(10, 1)).reduce();
 
     // Stock splits not supported
 //     qDebug() << "Line " << m_linenumber << ": Stock split not supported (date=" << date << " security=" << securityname << " factor=" << splitfactor.toString() << ")";
 
 //    s1.setShares(splitfactor);
 //    s1.setValue(0);
 //   s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares));
 
 //     return;
   } else {
     // Unsupported action type
     qDebug() << "Line " << m_linenumber << ": Unsupported transaction action (" << action << ")";
     return;
   }
   d->st.m_strAccountName = accountname;  //  accountname appears not to get set
   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.constBegin();
   while (it_accid != list.constEnd()) {
     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 newAccount;
     newAccount.setName(searchname);
     newAccount.setAccountType(eMyMoney::Account::Type::Income);
     MyMoneyAccount income = file->income();
     MyMoneyFileTransaction ft;
     file->addAccount(newAccount, income);
     ft.commit();
     result = newAccount.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.constBegin();
   while (it_accid != list.constEnd()) {
     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 newAccount;
     newAccount.setName(searchname);
     newAccount.setAccountType(eMyMoney::Account::Type::Expense);
     MyMoneyFileTransaction ft;
     MyMoneyAccount expense = file->expense();
     file->addAccount(newAccount, expense);
     ft.commit();
     result = newAccount.id();
   }
 
   return result;
 }
 
 const 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').toLower().remove(QRegExp("\\s+"));
   if (type == m_qifProfile.profileType().toLower().remove(QRegExp("\\s+"))) {
     account.setAccountType(eMyMoney::Account::Type::Checkings);
   } else if (type == "ccard" || type == "creditcard") {
     account.setAccountType(eMyMoney::Account::Type::CreditCard);
   } else if (type == "cash") {
     account.setAccountType(eMyMoney::Account::Type::Cash);
   } else if (type == "otha") {
     account.setAccountType(eMyMoney::Account::Type::Asset);
   } else if (type == "othl") {
     account.setAccountType(eMyMoney::Account::Type::Liability);
   } else if (type == "invst" || type == "port") {
     account.setAccountType(eMyMoney::Account::Type::Investment);
     transactionType = EntryInvestmentTransaction;
   } else if (type == "mutual") { // stock account w/o umbrella investment account
     account.setAccountType(eMyMoney::Account::Type::Stock);
     transactionType = EntryInvestmentTransaction;
   } else if (type == "unknown") {
     // don't do anything with the type, leave it unknown
   } else {
     account.setAccountType(eMyMoney::Account::Type::Checkings);
     qDebug() << "Line " << m_linenumber << ": Unknown account type '" << type << "', checkings assumed";
   }
 
   // check if we can find the account already in the file
   auto acc = 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() == eMyMoney::Account::Type::Unknown)
       account.setAccountType(eMyMoney::Account::Type::Checkings);
 
     MyMoneyAccount parentAccount;
     MyMoneyAccount brokerage;
     // in case it's a stock account, we need to setup a fix investment account
     if (account.isInvest()) {
       acc.setName(i18n("%1 (Investment)", account.name()));   // use the same name for the investment account
       acc.setDescription(i18n("Autogenerated by QIF importer from type Mutual account entry"));
       acc.setAccountType(eMyMoney::Account::Type::Investment);
       parentAccount = file->asset();
       file->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 eMyMoney::Account::Type::Asset:
         default:
           parentAccount = file->asset();
           break;
         case eMyMoney::Account::Type::Liability:
           parentAccount = file->liability();
           break;
         case eMyMoney::Account::Type::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
     // but only create it (not here, but later) if it is needed
     if (account.accountType() == eMyMoney::Account::Type::Investment) {
       brokerage.setName(QString());  //                           brokerage name empty so account not created yet
       brokerage.setAccountType(eMyMoney::Account::Type::Checkings);
       brokerage.setCurrencyId(MyMoneyFile::instance()->baseCurrency().id());
     }
     file->createAccount(account, parentAccount, brokerage, MyMoneyMoney());
     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();  //                      needed here for account selection
     d->transactionType = transactionType;
   }
   return acc.id();
 }
 
 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()
 {
   /*
     !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.constBegin();
 
   // Make a price for each line
   QRegExp priceExp("\"(.*)\",(.*),\"(.*)\"");
   while (it_line != m_qifEntry.constEnd()) {
     if (priceExp.indexIn(*it_line) != -1) {
       MyMoneyStatement::Price price;
       price.m_strSecurity = priceExp.cap(1);
       QString pricestr = priceExp.cap(2);
       QString datestr = priceExp.cap(3);
       qDebug() << "Price:" << price.m_strSecurity << " / " << pricestr << " / " << datestr;
 
       // 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()
 {
   /*
   !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;
 }
diff --git a/kmymoney/plugins/sql/mymoneydbdef.cpp b/kmymoney/plugins/sql/mymoneydbdef.cpp
index d63bd66fc..477a54ab3 100644
--- a/kmymoney/plugins/sql/mymoneydbdef.cpp
+++ b/kmymoney/plugins/sql/mymoneydbdef.cpp
@@ -1,776 +1,776 @@
 /***************************************************************************
                           mymoneydbdef.h
                           -------------------
     begin                : 20 February 2010
     copyright            : (C) 2010 by Fernando Vilas
     email                : tonybloom@users.sourceforge.net
                          : Fernando Vilas <fvilas@iname.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneydbdef.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include "mymoneydbdriver.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyexception.h"
 #include "mymoneystoragemgr.h"
 
 #include <alkimia/alkvalue.h>
 
 //***************** THE CURRENT VERSION OF THE DATABASE LAYOUT ****************
 unsigned int MyMoneyDbDef::m_currentVersion = 12;
 
 // ************************* Build table descriptions ****************************
 MyMoneyDbDef::MyMoneyDbDef()
 {
   FileInfo();
   PluginInfo();
   Institutions();
   Payees();
   PayeesPayeeIdentifier();
   Tags();
   TagSplits(); // a table to bind tags and splits
   Accounts();
   AccountsPayeeIdentifier();
   Transactions();
   Splits();
   KeyValuePairs();
   Schedules();
   SchedulePaymentHistory();
   Securities();
   Prices();
   Currencies();
   Reports();
   Budgets();
   Balances();
   OnlineJobs();
   PayeeIdentifier();
   CostCenter();
 }
 
 /* PRIMARYKEY - these fields combine to form a unique key field on which the db will create an index
    NOTNULL - this field should never be null
    UNSIGNED - for numeric types, indicates the field is UNSIGNED
    ?ISKEY - where there is no primary key, these fields can be used to uniquely identify a record
   Default is that a field is not a part of a primary key, nullable, and if numeric, signed */
 
 static const bool PRIMARYKEY = true;
 static const bool NOTNULL = true;
 static const bool UNSIGNED = false;
 
 #define appendField(a) fields.append(QExplicitlySharedDataPointer<MyMoneyDbColumn>(new a))
 void MyMoneyDbDef::FileInfo()
 {
   QList< QExplicitlySharedDataPointer<MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("version", "varchar(16)"));
   appendField(MyMoneyDbColumn("created", "date"));
   appendField(MyMoneyDbColumn("lastModified", "date"));
   appendField(MyMoneyDbColumn("baseCurrency", "char(3)"));
   appendField(MyMoneyDbIntColumn("institutions", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("accounts", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("payees", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("tags", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 7));
   appendField(MyMoneyDbIntColumn("transactions", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("splits", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("securities", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("prices", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("currencies", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("schedules", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("reports", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("kvps", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbColumn("dateRangeStart", "date"));
   appendField(MyMoneyDbColumn("dateRangeEnd", "date"));
   appendField(MyMoneyDbIntColumn("hiInstitutionId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiPayeeId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiTagId", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 7));
   appendField(MyMoneyDbIntColumn("hiAccountId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiTransactionId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiScheduleId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiSecurityId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbIntColumn("hiReportId", MyMoneyDbIntColumn::BIG, UNSIGNED));
   appendField(MyMoneyDbColumn("encryptData", "varchar(255)"));
   appendField(MyMoneyDbColumn("updateInProgress", "char(1)"));
   appendField(MyMoneyDbIntColumn("budgets", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 1));
   appendField(MyMoneyDbIntColumn("hiBudgetId", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 1));
   appendField(MyMoneyDbIntColumn("hiOnlineJobId", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 8));
   appendField(MyMoneyDbIntColumn("hiPayeeIdentifierId", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 8));
   appendField(MyMoneyDbColumn("logonUser", "varchar(255)", false, false, 1));
   appendField(MyMoneyDbDatetimeColumn("logonAt", false, false, 1));
   appendField(MyMoneyDbIntColumn("fixLevel",
                                  MyMoneyDbIntColumn::MEDIUM, UNSIGNED, false, false, 6));
   MyMoneyDbTable t("kmmFileInfo", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Institutions()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("name", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("manager"));
   appendField(MyMoneyDbTextColumn("routingCode"));
   appendField(MyMoneyDbTextColumn("addressStreet"));
   appendField(MyMoneyDbTextColumn("addressCity"));
   appendField(MyMoneyDbTextColumn("addressZipcode"));
   appendField(MyMoneyDbTextColumn("telephone"));
   MyMoneyDbTable t("kmmInstitutions", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Payees()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)",  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("name"));
   appendField(MyMoneyDbTextColumn("reference"));
   appendField(MyMoneyDbTextColumn("email"));
   appendField(MyMoneyDbTextColumn("addressStreet"));
   appendField(MyMoneyDbTextColumn("addressCity"));
   appendField(MyMoneyDbTextColumn("addressZipcode"));
   appendField(MyMoneyDbTextColumn("addressState"));
   appendField(MyMoneyDbTextColumn("telephone"));
   appendField(MyMoneyDbTextColumn("notes", MyMoneyDbTextColumn::LONG, false, false, 5));
   appendField(MyMoneyDbColumn("defaultAccountId", "varchar(32)", false, false, 5));
   appendField(MyMoneyDbIntColumn("matchData", MyMoneyDbIntColumn::TINY, UNSIGNED, false, false, 5));
   appendField(MyMoneyDbColumn("matchIgnoreCase", "char(1)", false, false, 5));
   appendField(MyMoneyDbTextColumn("matchKeys", MyMoneyDbTextColumn::MEDIUM, false, false, 5));
   MyMoneyDbTable t("kmmPayees", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::PayeesPayeeIdentifier()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("payeeId", "varchar(32)",  PRIMARYKEY, NOTNULL, 8));
   appendField(MyMoneyDbIntColumn("\"order\"", MyMoneyDbIntColumn::SMALL, UNSIGNED, PRIMARYKEY, NOTNULL, 8, 9));
   appendField(MyMoneyDbIntColumn("userOrder", MyMoneyDbIntColumn::SMALL, UNSIGNED, PRIMARYKEY, NOTNULL, 10));
   appendField(MyMoneyDbColumn("identifierId", "varchar(32)", false, NOTNULL, 8));
   MyMoneyDbTable t("kmmPayeesPayeeIdentifier", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Tags()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)",  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("name"));
   appendField(MyMoneyDbColumn("closed", "char(1)", false, false, 5));
   appendField(MyMoneyDbTextColumn("notes", MyMoneyDbTextColumn::LONG, false, false, 5));
   appendField(MyMoneyDbTextColumn("tagColor"));
   MyMoneyDbTable t("kmmTags", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::TagSplits()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("transactionId", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("tagId", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbIntColumn("splitId", MyMoneyDbIntColumn::SMALL, UNSIGNED, PRIMARYKEY, NOTNULL));
   MyMoneyDbTable t("kmmTagSplits", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Accounts()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)",  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("institutionId", "varchar(32)"));
   appendField(MyMoneyDbColumn("parentId", "varchar(32)"));
   appendField(MyMoneyDbDatetimeColumn("lastReconciled"));
   appendField(MyMoneyDbDatetimeColumn("lastModified"));
   appendField(MyMoneyDbColumn("openingDate", "date"));
   appendField(MyMoneyDbTextColumn("accountNumber"));
   appendField(MyMoneyDbColumn("accountType", "varchar(16)", false, NOTNULL));
   appendField(MyMoneyDbTextColumn("accountTypeString"));
   appendField(MyMoneyDbColumn("isStockAccount", "char(1)"));
   appendField(MyMoneyDbTextColumn("accountName"));
   appendField(MyMoneyDbTextColumn("description"));
   appendField(MyMoneyDbColumn("currencyId", "varchar(32)"));
   appendField(MyMoneyDbTextColumn("balance"));
   appendField(MyMoneyDbTextColumn("balanceFormatted"));
   appendField(MyMoneyDbIntColumn("transactionCount", MyMoneyDbIntColumn::BIG, UNSIGNED, false, false, 1));
   MyMoneyDbTable t("kmmAccounts", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::AccountsPayeeIdentifier()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("accountId", "varchar(32)",  PRIMARYKEY, NOTNULL, 8));
   appendField(MyMoneyDbIntColumn("\"order\"", MyMoneyDbIntColumn::SMALL, UNSIGNED, PRIMARYKEY, NOTNULL, 8, 9));
   appendField(MyMoneyDbIntColumn("userOrder", MyMoneyDbIntColumn::SMALL, UNSIGNED, PRIMARYKEY, NOTNULL, 10));
   appendField(MyMoneyDbColumn("identifierId", "varchar(32)", false, NOTNULL, 8));
   MyMoneyDbTable t("kmmAccountsPayeeIdentifier", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Transactions()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("txType", "char(1)"));
   appendField(MyMoneyDbDatetimeColumn("postDate"));
   appendField(MyMoneyDbTextColumn("memo"));
   appendField(MyMoneyDbDatetimeColumn("entryDate"));
   appendField(MyMoneyDbColumn("currencyId", "char(3)"));
   appendField(MyMoneyDbTextColumn("bankId"));
   MyMoneyDbTable t("kmmTransactions", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Splits()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("transactionId", "varchar(32)",  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("txType", "char(1)"));
   appendField(MyMoneyDbIntColumn("splitId", MyMoneyDbIntColumn::SMALL, UNSIGNED,  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("payeeId", "varchar(32)"));
   appendField(MyMoneyDbDatetimeColumn("reconcileDate"));
   appendField(MyMoneyDbColumn("action", "varchar(16)"));
   appendField(MyMoneyDbColumn("reconcileFlag", "char(1)"));
   appendField(MyMoneyDbTextColumn("value", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbColumn("valueFormatted", "text"));
   appendField(MyMoneyDbTextColumn("shares", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("sharesFormatted"));
   appendField(MyMoneyDbTextColumn("price", MyMoneyDbTextColumn::NORMAL, false, false, 2));
   appendField(MyMoneyDbTextColumn("priceFormatted", MyMoneyDbTextColumn::MEDIUM, false, false, 2));
   appendField(MyMoneyDbTextColumn("memo"));
   appendField(MyMoneyDbColumn("accountId", "varchar(32)", false, NOTNULL));
   appendField(MyMoneyDbColumn("costCenterId", "varchar(32)", false, false, 9));
   appendField(MyMoneyDbColumn("checkNumber", "varchar(32)"));
   appendField(MyMoneyDbDatetimeColumn("postDate", false, false, 1));
   appendField(MyMoneyDbTextColumn("bankId", MyMoneyDbTextColumn::MEDIUM, false, false, 5));
   MyMoneyDbTable t("kmmSplits", fields);
   QStringList list;
   list << "accountId" << "txType";
   t.addIndex("kmmSplitsaccount_type", list, false);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::KeyValuePairs()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("kvpType", "varchar(16)", false, NOTNULL));
   appendField(MyMoneyDbColumn("kvpId", "varchar(32)"));
   appendField(MyMoneyDbColumn("kvpKey", "varchar(255)", false, NOTNULL));
   appendField(MyMoneyDbTextColumn("kvpData"));
   MyMoneyDbTable t("kmmKeyValuePairs", fields);
   QStringList list;
   list << "kvpType" << "kvpId";
   t.addIndex("type_id", list, false);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Schedules()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("name", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbIntColumn("type", MyMoneyDbIntColumn::TINY, UNSIGNED, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("typeString"));
   appendField(MyMoneyDbIntColumn("occurence", MyMoneyDbIntColumn::SMALL, UNSIGNED, false, // krazy:exclude=spelling
                                  NOTNULL));
   appendField(MyMoneyDbIntColumn("occurenceMultiplier", MyMoneyDbIntColumn::SMALL, UNSIGNED, // krazy:exclude=spelling
                                  false, NOTNULL, 3));
   appendField(MyMoneyDbTextColumn("occurenceString")); // krazy:exclude=spelling
   appendField(MyMoneyDbIntColumn("paymentType", MyMoneyDbIntColumn::TINY, UNSIGNED));
   appendField(MyMoneyDbTextColumn("paymentTypeString", MyMoneyDbTextColumn::LONG));
   appendField(MyMoneyDbColumn("startDate", "date", false, NOTNULL));
   appendField(MyMoneyDbColumn("endDate", "date"));
   appendField(MyMoneyDbColumn("fixed", "char(1)", false, NOTNULL));
   appendField(MyMoneyDbColumn("lastDayInMonth", "char(1)", false, NOTNULL, 11, std::numeric_limits<int>::max(), QLatin1String("N")));
   appendField(MyMoneyDbColumn("autoEnter", "char(1)", false, NOTNULL));
   appendField(MyMoneyDbColumn("lastPayment", "date"));
   appendField(MyMoneyDbColumn("nextPaymentDue", "date"));
   appendField(MyMoneyDbIntColumn("weekendOption", MyMoneyDbIntColumn::TINY, UNSIGNED, false,
                                  NOTNULL));
   appendField(MyMoneyDbTextColumn("weekendOptionString"));
   MyMoneyDbTable t("kmmSchedules", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::SchedulePaymentHistory()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("schedId", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("payDate", "date", PRIMARYKEY,  NOTNULL));
   MyMoneyDbTable t("kmmSchedulePaymentHistory", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Securities()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("name", "text", false, NOTNULL));
   appendField(MyMoneyDbTextColumn("symbol"));
   appendField(MyMoneyDbIntColumn("type", MyMoneyDbIntColumn::SMALL, UNSIGNED, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("typeString"));
   appendField(MyMoneyDbColumn("smallestAccountFraction", "varchar(24)"));
   appendField(MyMoneyDbIntColumn("pricePrecision", MyMoneyDbIntColumn::SMALL, UNSIGNED, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("tradingMarket"));
   appendField(MyMoneyDbColumn("tradingCurrency", "char(3)"));
   appendField(MyMoneyDbIntColumn("roundingMethod", MyMoneyDbIntColumn::SMALL, UNSIGNED, false, NOTNULL, 11, std::numeric_limits<int>::max(), QString("%1").arg(AlkValue::RoundRound)));
   MyMoneyDbTable t("kmmSecurities", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Prices()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("fromId", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("toId", "varchar(32)",  PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("priceDate", "date", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("price", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbTextColumn("priceFormatted"));
   appendField(MyMoneyDbTextColumn("priceSource"));
   MyMoneyDbTable t("kmmPrices", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Currencies()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("ISOcode", "char(3)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbTextColumn("name", MyMoneyDbTextColumn::NORMAL, false, NOTNULL));
   appendField(MyMoneyDbIntColumn("type", MyMoneyDbIntColumn::SMALL, UNSIGNED));
   appendField(MyMoneyDbTextColumn("typeString"));
   appendField(MyMoneyDbIntColumn("symbol1", MyMoneyDbIntColumn::SMALL, UNSIGNED));
   appendField(MyMoneyDbIntColumn("symbol2", MyMoneyDbIntColumn::SMALL, UNSIGNED));
   appendField(MyMoneyDbIntColumn("symbol3", MyMoneyDbIntColumn::SMALL, UNSIGNED));
   appendField(MyMoneyDbColumn("symbolString", "varchar(255)"));
   appendField(MyMoneyDbColumn("smallestCashFraction", "varchar(24)"));
   appendField(MyMoneyDbColumn("smallestAccountFraction", "varchar(24)"));
   // the default for price precision was taken from MyMoneySecurity
   appendField(MyMoneyDbIntColumn("pricePrecision", MyMoneyDbIntColumn::SMALL, UNSIGNED, false, NOTNULL, 11, std::numeric_limits<int>::max(), QLatin1String("4")));
   MyMoneyDbTable t("kmmCurrencies", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Reports()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("name", "varchar(255)", false, NOTNULL));
   appendField(MyMoneyDbTextColumn("XML", MyMoneyDbTextColumn::LONG));
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL, 6));
   MyMoneyDbTable t("kmmReportConfig", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::OnlineJobs()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
 
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL, 8));
   appendField(MyMoneyDbColumn("type", "varchar(255)", false, NOTNULL, 8));
   appendField(MyMoneyDbDatetimeColumn("jobSend", false, false, 8));
   appendField(MyMoneyDbDatetimeColumn("bankAnswerDate", false, false, 8));
   appendField(MyMoneyDbColumn("state", "varchar(15)", false, NOTNULL, 8));
   appendField(MyMoneyDbColumn("locked", "char(1)", false, NOTNULL, 8));
 
   MyMoneyDbTable t("kmmOnlineJobs", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::PayeeIdentifier()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
 
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL, 8));
   appendField(MyMoneyDbColumn("type", "varchar(255)", false, false, 8));
 
   MyMoneyDbTable t("kmmPayeeIdentifier", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::PluginInfo()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
 
   appendField(MyMoneyDbColumn("iid", "varchar(255)", PRIMARYKEY, NOTNULL, 8));
   appendField(MyMoneyDbIntColumn("versionMajor", MyMoneyDbIntColumn::TINY, false, false, NOTNULL, 8));
   appendField(MyMoneyDbIntColumn("versionMinor", MyMoneyDbIntColumn::TINY, false, false, false, 8));
   appendField(MyMoneyDbTextColumn("uninstallQuery", MyMoneyDbTextColumn::LONG, false, false, 8));
 
   MyMoneyDbTable t("kmmPluginInfo", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Budgets()
 {
   QList<QExplicitlySharedDataPointer <MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("name", "text", false, NOTNULL));
   appendField(MyMoneyDbColumn("start", "date", false, NOTNULL));
   appendField(MyMoneyDbTextColumn("XML", MyMoneyDbTextColumn::LONG));
   MyMoneyDbTable t("kmmBudgetConfig", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::CostCenter()
 {
   QList<QExplicitlySharedDataPointer<MyMoneyDbColumn> > fields;
   appendField(MyMoneyDbColumn("id", "varchar(32)", PRIMARYKEY, NOTNULL));
   appendField(MyMoneyDbColumn("name", "text", false, NOTNULL));
   MyMoneyDbTable t("kmmCostCenter", fields);
   t.buildSQLStrings();
   m_tables[t.name()] = t;
 }
 
 void MyMoneyDbDef::Balances()
 {
   MyMoneyDbView v("kmmBalances", "CREATE VIEW kmmBalances AS "
                   "SELECT kmmAccounts.id AS id, kmmAccounts.currencyId, "
                   "kmmSplits.txType, kmmSplits.value, kmmSplits.shares, "
                   "kmmSplits.postDate AS balDate, "
                   "kmmTransactions.currencyId AS txCurrencyId "
                   "FROM kmmAccounts, kmmSplits, kmmTransactions "
                   "WHERE kmmSplits.txType = 'N' "
                   "AND kmmSplits.accountId = kmmAccounts.id "
                   "AND kmmSplits.transactionId = kmmTransactions.id;");
   m_views[v.name()] = v;
 }
 
 
 // function to write create SQL to a stream
 const QString MyMoneyDbDef::generateSQL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   QString retval;
 
   // Add the CREATE TABLE strings
   table_iterator tt = tableBegin();
   while (tt != tableEnd()) {
     retval += (*tt).generateCreateSQL(driver) + '\n';
     ++tt;
   }
 
   // Add the CREATE OR REPLACE VIEW strings
   view_iterator vt = viewBegin();
   while (vt != viewEnd()) {
     retval += (*vt).createString() + '\n';
     ++vt;
   }
   retval += '\n';
 
   // Add the strings to populate kmmFileInfo with initial values
   MyMoneyDbTable fi = m_tables["kmmFileInfo"];
   QString qs = fi.insertString();
   MyMoneyDbTable::field_iterator fit;
   for (fit = fi.begin(); fit != fi.end(); ++fit) {
     QString toReplace = (*fit)->name();
     toReplace.prepend(':');
     QString replace = "NULL";
     if ((*fit)->name() == "version")
       replace = QString::number(m_currentVersion);
     if ((*fit)->name() == "fixLevel")
       replace =  QString::number
                  (MyMoneyFile::instance()->storage()->currentFixVersion());
     if ((*fit)->name() == "created")
       replace = QLatin1Char('\'')
                 + QDate::currentDate().toString(Qt::ISODate)
                 + QLatin1Char('\'');
     if ((*fit)->name() == "lastModified")
       replace = QLatin1Char('\'')
                 + QDate::currentDate().toString(Qt::ISODate)
                 + QLatin1Char('\'');
     if ((*fit)->name() == "updateInProgress")
       replace = enclose("N");
 
     qs.replace(QRegExp(toReplace + "(?=[,\\s\\)])"), replace);
     // only replace parameters followed by comma, whitespace, closing parenthesis - otherwise
     // conflicts may occur if one parameter starts with the name of another one.
   }
   qs += "\n\n";
   retval += qs;
 
   // Add the strings to create the initial accounts
   qs.clear();
   QList<MyMoneyAccount> stdList;
   stdList.append(MyMoneyFile::instance()->asset());
   stdList.append(MyMoneyFile::instance()->equity());
   stdList.append(MyMoneyFile::instance()->expense());
   stdList.append(MyMoneyFile::instance()->income());
   stdList.append(MyMoneyFile::instance()->liability());
   for (int i = 0; i < stdList.count(); ++i) {
     MyMoneyAccount* pac = &stdList[i];
     MyMoneyDbTable ac = m_tables["kmmAccounts"];
     qs = ac.insertString();
     MyMoneyDbTable::field_iterator act;
     // do the following in reverse so the 'formatted' fields are
     // correctly handled.
     // Hmm, how does one use a QValueListIterator in reverse
     // It'll be okay in Qt4 with QListIterator
     for (act = ac.end(), --act; act != ac.begin(); --act) {
       QString toReplace = (*act)->name();
       toReplace.prepend(':');
       QString replace = "NULL";
       if ((*act)->name() == "accountType")
         replace = QString::number((int)pac->accountType());
       if ((*act)->name() == "accountTypeString")
         replace = enclose(pac->name());
       if ((*act)->name() == "isStockAccount")
         replace = enclose("N");
       if ((*act)->name() == "accountName")
         replace = enclose(pac->name());
       qs.replace(toReplace, replace);
     }
     qs.replace(":id", enclose(pac->id()));  // a real kludge
     qs += "\n\n";
     retval += qs;
   }
 
   return retval;
 }
 
 //*****************************************************************************
 
 void MyMoneyDbTable::addIndex(const QString& name, const QStringList& columns, bool unique)
 {
   m_indices.push_back(MyMoneyDbIndex(m_name, name, columns, unique));
 }
 
 void MyMoneyDbTable::buildSQLStrings()
 {
   // build fixed SQL strings for this table
   // build the insert string with placeholders for each field
   QString qs = QString("INSERT INTO %1 (").arg(name());
   QString ws = ") VALUES (";
   field_iterator ft = m_fields.constBegin();
   while (ft != m_fields.constEnd()) {
     qs += QString("%1, ").arg((*ft)->name());
     ws += QString(":%1, ").arg((*ft)->name());
     ++ft;
   }
   qs = qs.left(qs.length() - 2);
   ws = ws.left(ws.length() - 2);
   m_insertString = qs + ws + ");";
   // build a 'select all' string (select * is deprecated)
   // don't terminate with semicolon coz we may want a where or order clause
   m_selectAllString = "SELECT " + columnList() + " FROM " + name();
 
   // build an update string; key fields go in the where clause
   qs = "UPDATE " + name() + " SET ";
   ws.clear();
   ft = m_fields.constBegin();
   while (ft != m_fields.constEnd()) {
     if ((*ft)->isPrimaryKey()) {
       if (!ws.isEmpty()) ws += " AND ";
       ws += QString("%1 = :%2").arg((*ft)->name()).arg((*ft)->name());
     } else {
       qs += QString("%1 = :%2, ").arg((*ft)->name()).arg((*ft)->name());
     }
     ++ft;
   }
   qs = qs.left(qs.length() - 2);
   if (!ws.isEmpty()) qs += " WHERE " + ws;
   m_updateString = qs + ';';
   // build a delete string; where clause as for update
   qs = "DELETE FROM " + name();
   if (!ws.isEmpty()) qs += " WHERE " + ws;
   m_deleteString = qs + ';';
 
   // Setup the column name hash
   ft = m_fields.constBegin();
   m_fieldOrder.reserve(m_fields.size());
   int i = 0;
   while (ft != m_fields.constEnd()) {
     m_fieldOrder[(*ft)->name()] = i;
     ++i; ++ft;
   }
 }
 
 const QString MyMoneyDbTable::columnList(const int version) const
 {
   field_iterator ft = m_fields.begin();
   QString qs;
   ft = m_fields.begin();
   while (ft != m_fields.end()) {
     if ((*ft)->initVersion() <= version && (*ft)->lastVersion() >= version) {
       qs += QString("%1, ").arg((*ft)->name());
     }
     ++ft;
   }
   return (qs.left(qs.length() - 2));
 }
 
 const QString MyMoneyDbTable::generateCreateSQL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver, int version) const
 {
   QString qs = QString("CREATE TABLE %1 (").arg(name());
   QString pkey;
   for (field_iterator it = m_fields.begin(); it != m_fields.end(); ++it) {
     if ((*it)->initVersion() <= version && (*it)->lastVersion() >= version) {
       qs += (*it)->generateDDL(driver) + ", ";
       if ((*it)->isPrimaryKey())
         pkey += (*it)->name() + ", ";
     }
   }
 
   if (!pkey.isEmpty()) {
     qs += "PRIMARY KEY (" + pkey;
     qs = qs.left(qs.length() - 2) + "))";
   } else {
     qs = qs.left(qs.length() - 2) + ')';
   }
 
   qs += driver->tableOptionString();
   qs += ";\n";
 
   for (index_iterator ii = m_indices.begin(); ii != m_indices.end(); ++ii) {
     qs += (*ii).generateDDL(driver);
   }
   return qs;
 }
 
 const QString MyMoneyDbTable::dropPrimaryKeyString(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   return driver->dropPrimaryKeyString(m_name);
 }
 
 bool MyMoneyDbTable::hasPrimaryKey(int version) const
 {
   field_iterator ft = m_fields.constBegin();
   while (ft != m_fields.constEnd()) {
     if ((*ft)->initVersion() <= version && (*ft)->lastVersion() >= version) {
       if ((*ft)->isPrimaryKey())
         return (true);
     }
     ++ft;
   }
   return (false);
 }
 
 const QString MyMoneyDbTable::modifyColumnString(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver, const QString& columnName, const MyMoneyDbColumn& newDef) const
 {
   return driver->modifyColumnString(m_name, columnName, newDef);
 }
 
 int MyMoneyDbTable::fieldNumber(const QString& name) const
 {
   QHash<QString, int>::ConstIterator i = m_fieldOrder.find(name);
   if (m_fieldOrder.constEnd() == i) {
-    throw MYMONEYEXCEPTION(QString("Unknown field %1 in table %2").arg(name).arg(m_name));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Unknown field %1 in table %2").arg(name).arg(m_name));
   }
   return i.value();
 }
 
 //*****************************************************************************
 const QString MyMoneyDbIndex::generateDDL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   Q_UNUSED(driver);
 
   QString qs = "CREATE ";
 
   if (m_unique)
     qs += "UNIQUE ";
 
   qs += "INDEX " + m_table + '_' + m_name + "_idx ON "
         + m_table + " (";
 
   // The following should probably be revised.  MySQL supports an index on
   // partial columns, but not on a function.  Postgres supports an index on
   // the result of an SQL function, but not a partial column.  There should be
   // a way to merge these, and support other DBMSs like SQLite at the same time.
   // For now, if we just use plain columns, this will work fine.
   for (QStringList::ConstIterator it = m_columns.constBegin(); it != m_columns.constEnd(); ++it) {
     qs += *it + ',';
   }
 
   qs = qs.left(qs.length() - 1) + ");\n";
 
   return qs;
 }
 
 //*****************************************************************************
 // These are the actual column types.
 //
 
 MyMoneyDbColumn*         MyMoneyDbColumn::clone() const
 {
   return (new MyMoneyDbColumn(*this));
 }
 
 MyMoneyDbIntColumn*      MyMoneyDbIntColumn::clone() const
 {
   return (new MyMoneyDbIntColumn(*this));
 }
 
 MyMoneyDbDatetimeColumn* MyMoneyDbDatetimeColumn::clone() const
 {
   return (new MyMoneyDbDatetimeColumn(*this));
 }
 
 MyMoneyDbTextColumn* MyMoneyDbTextColumn::clone() const
 {
   return (new MyMoneyDbTextColumn(*this));
 }
 
 const QString MyMoneyDbColumn::generateDDL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   Q_UNUSED(driver);
 
   QString qs = name() + ' ' + type();
   if (isNotNull()) qs += " NOT NULL";
   if (!defaultValue().isEmpty())
       qs += QString(" DEFAULT \"%1\"").arg(defaultValue());
   return qs;
 }
 
 const QString MyMoneyDbIntColumn::generateDDL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   QString qs = driver->intString(*this);
   if (!defaultValue().isEmpty())
       qs += QString(" DEFAULT %1").arg(defaultValue());
   return qs;
 }
 
 const QString MyMoneyDbTextColumn::generateDDL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   return driver->textString(*this);
 }
 
 const QString MyMoneyDbDatetimeColumn::generateDDL(const QExplicitlySharedDataPointer<MyMoneyDbDriver>& driver) const
 {
   return driver->timestampString(*this);
 }
 
 
diff --git a/kmymoney/plugins/sql/mymoneydbdriver.cpp b/kmymoney/plugins/sql/mymoneydbdriver.cpp
index 666122f03..52fde5923 100644
--- a/kmymoney/plugins/sql/mymoneydbdriver.cpp
+++ b/kmymoney/plugins/sql/mymoneydbdriver.cpp
@@ -1,706 +1,706 @@
 /***************************************************************************
                           mymoneydbdriver.cpp
                           ---------------------
     begin                : 19 February 2010
     copyright            : (C) 2010 by Fernando Vilas
     email                : Fernando Vilas <fvilas@iname.com>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneydbdriver.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QSqlQuery>
 #include <QVariant>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include "mymoneydbdef.h"
 #include "mymoneyexception.h"
 
 //********************* The driver subclass definitions ********************
 // It is only necessary to implement the functions that deviate from the
 // default of the base type
 
 class MyMoneyDb2Driver : public MyMoneyDbDriver
 {
 public:
   MyMoneyDb2Driver() {
   }
 
   QString textString(const MyMoneyDbTextColumn& c) const final override;
 };
 
 class MyMoneyInterbaseDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneyInterbaseDriver() {
   }
 };
 
 class MyMoneyMysqlDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneyMysqlDriver() {
   }
 
   bool isTested() const final override;
   bool canAutocreate() const final override;
   QString defaultDbName() const final override;
   QString createDbString(const QString& name) const final override;
   QString dropPrimaryKeyString(const QString& name) const final override;
   QString dropIndexString(const QString& tableName, const QString& indexName) const final override;
   QString modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const final override;
   QString intString(const MyMoneyDbIntColumn& c) const final override;
   QString timestampString(const MyMoneyDbDatetimeColumn& c) const final override;
   QString tableOptionString() const final override;
   QString highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const final override;
   QStringList tables(QSql::TableType tt, const QSqlDatabase& db) const final override;
 };
 
 class MyMoneyOracleDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneyOracleDriver() {
   }
 
   QString dropPrimaryKeyString(const QString& name) const final override;
   QString modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const final override;
   QString intString(const MyMoneyDbIntColumn& c) const final override;
   QString textString(const MyMoneyDbTextColumn& c) const final override;
   QString highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const final override;
 };
 
 class MyMoneyODBCDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneyODBCDriver() {
   }
 
   QString timestampString(const MyMoneyDbDatetimeColumn& c) const final override;
 };
 
 class MyMoneyPostgresqlDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneyPostgresqlDriver() {
   }
 
   bool isTested() const final override;
   bool canAutocreate() const final override;
   QString defaultDbName() const final override;
   QString createDbString(const QString& name) const final override;
   QString dropPrimaryKeyString(const QString& name) const final override;
   QString modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const final override;
   QString intString(const MyMoneyDbIntColumn& c) const final override;
   QString textString(const MyMoneyDbTextColumn& c) const final override;
   QString highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const final override;
 };
 
 class MyMoneySybaseDriver : public MyMoneyDbDriver
 {
 public:
   MyMoneySybaseDriver() {
   }
 };
 
 class MyMoneySqlite3Driver : public MyMoneyDbDriver
 {
 public:
   MyMoneySqlite3Driver() {
   }
 
   bool isTested() const final override;
   QString forUpdateString() const final override;
   QString intString(const MyMoneyDbIntColumn& c) const final override;
   bool requiresExternalFile() const final override;
   bool requiresCreation() const final override;
   bool isPasswordSupported() const override;
 };
 
 class MyMoneySqlCipher3Driver : public MyMoneySqlite3Driver
 {
 public:
   bool isPasswordSupported() const final override;
 };
 
 //********************* The driver map *********************
 // This function is only used by the GUI types at the moment
 const QMap<QString, QString> MyMoneyDbDriver::driverMap()
 {
   QMap<QString, QString> map;
 
   map["QDB2"] = QString("IBM DB2");
   map["QIBASE"] = QString("Borland Interbase");
   map["QMYSQL"] = QString("MySQL");
   map["QOCI"] = QString("Oracle Call Interface");
   map["QODBC"] = QString("Open Database Connectivity");
   map["QPSQL"] = QString("PostgreSQL v7.3 and up");
   map["QTDS"] = QString("Sybase Adaptive Server and Microsoft SQL Server");
   map["QSQLITE"] = QString("SQLite Version 3");
   map["SQLCIPHER"] = QString("SQLCipher Version 3 (encrypted SQLite)");
   return map;
 }
 
 //********************* The factory *********************
 QExplicitlySharedDataPointer<MyMoneyDbDriver> MyMoneyDbDriver::create(const QString& type)
 {
   if (type == "QDB2")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyDb2Driver());
   else if (type == "QIBASE")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyInterbaseDriver());
   else if (type == "QMYSQL")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyMysqlDriver());
   else if (type == "QOCI")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyOracleDriver());
   else if (type == "QODBC")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyODBCDriver());
   else if (type == "QPSQL")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneyPostgresqlDriver());
   else if (type == "QTDS")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneySybaseDriver());
   else if (type == "QSQLITE")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneySqlite3Driver());
   else if (type == "SQLCIPHER")
     return QExplicitlySharedDataPointer<MyMoneyDbDriver> (new MyMoneySqlCipher3Driver());
-  else throw MYMONEYEXCEPTION(QString("Unknown database driver type").arg(type));
+  else throw MYMONEYEXCEPTION_CSTRING("Unknown database driver type.");
 }
 
 MyMoneyDbDriver::MyMoneyDbDriver()
 {
 }
 
 MyMoneyDbDriver::~MyMoneyDbDriver()
 {
 }
 
 //*******************************************************
 // By default, claim that the driver is not tested
 // For Mysql, Pgsql, and SQLite, return true.
 bool MyMoneyDbDriver::isTested() const
 {
   return false;
 }
 
 bool MyMoneyMysqlDriver::isTested() const
 {
   return true;
 }
 
 bool MyMoneyPostgresqlDriver::isTested() const
 {
   return true;
 }
 
 bool MyMoneySqlite3Driver::isTested() const
 {
   return true;
 }
 
 //*******************************************************
 // By default, claim that the database cannot be created
 // For Mysql and Pgsql, return true.
 bool MyMoneyDbDriver::canAutocreate() const
 {
   return false;
 }
 
 bool MyMoneyMysqlDriver::canAutocreate() const
 {
   return true;
 }
 
 bool MyMoneyPostgresqlDriver::canAutocreate() const
 {
   return true;
 }
 
 //*******************************************************
 // By default, there is no default name
 QString MyMoneyDbDriver::defaultDbName() const
 {
   return "";
 }
 
 // The default db for Mysql is "mysql"
 QString MyMoneyMysqlDriver::defaultDbName() const
 {
   return "mysql";
 }
 
 // The default db for Postgres is "template1"
 QString MyMoneyPostgresqlDriver::defaultDbName() const
 {
   return "template1";
 }
 
 //*******************************************************
 // By default, just attempt to create the database
 // Mysql and Postgres need the character set specified.
 QString MyMoneyDbDriver::createDbString(const QString& name) const
 {
   return QString("CREATE DATABASE %1").arg(name);
 }
 
 QString MyMoneyMysqlDriver::createDbString(const QString& name) const
 {
   return MyMoneyDbDriver::createDbString(name) + " CHARACTER SET 'utf8' COLLATE 'utf8_unicode_ci'";
 }
 
 QString MyMoneyPostgresqlDriver:: createDbString(const QString& name) const
 {
   return MyMoneyDbDriver::createDbString(name) + " WITH ENCODING='UTF8' LC_CTYPE='C' TEMPLATE=template0";
 }
 
 //*******************************************************
 // By default, the DBMS does not require an external file
 // At present, only sqlite does
 bool MyMoneyDbDriver::requiresExternalFile() const
 {
   return false;
 }
 
 bool MyMoneySqlite3Driver::requiresExternalFile() const
 {
   return true;
 }
 
 //*******************************************************
 // By default, the DBMS requires creating before use
 // At present, only sqlite doesn't AFAIK
 bool MyMoneyDbDriver::requiresCreation() const
 {
   return true;
 }
 
 bool MyMoneySqlite3Driver::requiresCreation() const
 {
   return false;
 }
 
 //*******************************************************
 // There is no standard for dropping a primary key.
 // If it is supported, it will have to be implemented for each DBMS
 QString MyMoneyDbDriver::dropPrimaryKeyString(const QString& name) const
 {
   Q_UNUSED(name);
   return "";
 }
 
 QString MyMoneyMysqlDriver::dropPrimaryKeyString(const QString& name) const
 {
   return QString("ALTER TABLE %1 DROP PRIMARY KEY;").arg(name);
 }
 
 QString MyMoneyOracleDriver::dropPrimaryKeyString(const QString& name) const
 {
   return QString("ALTER TABLE %1 DROP PRIMARY KEY;").arg(name);
 }
 
 QString MyMoneyPostgresqlDriver::dropPrimaryKeyString(const QString& name) const
 {
   return QString("ALTER TABLE %1 DROP CONSTRAINT %2_pkey;").arg(name).arg(name);
 }
 
 //*******************************************************
 // There is apparently no standard for dropping an index.
 // If it is supported, it will have to be implemented for each DBMS
 QString MyMoneyDbDriver::dropIndexString(const QString& tableName, const QString& indexName) const
 {
   Q_UNUSED(tableName);
   return QString("DROP INDEX %1;").arg(indexName);
 }
 
 QString MyMoneyMysqlDriver::dropIndexString(const QString& tableName, const QString& indexName) const
 {
   return QString("DROP INDEX %1 ON %2;").arg(indexName).arg(tableName);
 }
 
 //*******************************************************
 // There is no standard for modifying a column
 // If it is supported, it will have to be implemented for each DBMS
 QString MyMoneyDbDriver::modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const
 {
 
   Q_UNUSED(tableName);
   Q_UNUSED(columnName);
   Q_UNUSED(newDef);
 
   return "";
 }
 
 QString MyMoneyMysqlDriver::modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const
 {
   return QString("ALTER TABLE %1 CHANGE %2 %3")
          .arg(tableName)
          .arg(columnName)
          .arg(newDef.generateDDL(QExplicitlySharedDataPointer<MyMoneyDbDriver>(const_cast<MyMoneyMysqlDriver*>(this))));
 }
 
 QString MyMoneyPostgresqlDriver::modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const
 {
   return QString("ALTER TABLE %1 ALTER COLUMN %2 TYPE %3")
          .arg(tableName)
          .arg(columnName)
          .arg(newDef.generateDDL(QExplicitlySharedDataPointer<MyMoneyDbDriver>(const_cast<MyMoneyPostgresqlDriver*>(this))));
 }
 
 QString MyMoneyOracleDriver::modifyColumnString(const QString& tableName, const QString& columnName, const MyMoneyDbColumn& newDef) const
 {
   return QString("ALTER TABLE %1 MODIFY %2 %3")
          .arg(tableName)
          .arg(columnName)
          .arg(newDef.generateDDL(QExplicitlySharedDataPointer<MyMoneyDbDriver>(const_cast<MyMoneyOracleDriver*>(this))));
 }
 
 //*******************************************************
 // Define the integer column types in terms of the standard
 // Each DBMS typically has its own variation of this
 QString MyMoneyDbDriver::intString(const MyMoneyDbIntColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbIntColumn::TINY:
     case MyMoneyDbIntColumn::SMALL:
       qs += " smallint";
       break;
     case MyMoneyDbIntColumn::BIG:
       qs += " bigint";
       break;
     case MyMoneyDbIntColumn::MEDIUM:
     default:
       qs += " int";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
   return qs;
 }
 
 QString MyMoneyMysqlDriver::intString(const MyMoneyDbIntColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbIntColumn::TINY:
       qs += " tinyint";
       break;
     case MyMoneyDbIntColumn::SMALL:
       qs += " smallint";
       break;
     case MyMoneyDbIntColumn::BIG:
       qs += " bigint";
       break;
     case MyMoneyDbIntColumn::MEDIUM:
     default:
       qs += " int";
       break;
   }
 
   if (! c.isSigned()) qs += " unsigned";
 
   if (c.isNotNull()) qs += " NOT NULL";
   return qs;
 }
 
 QString MyMoneySqlite3Driver::intString(const MyMoneyDbIntColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbIntColumn::TINY:
       qs += " tinyint";
       break;
     case MyMoneyDbIntColumn::SMALL:
       qs += " smallint";
       break;
     case MyMoneyDbIntColumn::BIG:
       qs += " bigint";
       break;
     case MyMoneyDbIntColumn::MEDIUM:
     default:
       qs += " int";
       break;
   }
 
   if (! c.isSigned()) qs += " unsigned";
 
   if (c.isNotNull()) qs += " NOT NULL";
   return qs;
 }
 
 QString MyMoneyPostgresqlDriver::intString(const MyMoneyDbIntColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbIntColumn::TINY:
     case MyMoneyDbIntColumn::SMALL:
       qs += " int2";
       break;
     case MyMoneyDbIntColumn::BIG:
       qs += " int8";
       break;
     case MyMoneyDbIntColumn::MEDIUM:
     default:
       qs += " int4";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   if (! c.isSigned()) qs += QString(" check(%1 >= 0)").arg(c.name());
 
   return qs;
 }
 
 QString MyMoneyOracleDriver::intString(const MyMoneyDbIntColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbIntColumn::TINY:
       qs += " number(3)";
       break;
     case MyMoneyDbIntColumn::SMALL:
       qs += " number(5)";
       break;
     case MyMoneyDbIntColumn::BIG:
       qs += " number(20)";
       break;
     case MyMoneyDbIntColumn::MEDIUM:
     default:
       qs += " number(10)";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   if (! c.isSigned()) qs += QString(" check(%1 >= 0)").arg(c.name());
 
   return qs;
 }
 
 //*******************************************************
 // Define the text column types in terms of the standard
 // Each DBMS typically has its own variation of this
 QString MyMoneyDbDriver::textString(const MyMoneyDbTextColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbTextColumn::TINY:
       qs += " tinytext";
       break;
     case MyMoneyDbTextColumn::MEDIUM:
       qs += " mediumtext";
       break;
     case MyMoneyDbTextColumn::LONG:
       qs += " longtext";
       break;
     case MyMoneyDbTextColumn::NORMAL:
     default:
       qs += " text";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 QString MyMoneyDb2Driver::textString(const MyMoneyDbTextColumn& c) const
 {
   QString qs = c.name();
 
   switch (c.type()) {
     case MyMoneyDbTextColumn::TINY:
       qs += " varchar(255)";
       break;
     case MyMoneyDbTextColumn::MEDIUM:
       qs += " clob(16M)";
       break;
     case MyMoneyDbTextColumn::LONG:
       qs += " clob(2G)";
       break;
     case MyMoneyDbTextColumn::NORMAL:
     default:
       qs += " clob(64K)";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 QString MyMoneyOracleDriver::textString(const MyMoneyDbTextColumn& c) const
 {
   QString qs = c.name();
   switch (c.type()) {
     case MyMoneyDbTextColumn::TINY:
       qs += " varchar2(255)";
       break;
     case MyMoneyDbTextColumn::MEDIUM:
     case MyMoneyDbTextColumn::LONG:
     case MyMoneyDbTextColumn::NORMAL:
     default:
       qs += " clob";
       break;
   }
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 QString MyMoneyPostgresqlDriver::textString(const MyMoneyDbTextColumn& c) const
 {
   QString qs = QString("%1 text").arg(c.name());
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 //*******************************************************
 // Define the timestamp column types in terms of the standard
 // Each DBMS typically has its own variation of this
 QString MyMoneyDbDriver::timestampString(const MyMoneyDbDatetimeColumn& c) const
 {
   QString qs = QString("%1 timestamp").arg(c.name());
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 // Mysql has a timestamp type, but datetime is closer to the standard
 QString MyMoneyMysqlDriver::timestampString(const MyMoneyDbDatetimeColumn& c) const
 {
   QString qs = QString("%1 datetime").arg(c.name());
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 QString MyMoneyODBCDriver::timestampString(const MyMoneyDbDatetimeColumn& c) const
 {
   QString qs = QString("%1 datetime").arg(c.name());
 
   if (c.isNotNull()) qs += " NOT NULL";
 
   return qs;
 }
 
 //***********************************************
 // Define the FOR UPDATE string
 // So far, only SQLite requires special handling.
 QString MyMoneyDbDriver::forUpdateString() const
 {
   return " FOR UPDATE";
 }
 
 QString MyMoneySqlite3Driver::forUpdateString() const
 {
   return "";
 }
 
 //***********************************************
 // Define the table option string
 // So far, only mysql requires special handling.
 QString MyMoneyMysqlDriver::tableOptionString() const
 {
   return " ENGINE = InnoDB";
 }
 
 QString MyMoneyDbDriver::tableOptionString() const
 {
   return "";
 }
 
 //***********************************************
 // Define the highestIdNum string
 // PostgreSQL and Oracle return errors when a non-numerical string is cast to an integer, so a regex is used to skip strings that aren't entirely numerical after the prefix is removed
 QString MyMoneyDbDriver::highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const
 {
   return QString("SELECT MAX(CAST(SUBSTR(%1, %2) AS INTEGER)) FROM %3;").arg(tableField).arg(prefixLength + 1).arg(tableName);
 }
 
 QString MyMoneyMysqlDriver::highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const
 {
   return QString("SELECT MAX(CAST(SUBSTR(%1, %2) AS UNSIGNED INTEGER)) FROM %3;").arg(tableField).arg(prefixLength + 1).arg(tableName);
 }
 
 QString MyMoneyPostgresqlDriver::highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const
 {
   return QString("SELECT MAX(CAST(SUBSTR(%1, %2) AS INTEGER)) FROM %3 WHERE SUBSTR(%1, %2) ~ '^[0-9]+$';").arg(tableField).arg(prefixLength + 1).arg(tableName);
 }
 
 QString MyMoneyOracleDriver::highestNumberFromIdString(const QString& tableName, const QString& tableField, const int prefixLength) const
 {
   return QString("SELECT MAX(TO_NUMBER(SUBSTR(%1, %2))) FROM %3 WHERE REGEXP_LIKE(SUBSTR(%1, %2), '^[0-9]+$');").arg(tableField).arg(prefixLength + 1).arg(tableName);
 }
 
 //*************************************************
 // Define
 bool MyMoneyDbDriver::isPasswordSupported() const
 {
   return true;
 }
 
 bool MyMoneySqlite3Driver::isPasswordSupported() const
 {
   return false;
 }
 
 bool MyMoneySqlCipher3Driver::isPasswordSupported() const
 {
   return true;
 }
 
 //*************************************************
 // replace the QSqlDatabase::tables() call for Mysql only
 // see bug 252841
 QStringList MyMoneyDbDriver::tables(QSql::TableType tt, const QSqlDatabase& db) const
 {
   return (db.tables(tt));
 }
 
 QStringList MyMoneyMysqlDriver::tables(QSql::TableType tt, const QSqlDatabase& db) const
 {
   QStringList tableList;
   QSqlQuery q(db);
   QString selectString;
   switch (tt) {
     case QSql::AllTables:
       selectString = QString("SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = '%1'").arg(db.databaseName());
       if (!q.exec(selectString)) {
-        throw MYMONEYEXCEPTION("select names failed in mymoneydbdriver.cpp");
+        throw MYMONEYEXCEPTION_CSTRING("select names failed in mymoneydbdriver.cpp");
       }
       while (q.next())
         tableList.append(q.value(0).toString());
       break;
     case QSql::Tables:
     case QSql::SystemTables:
     case QSql::Views:
       qWarning("Programming error in mymoneydbdriver.cpp"); // KMM only uses AllTables; implement other options if required
   }
 
   return (tableList);
 }
diff --git a/kmymoney/plugins/sql/mymoneystoragesql.cpp b/kmymoney/plugins/sql/mymoneystoragesql.cpp
index fd7e9ba53..073f70422 100644
--- a/kmymoney/plugins/sql/mymoneystoragesql.cpp
+++ b/kmymoney/plugins/sql/mymoneystoragesql.cpp
@@ -1,2836 +1,2836 @@
 /***************************************************************************
                           mymoneystoragesql.cpp
                           ---------------------
     begin                : 11 November 2005
     copyright            : (C) 2005 by Tony Bloomfield
     email                : tonybloom@users.sourceforge.net
                          : Fernando Vilas <fvilas@iname.com>
                          : Christian Dávid <christian-david@web.de>
                          (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "mymoneystoragesql_p.h"
 
 // ----------------------------------------------------------------------------
 // System Includes
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 //************************ Constructor/Destructor *****************************
 MyMoneyStorageSql::MyMoneyStorageSql(MyMoneyStorageMgr *storage, const QUrl &url) :
   QSqlDatabase(QUrlQuery(url).queryItemValue("driver")),
   d_ptr(new MyMoneyStorageSqlPrivate(this))
 {
   Q_D(MyMoneyStorageSql);
   d->m_storage = storage;
 }
 
 MyMoneyStorageSql::~MyMoneyStorageSql()
 {
   try {
     close(true);
-  } catch (const MyMoneyException& e) {
+  } catch (const MyMoneyException &e) {
     qDebug() << "Caught Exception in MMStorageSql dtor: " << e.what();
   }
   Q_D(MyMoneyStorageSql);
   delete d;
 }
 
 uint MyMoneyStorageSql::currentVersion() const
 {
   Q_D(const MyMoneyStorageSql);
   return (d->m_db.currentVersion());
 }
 
 int MyMoneyStorageSql::open(const QUrl &url, int openMode, bool clear)
 {
   Q_D(MyMoneyStorageSql);
   try {
     int rc = 0;
     d->m_driver = MyMoneyDbDriver::create(QUrlQuery(url).queryItemValue("driver"));
     //get the input options
     QStringList options = QUrlQuery(url).queryItemValue("options").split(',');
     d->m_loadAll = true; // force loading whole database into memory since unification of storages
                    // options.contains("loadAll")/*|| m_mode == 0*/;
     d->m_override = options.contains("override");
 
     // create the database connection
     QString dbName = url.path().remove(0, 1);   // remove separator slash
     setDatabaseName(dbName);
     setHostName(url.host());
     setUserName(url.userName());
     setPassword(url.password());
     if (QUrlQuery(url).queryItemValue("driver").contains("QMYSQL")) {
       setConnectOptions("MYSQL_OPT_RECONNECT=1");
     }
     switch (openMode) {
       case QIODevice::ReadOnly:    // OpenDatabase menu entry (or open last file)
       case QIODevice::ReadWrite:   // Save menu entry with database open
         // this may be a sqlite file opened from the recently used list
         // but which no longer exists. In that case, open will work but create an empty file.
         // This is not what the user's after; he may accuse KMM of deleting all his data!
         if (d->m_driver->requiresExternalFile()) {
           if (!d->fileExists(dbName)) {
             rc = 1;
             break;
           }
         }
         if (!QSqlDatabase::open()) {
           d->buildError(QSqlQuery(*this), Q_FUNC_INFO, "opening database");
           rc = 1;
         } else {
           rc = d->createTables(); // check all tables are present, create if not
         }
         break;
       case QIODevice::WriteOnly:   // SaveAs Database - if exists, must be empty, if not will create
         // Try to open the database.
         // If that fails, try to create the database, then try to open it again.
         d->m_newDatabase = true;
         if (!QSqlDatabase::open()) {
           if (!d->createDatabase(url)) {
             rc = 1;
           } else {
             if (!QSqlDatabase::open()) {
               d->buildError(QSqlQuery(*this), Q_FUNC_INFO, "opening new database");
               rc = 1;
             } else {
               rc = d->createTables();
             }
           }
         } else {
           rc = d->createTables();
           if (rc == 0) {
             if (clear) {
               d->clean();
             } else {
               rc = d->isEmpty();
             }
           }
         }
         break;
       default:
         qWarning("%s", qPrintable(QString("%1 - unknown open mode %2").arg(Q_FUNC_INFO).arg(openMode)));
     }
     if (rc != 0) return (rc);
     // bypass logon check if we are creating a database
     if (d->m_newDatabase) return(0);
     // check if the database is locked, if not lock it
     d->readFileInfo();
     if (!d->m_logonUser.isEmpty() && (!d->m_override)) {
       d->m_error = i18n("Database apparently in use\nOpened by %1 on %2 at %3.\nOpen anyway?",
                      d->m_logonUser,
                      d->m_logonAt.date().toString(Qt::ISODate),
                      d->m_logonAt.time().toString("hh.mm.ss"));
       qDebug("%s", qPrintable(d->m_error));
       close(false);
       rc = -1; // retryable error
     } else {
       d->m_logonUser = url.userName() + '@' + url.host();
       d->m_logonAt = QDateTime::currentDateTime();
       d->writeFileInfo();
     }
     return(rc);
   } catch (const QString& s) {
     qDebug("%s", qPrintable(s));
     return (1);
   }
 }
 
 void MyMoneyStorageSql::close(bool logoff)
 {
   Q_D(MyMoneyStorageSql);
   if (QSqlDatabase::isOpen()) {
     if (logoff) {
       MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
       d->m_logonUser.clear();
       d->writeFileInfo();
     }
     QSqlDatabase::close();
     QSqlDatabase::removeDatabase(connectionName());
   }
 }
 
 ulong MyMoneyStorageSql::getRecCount(const QString& table) const
 {
   Q_D(const MyMoneyStorageSql);
   QSqlQuery q(*const_cast <MyMoneyStorageSql*>(this));
   q.prepare(QString("SELECT COUNT(*) FROM %1;").arg(table));
   if ((!q.exec()) || (!q.next())) { // krazy:exclude=crashy
     d->buildError(q, Q_FUNC_INFO, "error retrieving record count");
     qFatal("Error retrieving record count"); // definitely shouldn't happen
   }
   return ((ulong) q.value(0).toULongLong());
 }
 
 //////////////////////////////////////////////////////////////////
 
 bool MyMoneyStorageSql::readFile()
 {
   Q_D(MyMoneyStorageSql);
   d->m_displayStatus = true;
   try {
     d->readFileInfo();
     d->readInstitutions();
     if (d->m_loadAll) {
       readPayees();
     } else {
       QList<QString> user;
       user.append(QString("USER"));
       readPayees(user);
     }
     readTags();
     d->readCurrencies();
     d->readSecurities();
     d->readAccounts();
     if (d->m_loadAll) {
       d->readTransactions();
     } else {
       if (d->m_preferred.filterSet().singleFilter.accountFilter) readTransactions(d->m_preferred);
     }
     d->readSchedules();
     d->readPrices();
     d->readReports();
     d->readBudgets();
     //FIXME - ?? if (m_mode == 0)
     //m_storage->rebuildAccountBalances();
     // this seems to be nonsense, but it clears the dirty flag
     // as a side-effect.
     d->m_storage->setLastModificationDate(d->m_storage->lastModificationDate());
     // FIXME?? if (m_mode == 0) m_storage = NULL;
     // make sure the progress bar is not shown any longer
     d->signalProgress(-1, -1);
     d->m_displayStatus = false;
     //MyMoneySqlQuery::traceOn();
     return true;
   } catch (const QString &) {
     return false;
   }
   // this seems to be nonsense, but it clears the dirty flag
   // as a side-effect.
 }
 
 // The following is called from 'SaveAsDatabase'
 bool MyMoneyStorageSql::writeFile()
 {
   Q_D(MyMoneyStorageSql);
   // initialize record counts and hi ids
   d->m_institutions = d->m_accounts = d->m_payees = d->m_tags = d->m_transactions = d->m_splits
                                 = d->m_securities = d->m_prices = d->m_currencies = d->m_schedules  = d->m_reports = d->m_kvps = d->m_budgets = 0;
   d->m_hiIdInstitutions = d->m_hiIdPayees = d->m_hiIdTags = d->m_hiIdAccounts = d->m_hiIdTransactions =
                                         d->m_hiIdSchedules = d->m_hiIdSecurities = d->m_hiIdReports = d->m_hiIdBudgets = 0;
   d->m_onlineJobs = d->m_payeeIdentifier = 0;
   d->m_displayStatus = true;
   try {
     MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
     d->writeInstitutions();
     d->writePayees();
     d->writeTags();
     d->writeAccounts();
     d->writeTransactions();
     d->writeSchedules();
     d->writeSecurities();
     d->writePrices();
     d->writeCurrencies();
     d->writeReports();
     d->writeBudgets();
     d->writeOnlineJobs();
     d->writeFileInfo();
     // this seems to be nonsense, but it clears the dirty flag
     // as a side-effect.
     //m_storage->setLastModificationDate(m_storage->lastModificationDate());
     // FIXME?? if (m_mode == 0) m_storage = NULL;
 
     // make sure the progress bar is not shown any longer
     d->signalProgress(-1, -1);
     d->m_displayStatus = false;
     // this seems to be nonsense, but it clears the dirty flag
     // as a side-effect.
     d->m_storage->setLastModificationDate(d->m_storage->lastModificationDate());
     return true;
   } catch (const QString &) {
     return false;
   }
 }
 
 QString MyMoneyStorageSql::lastError() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->m_error;
 }
 
 // --------------- SQL Transaction (commit unit) handling -----------------------------------
 void MyMoneyStorageSql::startCommitUnit(const QString& callingFunction)
 {
   Q_D(MyMoneyStorageSql);
   if (d->m_commitUnitStack.isEmpty()) {
-    if (!transaction()) throw MYMONEYEXCEPTION(d->buildError(QSqlQuery(), callingFunction, "starting commit unit") + ' ' + callingFunction);
+    if (!transaction()) throw MYMONEYEXCEPTION(d->buildError(QSqlQuery(), callingFunction, "starting commit unit"));
   }
   d->m_commitUnitStack.push(callingFunction);
 }
 
 bool MyMoneyStorageSql::endCommitUnit(const QString& callingFunction)
 {
   Q_D(MyMoneyStorageSql);
   // for now, we don't know if there were any changes made to the data so
   // we expect the data to have changed. This assumption causes some unnecessary
   // repaints of the UI here and there, but for now it's ok. If we can determine
   // that the commit() really changes the data, we can return that information
   // as value of this method.
   bool rc = true;
   if (d->m_commitUnitStack.isEmpty()) {
-    throw MYMONEYEXCEPTION("Empty commit unit stack while trying to commit");
+    throw MYMONEYEXCEPTION_CSTRING("Empty commit unit stack while trying to commit");
   }
 
   if (callingFunction != d->m_commitUnitStack.top())
     qDebug("%s", qPrintable(QString("%1 - %2 s/be %3").arg(Q_FUNC_INFO).arg(callingFunction).arg(d->m_commitUnitStack.top())));
   d->m_commitUnitStack.pop();
   if (d->m_commitUnitStack.isEmpty()) {
     //qDebug() << "Committing with " << QSqlQuery::refCount() << " queries";
     if (!commit()) throw MYMONEYEXCEPTION(d->buildError(QSqlQuery(), callingFunction, "ending commit unit"));
   }
   return rc;
 }
 
 void MyMoneyStorageSql::cancelCommitUnit(const QString& callingFunction)
 {
   Q_D(MyMoneyStorageSql);
   if (d->m_commitUnitStack.isEmpty()) return;
   if (callingFunction != d->m_commitUnitStack.top())
     qDebug("%s", qPrintable(QString("%1 - %2 s/be %3").arg(Q_FUNC_INFO).arg(callingFunction).arg(d->m_commitUnitStack.top())));
   d->m_commitUnitStack.clear();
   if (!rollback()) throw MYMONEYEXCEPTION(d->buildError(QSqlQuery(), callingFunction, "cancelling commit unit") + ' ' + callingFunction);
 }
 
 /////////////////////////////////////////////////////////////////////
 void MyMoneyStorageSql::fillStorage()
 {
   Q_D(MyMoneyStorageSql);
 //  if (!m_transactionListRead)  // make sure we have loaded everything
   d->readTransactions();
 //  if (!m_payeeListRead)
   readPayees();
 }
 
 //------------------------------ Write SQL routines ----------------------------------------
 // **** Institutions ****
 
 
 void MyMoneyStorageSql::addInstitution(const MyMoneyInstitution& inst)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmInstitutions"].insertString());
   QList<MyMoneyInstitution> iList;
   iList << inst;
   d->writeInstitutionList(iList , q);
   ++d->m_institutions;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyInstitution(const MyMoneyInstitution& inst)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmInstitutions"].updateString());
   QVariantList kvpList;
   kvpList << inst.id();
   d->deleteKeyValuePairs("OFXSETTINGS", kvpList);
   QList<MyMoneyInstitution> iList;
   iList << inst;
   d->writeInstitutionList(iList , q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeInstitution(const MyMoneyInstitution& inst)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QVariantList kvpList;
   kvpList << inst.id();
   d->deleteKeyValuePairs("OFXSETTINGS", kvpList);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmInstitutions"].deleteString());
-  q.bindValue(":id", inst.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting  Institution"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmInstitutions"].deleteString());
+  query.bindValue(":id", inst.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting  Institution")); // krazy:exclude=crashy
   --d->m_institutions;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::addPayee(const MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmPayees"].insertString());
-  d->writePayee(payee, q);
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmPayees"].insertString());
+  d->writePayee(payee, query);
   ++d->m_payees;
 
   QVariantList identIds;
   QList<payeeIdentifier> idents = payee.payeeIdentifiers();
   // Store ids which have to be stored in the map table
   identIds.reserve(idents.count());
   foreach (payeeIdentifier ident, idents) {
       try {
         // note: this changes ident
         addPayeeIdentifier(ident);
       identIds.append(ident.idString());
-    } catch (payeeIdentifier::empty&) {
+    } catch (const payeeIdentifier::empty &) {
       }
   }
 
   if (!identIds.isEmpty()) {
     // Create lists for batch processing
     QVariantList order;
     QVariantList payeeIdList;
     order.reserve(identIds.size());
     payeeIdList.reserve(identIds.size());
 
     for (int i = 0; i < identIds.size(); ++i) {
       order << i;
       payeeIdList << payee.id();
     }
-    q.prepare("INSERT INTO kmmPayeesPayeeIdentifier (payeeId, identifierId, userOrder) VALUES(?, ?, ?)");
-    q.bindValue(0, payeeIdList);
-    q.bindValue(1, identIds);
-    q.bindValue(2, order);
-    if (!q.execBatch())
-      throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("writing payee's identifiers"))); // krazy:exclude=crashy
+    query.prepare("INSERT INTO kmmPayeesPayeeIdentifier (payeeId, identifierId, userOrder) VALUES(?, ?, ?)");
+    query.bindValue(0, payeeIdList);
+    query.bindValue(1, identIds);
+    query.bindValue(2, order);
+    if (!query.execBatch())
+      throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("writing payee's identifiers")); // krazy:exclude=crashy
   }
 
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyPayee(MyMoneyPayee payee)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmPayees"].updateString());
-  d->writePayee(payee, q);
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmPayees"].updateString());
+  d->writePayee(payee, query);
 
   // Get a list of old identifiers first
-  q.prepare("SELECT identifierId FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
-  q.bindValue(0, payee.id());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("modifying payee's identifiers (getting old values failed)"))); // krazy:exclude=crashy
+  query.prepare("SELECT identifierId FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
+  query.bindValue(0, payee.id());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("modifying payee's identifiers (getting old values failed)")); // krazy:exclude=crashy
 
   QStringList oldIdentIds;
-  oldIdentIds.reserve(q.numRowsAffected());
-  while (q.next())
-    oldIdentIds << q.value(0).toString();
+  oldIdentIds.reserve(query.numRowsAffected());
+  while (query.next())
+    oldIdentIds << query.value(0).toString();
 
   // Add new and modify old payeeIdentifiers
   foreach (payeeIdentifier ident, payee.payeeIdentifiers()) {
     if (ident.idString().isEmpty()) {
       payeeIdentifier oldIdent(ident);
       addPayeeIdentifier(ident);
       // addPayeeIdentifier could fail (throws an exception then) only remove old
       // identifier if new one is stored correctly
       payee.removePayeeIdentifier(oldIdent);
       payee.addPayeeIdentifier(ident);
     } else {
       modifyPayeeIdentifier(ident);
       payee.modifyPayeeIdentifier(ident);
       oldIdentIds.removeAll(ident.idString());
     }
   }
 
   // Remove identifiers which are not used anymore
   foreach (QString idToRemove, oldIdentIds) {
     payeeIdentifier ident(fetchPayeeIdentifier(idToRemove));
     removePayeeIdentifier(ident);
   }
 
   // Update relation table
-  q.prepare("DELETE FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
-  q.bindValue(0, payee.id());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("modifying payee's identifiers (delete from mapping table)"))); // krazy:exclude=crashy
+  query.prepare("DELETE FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
+  query.bindValue(0, payee.id());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("modifying payee's identifiers (delete from mapping table)")); // krazy:exclude=crashy
 
   // Get list again because modifiyPayeeIdentifier which is used above may change the id
   QList<payeeIdentifier> idents(payee.payeeIdentifiers());
 
   QVariantList order;
   QVariantList payeeIdList;
   QVariantList identIdList;
   order.reserve(idents.size());
   payeeIdList.reserve(idents.size());
   identIdList.reserve(idents.size());
 
   {
     QList<payeeIdentifier>::const_iterator end = idents.constEnd();
     int i = 0;
     for (QList<payeeIdentifier>::const_iterator iter = idents.constBegin(); iter != end; ++iter, ++i) {
       order << i;
       payeeIdList << payee.id();
       identIdList << iter->idString();
     }
   }
 
-  q.prepare("INSERT INTO kmmPayeesPayeeIdentifier (payeeId, userOrder, identifierId) VALUES(?, ?, ?)");
-  q.bindValue(0, payeeIdList);
-  q.bindValue(1, order);
-  q.bindValue(2, identIdList);
-  if (!q.execBatch())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("writing payee's identifiers during modify"))); // krazy:exclude=crashy
+  query.prepare("INSERT INTO kmmPayeesPayeeIdentifier (payeeId, userOrder, identifierId) VALUES(?, ?, ?)");
+  query.bindValue(0, payeeIdList);
+  query.bindValue(1, order);
+  query.bindValue(2, identIdList);
+  if (!query.execBatch())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("writing payee's identifiers during modify")); // krazy:exclude=crashy
 
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyUserInfo(const MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmPayees"].updateString());
   d->writePayee(payee, q, true);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removePayee(const MyMoneyPayee& payee)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
+  QSqlQuery query(*this);
 
   // Get identifiers first so we know which to delete
-  q.prepare("SELECT identifierId FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
-  q.bindValue(0, payee.id());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("removing payee's identifiers (getting old values failed)"))); // krazy:exclude=crashy
+  query.prepare("SELECT identifierId FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
+  query.bindValue(0, payee.id());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("removing payee's identifiers (getting old values failed)")); // krazy:exclude=crashy
 
   QStringList identIds;
-  while (q.next())
-    identIds << q.value(0).toString();
+  while (query.next())
+    identIds << query.value(0).toString();
 
   QMap<QString, payeeIdentifier> idents = fetchPayeeIdentifiers(identIds);
   foreach (payeeIdentifier ident, idents) {
     removePayeeIdentifier(ident);
   }
 
   // Delete entries from mapping table
-  q.prepare("DELETE FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
-  q.bindValue(0, payee.id());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("removing payee's identifiers (delete from mapping table)"))); // krazy:exclude=crashy
+  query.prepare("DELETE FROM kmmPayeesPayeeIdentifier WHERE payeeId = ?");
+  query.bindValue(0, payee.id());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("removing payee's identifiers (delete from mapping table)")); // krazy:exclude=crashy
 
   // Delete payee
-  q.prepare(d->m_db.m_tables["kmmPayees"].deleteString());
-  q.bindValue(":id", payee.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting  Payee"))); // krazy:exclude=crashy
+  query.prepare(d->m_db.m_tables["kmmPayees"].deleteString());
+  query.bindValue(":id", payee.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting  Payee")); // krazy:exclude=crashy
   --d->m_payees;
 
   d->writeFileInfo();
 }
 
 // **** Tags ****
 void MyMoneyStorageSql::addTag(const MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmTags"].insertString());
   d->writeTag(tag, q);
   ++d->m_tags;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyTag(const MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmTags"].updateString());
   d->writeTag(tag, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeTag(const MyMoneyTag& tag)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmTags"].deleteString());
-  q.bindValue(":id", tag.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting  Tag"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmTags"].deleteString());
+  query.bindValue(":id", tag.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting  Tag")); // krazy:exclude=crashy
   --d->m_tags;
   d->writeFileInfo();
 }
 
 // **** Accounts ****
 void MyMoneyStorageSql::addAccount(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmAccounts"].insertString());
   QList<MyMoneyAccount> aList;
   aList << acc;
   d->writeAccountList(aList, q);
   ++d->m_accounts;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyAccount(const MyMoneyAccount& acc)
 {
   QList<MyMoneyAccount> aList;
   aList << acc;
   modifyAccountList(aList);
 }
 
 void MyMoneyStorageSql::modifyAccountList(const QList<MyMoneyAccount>& acc)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmAccounts"].updateString());
   QVariantList kvpList;
   foreach (const MyMoneyAccount& a, acc) {
     kvpList << a.id();
   }
   d->deleteKeyValuePairs("ACCOUNT", kvpList);
   d->deleteKeyValuePairs("ONLINEBANKING", kvpList);
   d->writeAccountList(acc, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeAccount(const MyMoneyAccount& acc)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QVariantList kvpList;
   kvpList << acc.id();
   d->deleteKeyValuePairs("ACCOUNT", kvpList);
   d->deleteKeyValuePairs("ONLINEBANKING", kvpList);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmAccounts"].deleteString());
-  q.bindValue(":id", acc.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Account"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmAccounts"].deleteString());
+  query.bindValue(":id", acc.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Account")); // krazy:exclude=crashy
   --d->m_accounts;
   d->writeFileInfo();
 }
 
 
 // **** Transactions and Splits ****
 void MyMoneyStorageSql::addTransaction(const MyMoneyTransaction& tx)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   // add the transaction and splits
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmTransactions"].insertString());
   d->writeTransaction(tx.id(), tx, q, "N");
   ++d->m_transactions;
   QList<MyMoneyAccount> aList;
   // for each split account, update lastMod date, balance, txCount
   foreach (const MyMoneySplit& it_s, tx.splits()) {
     MyMoneyAccount acc = d->m_storage->account(it_s.accountId());
     ++d->m_transactionCountMap[acc.id()];
     aList << acc;
   }
   modifyAccountList(aList);
   // in the fileinfo record, update lastMod, txCount, next TxId
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyTransaction(const MyMoneyTransaction& tx)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   // remove the splits of the old tx from the count table
-  QSqlQuery q(*this);
-  q.prepare("SELECT accountId FROM kmmSplits WHERE transactionId = :txId;");
-  q.bindValue(":txId", tx.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, "retrieving old splits"));
-  while (q.next()) {
-    QString id = q.value(0).toString();
+  QSqlQuery query(*this);
+  query.prepare("SELECT accountId FROM kmmSplits WHERE transactionId = :txId;");
+  query.bindValue(":txId", tx.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("retrieving old splits"));
+  while (query.next()) {
+    QString id = query.value(0).toString();
     --d->m_transactionCountMap[id];
   }
   // add the transaction and splits
-  q.prepare(d->m_db.m_tables["kmmTransactions"].updateString());
-  d->writeTransaction(tx.id(), tx, q, "N");
+  query.prepare(d->m_db.m_tables["kmmTransactions"].updateString());
+  d->writeTransaction(tx.id(), tx, query, "N");
   QList<MyMoneyAccount> aList;
   // for each split account, update lastMod date, balance, txCount
   foreach (const MyMoneySplit& it_s, tx.splits()) {
     MyMoneyAccount acc = d->m_storage->account(it_s.accountId());
     ++d->m_transactionCountMap[acc.id()];
     aList << acc;
   }
   modifyAccountList(aList);
   //writeSplits(tx.id(), "N", tx.splits());
   // in the fileinfo record, update lastMod
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeTransaction(const MyMoneyTransaction& tx)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   d->deleteTransaction(tx.id());
   --d->m_transactions;
 
   QList<MyMoneyAccount> aList;
   // for each split account, update lastMod date, balance, txCount
   foreach (const MyMoneySplit& it_s, tx.splits()) {
     MyMoneyAccount acc = d->m_storage->account(it_s.accountId());
     --d->m_transactionCountMap[acc.id()];
     aList << acc;
   }
   modifyAccountList(aList);
   // in the fileinfo record, update lastModDate, txCount
   d->writeFileInfo();
 }
 
 // **** Schedules ****
 
 void MyMoneyStorageSql::addSchedule(const MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmSchedules"].insertString());
   d->writeSchedule(sched, q, true);
   ++d->m_schedules;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifySchedule(const MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmSchedules"].updateString());
   d->writeSchedule(sched, q, false);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeSchedule(const MyMoneySchedule& sched)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   d->deleteSchedule(sched.id());
   --d->m_schedules;
   d->writeFileInfo();
 }
 
 // **** Securities ****
 void MyMoneyStorageSql::addSecurity(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmSecurities"].insertString());
   d->writeSecurity(sec, q);
   ++d->m_securities;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifySecurity(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QVariantList kvpList;
   kvpList << sec.id();
   d->deleteKeyValuePairs("SECURITY", kvpList);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmSecurities"].updateString());
   d->writeSecurity(sec, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeSecurity(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QVariantList kvpList;
   kvpList << sec.id();
   d->deleteKeyValuePairs("SECURITY", kvpList);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmSecurities"].deleteString());
-  q.bindValue(":id", kvpList);
-  if (!q.execBatch()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Security")));
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmSecurities"].deleteString());
+  query.bindValue(":id", kvpList);
+  if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Security"));
   --d->m_securities;
   d->writeFileInfo();
 }
 
 // **** Prices ****
 void MyMoneyStorageSql::addPrice(const MyMoneyPrice& p)
 {
   Q_D(MyMoneyStorageSql);
   if (d->m_readingPrices) return;
   // the app always calls addPrice, whether or not there is already one there
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   bool newRecord = false;
-  QSqlQuery q(*this);
+  QSqlQuery query(*this);
   QString s = d->m_db.m_tables["kmmPrices"].selectAllString(false);
   s += " WHERE fromId = :fromId AND toId = :toId AND priceDate = :priceDate;";
-  q.prepare(s);
-  q.bindValue(":fromId", p.from());
-  q.bindValue(":toId", p.to());
-  q.bindValue(":priceDate", p.date().toString(Qt::ISODate));
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("finding Price"))); // krazy:exclude=crashy
-  if (q.next()) {
-    q.prepare(d->m_db.m_tables["kmmPrices"].updateString());
+  query.prepare(s);
+  query.bindValue(":fromId", p.from());
+  query.bindValue(":toId", p.to());
+  query.bindValue(":priceDate", p.date().toString(Qt::ISODate));
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("finding Price")); // krazy:exclude=crashy
+  if (query.next()) {
+    query.prepare(d->m_db.m_tables["kmmPrices"].updateString());
   } else {
-    q.prepare(d->m_db.m_tables["kmmPrices"].insertString());
+    query.prepare(d->m_db.m_tables["kmmPrices"].insertString());
     ++d->m_prices;
     newRecord = true;
   }
-  q.bindValue(":fromId", p.from());
-  q.bindValue(":toId", p.to());
-  q.bindValue(":priceDate", p.date().toString(Qt::ISODate));
-  q.bindValue(":price", p.rate(QString()).toString());
+  query.bindValue(":fromId", p.from());
+  query.bindValue(":toId", p.to());
+  query.bindValue(":priceDate", p.date().toString(Qt::ISODate));
+  query.bindValue(":price", p.rate(QString()).toString());
   const MyMoneySecurity sec = d->m_storage->security(p.to());
-  q.bindValue(":priceFormatted",
+  query.bindValue(":priceFormatted",
               p.rate(QString()).formatMoney("", sec.pricePrecision()));
-  q.bindValue(":priceSource", p.source());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("writing Price"))); // krazy:exclude=crashy
+  query.bindValue(":priceSource", p.source());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("writing Price")); // krazy:exclude=crashy
 
   if (newRecord) d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removePrice(const MyMoneyPrice& p)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmPrices"].deleteString());
-  q.bindValue(":fromId", p.from());
-  q.bindValue(":toId", p.to());
-  q.bindValue(":priceDate", p.date().toString(Qt::ISODate));
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Price"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmPrices"].deleteString());
+  query.bindValue(":fromId", p.from());
+  query.bindValue(":toId", p.to());
+  query.bindValue(":priceDate", p.date().toString(Qt::ISODate));
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Price")); // krazy:exclude=crashy
   --d->m_prices;
   d->writeFileInfo();
 }
 
 // **** Currencies ****
 void MyMoneyStorageSql::addCurrency(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmCurrencies"].insertString());
   d->writeCurrency(sec, q);
   ++d->m_currencies;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyCurrency(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmCurrencies"].updateString());
   d->writeCurrency(sec, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeCurrency(const MyMoneySecurity& sec)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmCurrencies"].deleteString());
-  q.bindValue(":ISOcode", sec.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Currency"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmCurrencies"].deleteString());
+  query.bindValue(":ISOcode", sec.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Currency")); // krazy:exclude=crashy
   --d->m_currencies;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::addReport(const MyMoneyReport& rep)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmReportConfig"].insertString());
   d->writeReport(rep, q);
   ++d->m_reports;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyReport(const MyMoneyReport& rep)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmReportConfig"].updateString());
   d->writeReport(rep, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeReport(const MyMoneyReport& rep)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare("DELETE FROM kmmReportConfig WHERE id = :id");
-  q.bindValue(":id", rep.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Report"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare("DELETE FROM kmmReportConfig WHERE id = :id");
+  query.bindValue(":id", rep.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Report")); // krazy:exclude=crashy
   --d->m_reports;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::addBudget(const MyMoneyBudget& bud)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmBudgetConfig"].insertString());
   d->writeBudget(bud, q);
   ++d->m_budgets;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::modifyBudget(const MyMoneyBudget& bud)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery q(*this);
   q.prepare(d->m_db.m_tables["kmmBudgetConfig"].updateString());
   d->writeBudget(bud, q);
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::removeBudget(const MyMoneyBudget& bud)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmBudgetConfig"].deleteString());
-  q.bindValue(":id", bud.id());
-  if (!q.exec()) throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting Budget"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmBudgetConfig"].deleteString());
+  query.bindValue(":id", bud.id());
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting Budget")); // krazy:exclude=crashy
   --d->m_budgets;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::addOnlineJob(const onlineJob& job)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
-  QSqlQuery q(*this);
-  q.prepare("INSERT INTO kmmOnlineJobs (id, type, jobSend, bankAnswerDate, state, locked) VALUES(:id, :type, :jobSend, :bankAnswerDate, :state, :locked);");
-  d->writeOnlineJob(job, q);
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("writing onlineJob"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare("INSERT INTO kmmOnlineJobs (id, type, jobSend, bankAnswerDate, state, locked) VALUES(:id, :type, :jobSend, :bankAnswerDate, :state, :locked);");
+  d->writeOnlineJob(job, query);
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("writing onlineJob")); // krazy:exclude=crashy
   ++d->m_onlineJobs;
 
   try {
     // Save online task
     d->insertStorableObject(*job.constTask(), job.id());
   } catch (onlineJob::emptyTask&) {
   }
 }
 
 void MyMoneyStorageSql::modifyOnlineJob(const onlineJob& job)
 {
   Q_D(MyMoneyStorageSql);
   Q_ASSERT(!job.id().isEmpty());
 
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
   QSqlQuery query(*this);
   query.prepare(QLatin1String(
     "UPDATE kmmOnlineJobs SET "
     " type = :type, "
     " jobSend = :jobSend, "
     " bankAnswerDate = :bankAnswerDate, "
     " state = :state, "
     " locked = :locked "
     " WHERE id = :id"
   ));
 
   d->writeOnlineJob(job, query);
   if (!query.exec())
-    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("writing onlineJob"))); // krazy:exclude=crashy
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("writing onlineJob")); // krazy:exclude=crashy
 
   try {
     // Modify online task
     d->updateStorableObject(*job.constTask(), job.id());
   } catch (onlineJob::emptyTask&) {
     // If there is no task attached this is fine as well
   }
 }
 
 void MyMoneyStorageSql::removeOnlineJob(const onlineJob& job)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
 
   // Remove onlineTask first, because it could have a contraint
   // which could block the removal of the onlineJob
 
   try {
     // Remove task
     d->deleteStorableObject(*job.constTask(), job.id());
   } catch (onlineJob::emptyTask&) {
   }
 
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmOnlineJobs"].deleteString());
-  q.bindValue(":id", job.id());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting onlineJob"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmOnlineJobs"].deleteString());
+  query.bindValue(":id", job.id());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting onlineJob")); // krazy:exclude=crashy
   --d->m_onlineJobs;
 }
 
 void MyMoneyStorageSql::addPayeeIdentifier(payeeIdentifier& ident)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
 
   ident = payeeIdentifier(incrementPayeeIdentfierId(), ident);
 
   QSqlQuery q(*this);
   q.prepare("INSERT INTO kmmPayeeIdentifier (id, type) VALUES(:id, :type)");
   d->writePayeeIdentifier(ident, q);
   ++d->m_payeeIdentifier;
 
   try {
     d->insertStorableObject(*ident.data(), ident.idString());
-  } catch (payeeIdentifier::empty&) {
+  } catch (const payeeIdentifier::empty &) {
   }
 }
 
 void MyMoneyStorageSql::modifyPayeeIdentifier(const payeeIdentifier& ident)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
 
-  QSqlQuery q(*this);
-  q.prepare("SELECT type FROM kmmPayeeIdentifier WHERE id = ?");
-  q.bindValue(0, ident.idString());
-  if (!q.exec() || !q.next())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("modifying payeeIdentifier"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare("SELECT type FROM kmmPayeeIdentifier WHERE id = ?");
+  query.bindValue(0, ident.idString());
+  if (!query.exec() || !query.next())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("modifying payeeIdentifier")); // krazy:exclude=crashy
 
-  bool typeChanged = (q.value(0).toString() != ident.iid());
+  bool typeChanged = (query.value(0).toString() != ident.iid());
 
   if (typeChanged) {
     // Delete old identifier if type changed
     const payeeIdentifier oldIdent(fetchPayeeIdentifier(ident.idString()));
     try {
       d->deleteStorableObject(*oldIdent.data(), ident.idString());
-    } catch (payeeIdentifier::empty&) {
+    } catch (const payeeIdentifier::empty &) {
       // Note: this should not happen because the ui does not offer a way to change
       // the type of an payeeIdentifier if it was not correctly loaded.
-      throw MYMONEYEXCEPTION(QLatin1String("Could not modify payeeIdentifier '")
+      throw MYMONEYEXCEPTION((QString::fromLatin1("Could not modify payeeIdentifier '")
         + ident.idString()
-        + QLatin1String("' because type changed and could not remove identifier of old type. Maybe a plugin is missing?")
+        + QLatin1String("' because type changed and could not remove identifier of old type. Maybe a plugin is missing?"))
       ); // krazy:exclude=crashy
     }
   }
 
-  q.prepare("UPDATE kmmPayeeIdentifier SET type = :type WHERE id = :id");
-  d->writePayeeIdentifier(ident, q);
+  query.prepare("UPDATE kmmPayeeIdentifier SET type = :type WHERE id = :id");
+  d->writePayeeIdentifier(ident, query);
 
   try {
     if (typeChanged)
       d->insertStorableObject(*ident.data(), ident.idString());
     else
       d->updateStorableObject(*ident.data(), ident.idString());
-  } catch (payeeIdentifier::empty&) {
+  } catch (const payeeIdentifier::empty &) {
   }
 }
 
 void MyMoneyStorageSql::removePayeeIdentifier(const payeeIdentifier& ident)
 {
   Q_D(MyMoneyStorageSql);
   MyMoneyDbTransaction t(*this, Q_FUNC_INFO);
 
   // Remove first, the table could have a contraint which prevents removal
   // of row in kmmPayeeIdentifier
   try {
     d->deleteStorableObject(*ident.data(), ident.idString());
-  } catch (payeeIdentifier::empty&) {
+  } catch (const payeeIdentifier::empty &) {
   }
 
-  QSqlQuery q(*this);
-  q.prepare(d->m_db.m_tables["kmmPayeeIdentifier"].deleteString());
-  q.bindValue(":id", ident.idString());
-  if (!q.exec())
-    throw MYMONEYEXCEPTION(d->buildError(q, Q_FUNC_INFO, QString("deleting payeeIdentifier"))); // krazy:exclude=crashy
+  QSqlQuery query(*this);
+  query.prepare(d->m_db.m_tables["kmmPayeeIdentifier"].deleteString());
+  query.bindValue(":id", ident.idString());
+  if (!query.exec())
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("deleting payeeIdentifier")); // krazy:exclude=crashy
   --d->m_payeeIdentifier;
 }
 
 // **** Key/value pairs ****
 
 //******************************** read SQL routines **************************************
 
 /*void MyMoneyStorageSql::setVersion (const QString& version)
 {
   m_dbVersion = version.section('.', 0, 0).toUInt();
   m_minorVersion = version.section('.', 1, 1).toUInt();
   // Okay, I made a cockup by forgetting to include a fixversion in the database
   // design, so we'll use the minor version as fix level (similar to VERSION
   // and FIXVERSION in XML file format). A second mistake was setting minor version to 1
   // in the first place, so we need to subtract one on reading and add one on writing (sigh)!!
   m_storage->setFileFixVersion( m_minorVersion - 1);
 }*/
 
 
 QMap<QString, MyMoneyInstitution> MyMoneyStorageSql::fetchInstitutions(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int institutionsNb = (idList.isEmpty() ? d->m_institutions : idList.size());
   d->signalProgress(0, institutionsNb, QObject::tr("Loading institutions..."));
   int progress = 0;
   QMap<QString, MyMoneyInstitution> iList;
   ulong lastId = 0;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmInstitutions"];
   QSqlQuery sq(*const_cast <MyMoneyStorageSql*>(this));
   sq.prepare("SELECT id from kmmAccounts where institutionId = :id");
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QString queryString(t.selectAllString(false));
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   if (! idList.empty()) {
     queryString += " WHERE";
     for (int i = 0; i < idList.count(); ++i)
       queryString += QString(" id = :id%1 OR").arg(i);
     queryString = queryString.left(queryString.length() - 2);
   }
   if (forUpdate)
     queryString += d->m_driver->forUpdateString();
 
   queryString += ';';
 
   query.prepare(queryString);
 
   if (! idList.empty()) {
     QStringList::ConstIterator bindVal = idList.constBegin();
     for (int i = 0; bindVal != idList.constEnd(); ++i, ++bindVal) {
       query.bindValue(QString(":id%1").arg(i), *bindVal);
     }
   }
 
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Institution"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString::fromLatin1("reading Institution"))); // krazy:exclude=crashy
   int idCol = t.fieldNumber("id");
   int nameCol = t.fieldNumber("name");
   int managerCol = t.fieldNumber("manager");
   int routingCodeCol = t.fieldNumber("routingCode");
   int addressStreetCol = t.fieldNumber("addressStreet");
   int addressCityCol = t.fieldNumber("addressCity");
   int addressZipcodeCol = t.fieldNumber("addressZipcode");
   int telephoneCol = t.fieldNumber("telephone");
 
   while (query.next()) {
     MyMoneyInstitution inst;
     QString iid = GETSTRING(idCol);
     inst.setName(GETSTRING(nameCol));
     inst.setManager(GETSTRING(managerCol));
     inst.setSortcode(GETSTRING(routingCodeCol));
     inst.setStreet(GETSTRING(addressStreetCol));
     inst.setCity(GETSTRING(addressCityCol));
     inst.setPostcode(GETSTRING(addressZipcodeCol));
     inst.setTelephone(GETSTRING(telephoneCol));
     // get list of subaccounts
     sq.bindValue(":id", iid);
-    if (!sq.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Institution AccountList"))); // krazy:exclude=crashy
+    if (!sq.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Institution AccountList")); // krazy:exclude=crashy
     QStringList aList;
     while (sq.next()) aList.append(sq.value(0).toString());
     foreach (const QString& it, aList)
     inst.addAccountId(it);
 
     iList[iid] = MyMoneyInstitution(iid, inst);
     ulong id = MyMoneyUtils::extractId(iid);
     if (id > lastId)
       lastId = id;
 
     d->signalProgress(++progress, 0);
   }
   return iList;
 }
 
 QMap<QString, MyMoneyInstitution> MyMoneyStorageSql::fetchInstitutions() const
 {
   return fetchInstitutions(QStringList(), false);
 }
 
 void MyMoneyStorageSql::readPayees(const QString& id)
 {
   QList<QString> list;
   list.append(id);
   readPayees(list);
 }
 
 void MyMoneyStorageSql::readPayees(const QList<QString>& pid)
 {
   Q_D(MyMoneyStorageSql);
   try {
     d->m_storage->loadPayees(fetchPayees(pid));
   } catch (const MyMoneyException &) {
   }
 //  if (pid.isEmpty()) m_payeeListRead = true;
 }
 
 void MyMoneyStorageSql::readPayees()
 {
   readPayees(QList<QString>());
 }
 
 QMap<QString, MyMoneyPayee> MyMoneyStorageSql::fetchPayees(const QStringList& idList, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
   MyMoneyDbTransaction trans(const_cast <MyMoneyStorageSql&>(*this), Q_FUNC_INFO);
   if (d->m_displayStatus) {
     int payeesNb = (idList.isEmpty() ? d->m_payees : idList.size());
     d->signalProgress(0, payeesNb, QObject::tr("Loading payees..."));
   }
 
   int progress = 0;
   QMap<QString, MyMoneyPayee> pList;
 
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QString queryString = QLatin1String("SELECT kmmPayees.id AS id, kmmPayees.name AS name, kmmPayees.reference AS reference, "
     " kmmPayees.email AS email, kmmPayees.addressStreet AS addressStreet, kmmPayees.addressCity AS addressCity, kmmPayees.addressZipcode AS addressZipcode, "
     " kmmPayees.addressState AS addressState, kmmPayees.telephone AS  telephone, kmmPayees.notes AS notes, "
     " kmmPayees.defaultAccountId AS defaultAccountId, kmmPayees.matchData AS matchData, kmmPayees.matchIgnoreCase AS matchIgnoreCase, "
     " kmmPayees.matchKeys AS matchKeys, "
     " kmmPayeesPayeeIdentifier.identifierId AS identId "
     " FROM ( SELECT * FROM kmmPayees ");
 
   if (!idList.isEmpty()) {
     // Create WHERE clause if needed
     queryString += QLatin1String(" WHERE id IN (");
     queryString += QString("?, ").repeated(idList.length());
     queryString.chop(2);   // remove ", " from end
     queryString += QLatin1Char(')');
   }
 
   queryString += QLatin1String(
     " ) kmmPayees "
     " LEFT OUTER JOIN kmmPayeesPayeeIdentifier ON kmmPayees.Id = kmmPayeesPayeeIdentifier.payeeId "
     // The order is used below
     " ORDER BY kmmPayees.id, kmmPayeesPayeeIdentifier.userOrder;");
 
   query.prepare(queryString);
 
   if (!idList.isEmpty()) {
     // Bind values
     QStringList::const_iterator end = idList.constEnd();
     for (QStringList::const_iterator iter = idList.constBegin(); iter != end; ++iter) {
       query.addBindValue(*iter);
     }
   }
 
   if (!query.exec())
-    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Payee"))); // krazy:exclude=crashy
+    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString::fromLatin1("reading Payee"))); // krazy:exclude=crashy
   const QSqlRecord record = query.record();
   const int idCol = record.indexOf("id");
   const int nameCol = record.indexOf("name");
   const int referenceCol = record.indexOf("reference");
   const int emailCol = record.indexOf("email");
   const int addressStreetCol = record.indexOf("addressStreet");
   const int addressCityCol = record.indexOf("addressCity");
   const int addressZipcodeCol = record.indexOf("addressZipcode");
   const int addressStateCol = record.indexOf("addressState");
   const int telephoneCol = record.indexOf("telephone");
   const int notesCol = record.indexOf("notes");
   const int defaultAccountIdCol = record.indexOf("defaultAccountId");
   const int matchDataCol = record.indexOf("matchData");
   const int matchIgnoreCaseCol = record.indexOf("matchIgnoreCase");
   const int matchKeysCol = record.indexOf("matchKeys");
   const int identIdCol = record.indexOf("identId");
 
   if (query.next()) {
     while (query.isValid()) {
       QString pid;
       QString boolChar;
       MyMoneyPayee payee;
       uint type;
       bool ignoreCase;
       QString matchKeys;
       pid = GETSTRING(idCol);
       payee.setName(GETSTRING(nameCol));
       payee.setReference(GETSTRING(referenceCol));
       payee.setEmail(GETSTRING(emailCol));
       payee.setAddress(GETSTRING(addressStreetCol));
       payee.setCity(GETSTRING(addressCityCol));
       payee.setPostcode(GETSTRING(addressZipcodeCol));
       payee.setState(GETSTRING(addressStateCol));
       payee.setTelephone(GETSTRING(telephoneCol));
       payee.setNotes(GETSTRING(notesCol));
       payee.setDefaultAccountId(GETSTRING(defaultAccountIdCol));
       type = GETINT(matchDataCol);
       ignoreCase = (GETSTRING(matchIgnoreCaseCol) == "Y");
       matchKeys = GETSTRING(matchKeysCol);
 
       payee.setMatchData(static_cast<MyMoneyPayee::payeeMatchType>(type), ignoreCase, matchKeys);
 
       // Get payeeIdentifier ids
       QStringList identifierIds;
       do {
         identifierIds.append(GETSTRING(identIdCol));
       } while (query.next() && GETSTRING(idCol) == pid);   // as long as the payeeId is unchanged
 
       // Fetch and save payeeIdentifier
       if (!identifierIds.isEmpty()) {
         QList< ::payeeIdentifier > identifier = fetchPayeeIdentifiers(identifierIds).values();
         payee.resetPayeeIdentifiers(identifier);
       }
 
       if (pid == "USER")
         d->m_storage->setUser(payee);
       else
         pList[pid] = MyMoneyPayee(pid, payee);
 
       if (d->m_displayStatus)
         d->signalProgress(++progress, 0);
     }
   }
   return pList;
 }
 
 QMap<QString, MyMoneyPayee> MyMoneyStorageSql::fetchPayees() const
 {
   return fetchPayees(QStringList(), false);
 }
 
 void MyMoneyStorageSql::readTags(const QString& id)
 {
   QList<QString> list;
   list.append(id);
   readTags(list);
 }
 
 void MyMoneyStorageSql::readTags(const QList<QString>& pid)
 {
   Q_D(MyMoneyStorageSql);
   try {
     d->m_storage->loadTags(fetchTags(pid));
     d->readFileInfo();
   } catch (const MyMoneyException &) {
   }
 //  if (pid.isEmpty()) m_tagListRead = true;
 }
 
 void MyMoneyStorageSql::readTags()
 {
   readTags(QList<QString>());
 }
 
 QMap<QString, onlineJob> MyMoneyStorageSql::fetchOnlineJobs(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   Q_UNUSED(forUpdate);
   MyMoneyDbTransaction trans(const_cast <MyMoneyStorageSql&>(*this), Q_FUNC_INFO);
   if (d->m_displayStatus)
     d->signalProgress(0, idList.isEmpty() ? d->m_onlineJobs : idList.size(), QObject::tr("Loading online banking data..."));
 
   // Create query
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   if (idList.isEmpty()) {
     query.prepare("SELECT id, type, jobSend, bankAnswerDate, state, locked FROM kmmOnlineJobs;");
   } else {
     QString queryIdSet = QString("?, ").repeated(idList.length());
     queryIdSet.chop(2);
     query.prepare(QLatin1String("SELECT id, type, jobSend, bankAnswerDate, state, locked FROM kmmOnlineJobs WHERE id IN (") + queryIdSet + QLatin1String(");"));
 
     QStringList::const_iterator end = idList.constEnd();
     for (QStringList::const_iterator iter = idList.constBegin(); iter != end; ++iter) {
       query.addBindValue(*iter);
     }
   }
   if (!query.exec())
-    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading onlineJobs"))); // krazy:exclude=crashy
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading onlineJobs")); // krazy:exclude=crashy
 
   // Create onlineJobs
   int progress = 0;
   QMap<QString, onlineJob> jobList;
 
   while (query.next()) {
     const QString& id = query.value(0).toString();
     onlineTask *const task = onlineJobAdministration::instance()->createOnlineTaskFromSqlDatabase(query.value(1).toString(), id, *this);
     onlineJob job = onlineJob(task, id);
     job.setJobSend(query.value(2).toDateTime());
     onlineJob::sendingState state;
     const QString stateString = query.value(4).toString();
     if (stateString == "acceptedByBank")
       state = onlineJob::acceptedByBank;
     else if (stateString == "rejectedByBank")
       state = onlineJob::rejectedByBank;
     else if (stateString == "abortedByUser")
       state = onlineJob::abortedByUser;
     else if (stateString == "sendingError")
       state = onlineJob::sendingError;
     else // includes: stateString == "noBankAnswer"
       state = onlineJob::noBankAnswer;
 
     job.setBankAnswer(state, query.value(4).toDateTime());
     job.setLock(query.value(5).toString() == QLatin1String("Y") ? true : false);
     jobList.insert(job.id(), job);
     if (d->m_displayStatus)
       d->signalProgress(++progress, 0);
   }
   return jobList;
 }
 
 QMap<QString, onlineJob> MyMoneyStorageSql::fetchOnlineJobs() const
 {
   return fetchOnlineJobs(QStringList(), false);
 }
 
 payeeIdentifier MyMoneyStorageSql::fetchPayeeIdentifier(const QString& id) const
 {
   QMap<QString, payeeIdentifier> list = fetchPayeeIdentifiers(QStringList(id));
   QMap<QString, payeeIdentifier>::const_iterator iter = list.constFind(id);
   if (iter == list.constEnd())
-    throw MYMONEYEXCEPTION(QLatin1String("payeeIdentifier with id '") + id + QLatin1String("' not found.")); // krazy:exclude=crashy
+    throw MYMONEYEXCEPTION(QString::fromLatin1("payeeIdentifier with id '%1' not found").arg(id)); // krazy:exclude=crashy
   return *iter;
 }
 
 QMap< QString, payeeIdentifier > MyMoneyStorageSql::fetchPayeeIdentifiers(const QStringList& idList) const
 {
   Q_D(const MyMoneyStorageSql);
   MyMoneyDbTransaction trans(const_cast <MyMoneyStorageSql&>(*this), Q_FUNC_INFO);
   // Create query
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   if (idList.isEmpty()) {
     query.prepare("SELECT id, type FROM kmmPayeeIdentifier;");
   } else {
     QString queryIdSet = QString("?, ").repeated(idList.length());
     queryIdSet.chop(2);   // remove ", " from end
     query.prepare(QLatin1String("SELECT id, type FROM kmmPayeeIdentifier WHERE id IN (") + queryIdSet + QLatin1String(");"));
 
     QStringList::const_iterator end = idList.constEnd();
     for (QStringList::const_iterator iter = idList.constBegin(); iter != end; ++iter) {
       query.addBindValue(*iter);
     }
   }
   if (!query.exec())
-    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading payee identifiers"))); // krazy:exclude=crashy
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading payee identifiers")); // krazy:exclude=crashy
 
   QMap<QString, payeeIdentifier> identList;
 
   while (query.next()) {
     const QString id = query.value(0).toString();
     identList.insert(id, payeeIdentifierLoader::instance()->createPayeeIdentifierFromSqlDatabase(*this, query.value(1).toString(), id));
   }
 
   return identList;
 }
 
 QMap< QString, payeeIdentifier > MyMoneyStorageSql::fetchPayeeIdentifiers() const
 {
   return fetchPayeeIdentifiers(QStringList());
 }
 
 QMap<QString, MyMoneyTag> MyMoneyStorageSql::fetchTags(const QStringList& idList, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
   MyMoneyDbTransaction trans(const_cast <MyMoneyStorageSql&>(*this), Q_FUNC_INFO);
   if (d->m_displayStatus) {
     int tagsNb = (idList.isEmpty() ? d->m_tags : idList.size());
     d->signalProgress(0, tagsNb, QObject::tr("Loading tags..."));
   } else {
 //    if (m_tagListRead) return;
   }
   int progress = 0;
   QMap<QString, MyMoneyTag> taList;
   //ulong lastId;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmTags"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   if (idList.isEmpty()) {
     query.prepare(t.selectAllString());
   } else {
     QString whereClause = " where (";
     QString itemConnector = "";
     foreach (const QString& it, idList) {
       whereClause.append(QString("%1id = '%2'").arg(itemConnector).arg(it));
       itemConnector = " or ";
     }
     whereClause += ')';
     query.prepare(t.selectAllString(false) + whereClause);
   }
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Tag"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Tag")); // krazy:exclude=crashy
   int idCol = t.fieldNumber("id");
   int nameCol = t.fieldNumber("name");
   int notesCol = t.fieldNumber("notes");
   int tagColorCol = t.fieldNumber("tagColor");
   int closedCol = t.fieldNumber("closed");
 
   while (query.next()) {
     QString pid;
     QString boolChar;
     MyMoneyTag tag;
     pid = GETSTRING(idCol);
     tag.setName(GETSTRING(nameCol));
     tag.setNotes(GETSTRING(notesCol));
     tag.setClosed((GETSTRING(closedCol) == "Y"));
     tag.setTagColor(QColor(GETSTRING(tagColorCol)));
     taList[pid] = MyMoneyTag(pid, tag);
     if (d->m_displayStatus) d->signalProgress(++progress, 0);
   }
   return taList;
 }
 
 QMap<QString, MyMoneyTag> MyMoneyStorageSql::fetchTags() const
 {
   return fetchTags(QStringList(), false);
 }
 
 QMap<QString, MyMoneyAccount> MyMoneyStorageSql::fetchAccounts(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int accountsNb = (idList.isEmpty() ? d->m_accounts : idList.size());
   d->signalProgress(0, accountsNb, QObject::tr("Loading accounts..."));
   int progress = 0;
   QMap<QString, MyMoneyAccount> accList;
   QStringList kvpAccountList(idList);
 
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmAccounts"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QSqlQuery sq(*const_cast <MyMoneyStorageSql*>(this));
 
   QString childQueryString = "SELECT id, parentId FROM kmmAccounts WHERE ";
   QString queryString(t.selectAllString(false));
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   if (! idList.empty()) {
     queryString += " WHERE id IN (";
     childQueryString += " parentId IN (";
     QString inString;
     for (int i = 0; i < idList.count(); ++i) {
       inString += QString(":id%1, ").arg(i);
     }
     inString = inString.left(inString.length() - 2) + ')';
 
     queryString += inString;
     childQueryString += inString;
   } else {
     childQueryString += " NOT parentId IS NULL";
   }
 
   queryString += " ORDER BY id";
   childQueryString += " ORDER BY parentid, id";
 
   if (forUpdate) {
     queryString += d->m_driver->forUpdateString();
     childQueryString += d->m_driver->forUpdateString();
   }
 
   query.prepare(queryString);
   sq.prepare(childQueryString);
 
   if (! idList.empty()) {
     QStringList::ConstIterator bindVal = idList.constBegin();
     for (int i = 0; bindVal != idList.constEnd(); ++i, ++bindVal) {
       query.bindValue(QString(":id%1").arg(i), *bindVal);
       sq.bindValue(QString(":id%1").arg(i), *bindVal);
     }
   }
 
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Account"))); // krazy:exclude=crashy
-  if (!sq.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading subAccountList"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Account")); // krazy:exclude=crashy
+  if (!sq.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading subAccountList")); // krazy:exclude=crashy
 
   // Reserve enough space for all values. Approximate it with the size of the
   // idList in case the db doesn't support reporting the size of the
   // resultset to the caller.
   //FIXME: this is for if/when there is a QHash conversion
   //accList.reserve(q.size() > 0 ? q.size() : idList.size());
 
   static const int idCol = t.fieldNumber("id");
   static const int institutionIdCol = t.fieldNumber("institutionId");
   static const int parentIdCol = t.fieldNumber("parentId");
   static const int lastReconciledCol = t.fieldNumber("lastReconciled");
   static const int lastModifiedCol = t.fieldNumber("lastModified");
   static const int openingDateCol = t.fieldNumber("openingDate");
   static const int accountNumberCol = t.fieldNumber("accountNumber");
   static const int accountTypeCol = t.fieldNumber("accountType");
   static const int accountNameCol = t.fieldNumber("accountName");
   static const int descriptionCol = t.fieldNumber("description");
   static const int currencyIdCol = t.fieldNumber("currencyId");
   static const int balanceCol = t.fieldNumber("balance");
   static const int transactionCountCol = t.fieldNumber("transactionCount");
 
   while (query.next()) {
     QString aid;
     QString balance;
     MyMoneyAccount acc;
 
     aid = GETSTRING(idCol);
     acc.setInstitutionId(GETSTRING(institutionIdCol));
     acc.setParentAccountId(GETSTRING(parentIdCol));
     acc.setLastReconciliationDate(GETDATE_D(lastReconciledCol));
     acc.setLastModified(GETDATE_D(lastModifiedCol));
     acc.setOpeningDate(GETDATE_D(openingDateCol));
     acc.setNumber(GETSTRING(accountNumberCol));
     acc.setAccountType(static_cast<Account::Type>(GETINT(accountTypeCol)));
     acc.setName(GETSTRING(accountNameCol));
     acc.setDescription(GETSTRING(descriptionCol));
     acc.setCurrencyId(GETSTRING(currencyIdCol));
     acc.setBalance(MyMoneyMoney(GETSTRING(balanceCol)));
     const_cast <MyMoneyStorageSql*>(this)->d_func()->m_transactionCountMap[aid] = (ulong) GETULL(transactionCountCol);
 
     // Process any key value pair
     if (idList.empty())
       kvpAccountList.append(aid);
 
     accList.insert(aid, MyMoneyAccount(aid, acc));
     if (acc.value("PreferredAccount") == "Yes") {
       const_cast <MyMoneyStorageSql*>(this)->d_func()->m_preferred.addAccount(aid);
     }
     d->signalProgress(++progress, 0);
   }
 
   QMap<QString, MyMoneyAccount>::Iterator it_acc;
   QMap<QString, MyMoneyAccount>::Iterator accListEnd = accList.end();
   while (sq.next()) {
     it_acc = accList.find(sq.value(1).toString());
     if (it_acc != accListEnd && it_acc.value().id() == sq.value(1).toString()) {
       while (sq.isValid() && it_acc != accListEnd
              && it_acc.value().id() == sq.value(1).toString()) {
         it_acc.value().addAccountId(sq.value(0).toString());
         if (!sq.next())
           break;
       }
       sq.previous();
     }
   }
 
   //TODO: There should be a better way than this.  What's below is O(n log n) or more,
   // where it may be able to be done in O(n), if things are just right.
   // The operator[] call in the loop is the most expensive call in this function, according
   // to several profile runs.
   QHash <QString, MyMoneyKeyValueContainer> kvpResult = d->readKeyValuePairs("ACCOUNT", kvpAccountList);
   QHash <QString, MyMoneyKeyValueContainer>::const_iterator kvp_end = kvpResult.constEnd();
   for (QHash <QString, MyMoneyKeyValueContainer>::const_iterator it_kvp = kvpResult.constBegin();
        it_kvp != kvp_end; ++it_kvp) {
     accList[it_kvp.key()].setPairs(it_kvp.value().pairs());
   }
 
   kvpResult = d->readKeyValuePairs("ONLINEBANKING", kvpAccountList);
   kvp_end = kvpResult.constEnd();
   for (QHash <QString, MyMoneyKeyValueContainer>::const_iterator it_kvp = kvpResult.constBegin();
        it_kvp != kvp_end; ++it_kvp) {
     accList[it_kvp.key()].setOnlineBankingSettings(it_kvp.value());
   }
 
   return accList;
 }
 
 QMap<QString, MyMoneyAccount> MyMoneyStorageSql::fetchAccounts() const
 {
   return fetchAccounts(QStringList(), false);
 }
 
 QMap<QString, MyMoneyMoney> MyMoneyStorageSql::fetchBalance(const QStringList& idList, const QDate& date) const
 {
   Q_D(const MyMoneyStorageSql);
   QMap<QString, MyMoneyMoney> returnValue;
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QString queryString = "SELECT action, shares, accountId, postDate "
                         "FROM kmmSplits WHERE txType = 'N'";
 
   if (idList.count() > 0) {
     queryString += "AND accountId in (";
 
     for (int i = 0; i < idList.count(); ++i) {
       queryString += QString(":id%1, ").arg(i);
     }
     queryString = queryString.left(queryString.length() - 2) + ')';
   }
 
   // SQLite stores dates as YYYY-MM-DDTHH:mm:ss with 0s for the time part. This makes
   // the <= operator misbehave when the date matches. To avoid this, add a day to the
   // requested date and use the < operator.
   if (date.isValid() && !date.isNull())
     queryString += QString(" AND postDate < '%1'").arg(date.addDays(1).toString(Qt::ISODate));
 
   queryString += " ORDER BY accountId, postDate;";
   //DBG(queryString);
   query.prepare(queryString);
 
   int i = 0;
   foreach (const QString& bindVal, idList) {
     query.bindValue(QString(":id%1").arg(i), bindVal);
     ++i;
   }
 
   if (!query.exec()) // krazy:exclude=crashy
-    throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("fetching balance")));
+    throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("fetching balance"));
   QString id;
   QString oldId;
   MyMoneyMoney temp;
   while (query.next()) {
     id = query.value(2).toString();
     // If the old ID does not match the new ID, then the account being summed has changed.
     // Write the balance into the returnValue map and update the oldId to the current one.
     if (id != oldId) {
       if (!oldId.isEmpty()) {
         returnValue.insert(oldId, temp);
         temp = 0;
       }
       oldId = id;
     }
     if (MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares) == query.value(0).toString())
       temp *= MyMoneyMoney(query.value(1).toString());
     else
       temp += MyMoneyMoney(query.value(1).toString());
   }
   // Do not forget the last id in the list.
   returnValue.insert(id, temp);
 
   // Return the map.
   return returnValue;
 }
 
 void MyMoneyStorageSql::readTransactions(const MyMoneyTransactionFilter& filter)
 {
   Q_D(MyMoneyStorageSql);
   try {
     d->m_storage->loadTransactions(fetchTransactions(filter));
   } catch (const MyMoneyException &) {
     throw;
   }
 }
 
 QMap<QString, MyMoneyTransaction> MyMoneyStorageSql::fetchTransactions(const QString& tidList, const QString& dateClause, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
 //  if (m_transactionListRead) return; // all list already in memory
   if (d->m_displayStatus) {
     int transactionsNb = (tidList.isEmpty() ? d->m_transactions : tidList.size());
     d->signalProgress(0, transactionsNb, QObject::tr("Loading transactions..."));
   }
   int progress = 0;
 //  m_payeeList.clear();
   QString whereClause = " WHERE txType = 'N' ";
   if (! tidList.isEmpty()) {
     whereClause += " AND id IN " + tidList;
   }
   if (!dateClause.isEmpty()) whereClause += " and " + dateClause;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmTransactions"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   query.prepare(t.selectAllString(false) + whereClause + " ORDER BY id;");
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Transaction"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Transaction")); // krazy:exclude=crashy
   const MyMoneyDbTable& ts = d->m_db.m_tables["kmmSplits"];
   whereClause = " WHERE txType = 'N' ";
   if (! tidList.isEmpty()) {
     whereClause += " AND transactionId IN " + tidList;
   }
   if (!dateClause.isEmpty()) whereClause += " and " + dateClause;
   QSqlQuery qs(*const_cast <MyMoneyStorageSql*>(this));
   QString splitQuery = ts.selectAllString(false) + whereClause
                        + " ORDER BY transactionId, splitId;";
   qs.prepare(splitQuery);
   if (!qs.exec()) throw MYMONEYEXCEPTION(d->buildError(qs, Q_FUNC_INFO, "reading Splits")); // krazy:exclude=crashy
   QString splitTxId = "ZZZ";
   MyMoneySplit s;
   if (qs.next()) {
     splitTxId = qs.value(0).toString();
     d->readSplit(s, qs);
   } else {
     splitTxId = "ZZZ";
   }
   QMap <QString, MyMoneyTransaction> txMap;
   QStringList txList;
   int idCol = t.fieldNumber("id");
   int postDateCol = t.fieldNumber("postDate");
   int memoCol = t.fieldNumber("memo");
   int entryDateCol = t.fieldNumber("entryDate");
   int currencyIdCol = t.fieldNumber("currencyId");
   int bankIdCol = t.fieldNumber("bankId");
 
   while (query.next()) {
     MyMoneyTransaction tx;
     QString txId = GETSTRING(idCol);
     tx.setPostDate(GETDATE_D(postDateCol));
     tx.setMemo(GETSTRING(memoCol));
     tx.setEntryDate(GETDATE_D(entryDateCol));
     tx.setCommodity(GETSTRING(currencyIdCol));
     tx.setBankID(GETSTRING(bankIdCol));
 
     // skip all splits while the transaction id of the split is less than
     // the transaction id of the current transaction. Don't forget to check
     // for the ZZZ flag for the end of the list.
     while (txId < splitTxId && splitTxId != "ZZZ") {
       if (qs.next()) {
         splitTxId = qs.value(0).toString();
         d->readSplit(s, qs);
       } else {
         splitTxId = "ZZZ";
       }
     }
 
     // while the split transaction id matches the current transaction id,
     // add the split to the current transaction. Set the ZZZ flag if
     // all splits for this transaction have been read.
     while (txId == splitTxId) {
       tx.addSplit(s);
       if (qs.next()) {
         splitTxId = qs.value(0).toString();
         d->readSplit(s, qs);
       } else {
         splitTxId = "ZZZ";
       }
     }
 
     // Process any key value pair
     if (! txId.isEmpty()) {
       txList.append(txId);
       tx = MyMoneyTransaction(txId, tx);
       txMap.insert(tx.uniqueSortKey(), tx);
     }
   }
 
   // get the kvps
   QHash <QString, MyMoneyKeyValueContainer> kvpMap = d->readKeyValuePairs("TRANSACTION", txList);
   QMap<QString, MyMoneyTransaction>::Iterator txMapEnd = txMap.end();
   for (QMap<QString, MyMoneyTransaction>::Iterator i = txMap.begin();
        i != txMapEnd; ++i) {
     i.value().setPairs(kvpMap[i.value().id()].pairs());
 
     if (d->m_displayStatus) d->signalProgress(++progress, 0);
   }
 
   if ((tidList.isEmpty()) && (dateClause.isEmpty())) {
     //qDebug("setting full list read");
   }
   return txMap;
 }
 
 QMap<QString, MyMoneyTransaction> MyMoneyStorageSql::fetchTransactions(const QString& tidList) const
 {
   return fetchTransactions(tidList, QString(), false);
 }
 
 QMap<QString, MyMoneyTransaction> MyMoneyStorageSql::fetchTransactions() const
 {
   return fetchTransactions(QString(), QString(), false);
 }
 
 QMap<QString, MyMoneyTransaction> MyMoneyStorageSql::fetchTransactions(const MyMoneyTransactionFilter& filter) const
 {
   Q_D(const MyMoneyStorageSql);
   // analyze the filter
 //  if (m_transactionListRead) return; // all list already in memory
   // if the filter is restricted to certain accounts/categories
   // check if we already have them all in memory
   QStringList accounts;
   QString inQuery;
   filter.accounts(accounts);
   filter.categories(accounts);
 //  QStringList::iterator it;
 //  bool allAccountsLoaded = true;
 //  for (it = accounts.begin(); it != accounts.end(); ++it) {
 //    if (m_accountsLoaded.find(*it) == m_accountsLoaded.end()) {
 //      allAccountsLoaded = false;
 //      break;
 //    }
 //  }
 //  if (allAccountsLoaded) return;
   /* Some filter combinations do not lend themselves to implementation
   * in SQL, or are likely to require such extensive reading of the database
   * as to make it easier to just read everything into memory.  */
   bool canImplementFilter = true;
   MyMoneyMoney m1, m2;
   if (filter.amountFilter(m1, m2)) {
     d->alert("Amount Filter Set");
     canImplementFilter = false;
   }
   QString n1, n2;
   if (filter.numberFilter(n1, n2)) {
     d->alert("Number filter set");
     canImplementFilter = false;
   }
   int t1;
   if (filter.firstType(t1)) {
     d->alert("Type filter set");
     canImplementFilter = false;
   }
 //  int s1;
 //  if (filter.firstState(s1)) {
 //    alert("State filter set");
 //    canImplementFilter = false;
 //  }
   QRegExp t2;
   if (filter.textFilter(t2)) {
     d->alert("text filter set");
     canImplementFilter = false;
   }
   MyMoneyTransactionFilter::FilterSet s = filter.filterSet();
   if (s.singleFilter.validityFilter) {
     d->alert("Validity filter set");
     canImplementFilter = false;
   }
   if (!canImplementFilter) {
     QMap<QString, MyMoneyTransaction> transactionList =  fetchTransactions();
     QMap<QString, MyMoneyTransaction>::ConstIterator it_t;
 
     std::remove_if(transactionList.begin(), transactionList.end(), FilterFail(filter));
     return transactionList;
   }
 
   bool splitFilterActive = false; // the split filter is active if we are selecting on fields in the split table
   // get start and end dates
   QDate start = filter.fromDate();
   QDate end = filter.toDate();
   // not entirely sure if the following is correct, but at best, saves a lot of reads, at worst
   // it only causes us to read a few more transactions that strictly necessary (I think...)
   if (start == MyMoneyStorageSqlPrivate::m_startDate) start = QDate();
   bool txFilterActive = ((start != QDate()) || (end != QDate())); // and this for fields in the transaction table
 
   QString whereClause = "";
   QString subClauseconnector = " where txType = 'N' and ";
   // payees
   QStringList payees;
   if (filter.payees(payees)) {
     QString itemConnector = "payeeId in (";
     QString payeesClause = "";
     foreach (const QString& it, payees) {
       payeesClause.append(QString("%1'%2'")
                           .arg(itemConnector).arg(it));
       itemConnector = ", ";
     }
     if (!payeesClause.isEmpty()) {
       whereClause += subClauseconnector + payeesClause + ')';
       subClauseconnector = " and ";
     }
     splitFilterActive = true;
   }
 
   //tags
   QStringList tags;
   if (filter.tags(tags)) {
     QString itemConnector = "splitId in ( SELECT splitId from kmmTagSplits where kmmTagSplits.transactionId = kmmSplits.transactionId and tagId in (";
     QString tagsClause = "";
     foreach (const QString& it, tags) {
       tagsClause.append(QString("%1'%2'")
                         .arg(itemConnector).arg(it));
       itemConnector = ", ";
     }
     if (!tagsClause.isEmpty()) {
       whereClause += subClauseconnector + tagsClause + ')';
       subClauseconnector = " and ";
     }
     splitFilterActive = true;
   }
 
   // accounts and categories
   if (!accounts.isEmpty()) {
     splitFilterActive = true;
     QString itemConnector = "accountId in (";
     QString accountsClause = "";
     foreach (const QString& it, accounts) {
       accountsClause.append(QString("%1 '%2'")
                             .arg(itemConnector).arg(it));
       itemConnector = ", ";
     }
     if (!accountsClause.isEmpty()) {
       whereClause += subClauseconnector + accountsClause + ')';
       subClauseconnector = " and (";
     }
   }
 
   // split states
   QList <int> splitStates;
   if (filter.states(splitStates)) {
     splitFilterActive = true;
     QString itemConnector = " reconcileFlag IN (";
     QString statesClause = "";
     foreach (int it, splitStates) {
       statesClause.append(QString(" %1 '%2'").arg(itemConnector)
                           .arg(d->splitState(TransactionFilter::State(it))));
       itemConnector = ',';
     }
     if (!statesClause.isEmpty()) {
       whereClause += subClauseconnector + statesClause + ')';
       subClauseconnector = " and (";
     }
   }
   // I've given up trying to work out the logic. we keep getting the wrong number of close brackets
   int obc = whereClause.count('(');
   int cbc = whereClause.count(')');
   if (cbc > obc) {
     qDebug() << "invalid where clause " << whereClause;
     qFatal("aborting");
   }
   while (cbc < obc) {
     whereClause.append(')');
     cbc++;
   }
   // if the split filter is active, but the where clause and the date filter is empty
   // it means we already have all the transactions for the specified filter
   // in memory, so just exit
   if ((splitFilterActive) && (whereClause.isEmpty()) && (!txFilterActive)) {
     qDebug("all transactions already in storage");
     return fetchTransactions();
   }
 
   // if we have neither a split filter, nor a tx (date) filter
   // it's effectively a read all
   if ((!splitFilterActive) && (!txFilterActive)) {
     //qDebug("reading all transactions");
     return fetchTransactions();
   }
   // build a date clause for the transaction table
   QString dateClause;
   QString connector = "";
   if (end != QDate()) {
     dateClause = QString("(postDate < '%1')").arg(end.addDays(1).toString(Qt::ISODate));
     connector = " and ";
   }
   if (start != QDate()) {
     dateClause += QString("%1 (postDate >= '%2')").arg(connector).arg(start.toString(Qt::ISODate));
   }
   // now get a list of transaction ids
   // if we have only a date filter, we need to build the list from the tx table
   // otherwise we need to build from the split table
   if (splitFilterActive) {
     inQuery = QString("(select distinct transactionId from kmmSplits %1)").arg(whereClause);
   } else {
     inQuery = QString("(select distinct id from kmmTransactions where %1)").arg(dateClause);
     txFilterActive = false; // kill off the date filter now
   }
 
   return fetchTransactions(inQuery, dateClause);
   //FIXME: if we have an accounts-only filter, recalc balances on loaded accounts
 }
 
 ulong MyMoneyStorageSql::transactionCount(const QString& aid) const
 {
   Q_D(const MyMoneyStorageSql);
   if (aid.isEmpty())
     return d->m_transactions;
   else
     return d->m_transactionCountMap[aid];
 }
 
 QHash<QString, ulong> MyMoneyStorageSql::transactionCountMap() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->m_transactionCountMap;
 }
 
 bool MyMoneyStorageSql::isReferencedByTransaction(const QString& id) const
 {
   Q_D(const MyMoneyStorageSql);
   //FIXME-ALEX should I add sub query for kmmTagSplits here?
   QSqlQuery q(*const_cast <MyMoneyStorageSql*>(this));
   q.prepare("SELECT COUNT(*) FROM kmmTransactions "
             "INNER JOIN kmmSplits ON kmmTransactions.id = kmmSplits.transactionId "
             "WHERE kmmTransactions.currencyId = :ID OR kmmSplits.payeeId = :ID "
             "OR kmmSplits.accountId = :ID OR kmmSplits.costCenterId = :ID");
   q.bindValue(":ID", id);
   if ((!q.exec()) || (!q.next())) { // krazy:exclude=crashy
     d->buildError(q, Q_FUNC_INFO, "error retrieving reference count");
     qFatal("Error retrieving reference count"); // definitely shouldn't happen
   }
   return (0 != q.value(0).toULongLong());
 }
 
 QMap<QString, MyMoneySchedule> MyMoneyStorageSql::fetchSchedules(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int schedulesNb = (idList.isEmpty() ? d->m_schedules : idList.size());
   d->signalProgress(0, schedulesNb, QObject::tr("Loading schedules..."));
   int progress = 0;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmSchedules"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QMap<QString, MyMoneySchedule> sList;
   //ulong lastId = 0;
   const MyMoneyDbTable& ts = d->m_db.m_tables["kmmSplits"];
   QSqlQuery qs(*const_cast <MyMoneyStorageSql*>(this));
   qs.prepare(ts.selectAllString(false) + " WHERE transactionId = :id ORDER BY splitId;");
   QSqlQuery sq(*const_cast <MyMoneyStorageSql*>(this));
   sq.prepare("SELECT payDate from kmmSchedulePaymentHistory where schedId = :id");
 
   QString queryString(t.selectAllString(false));
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   if (! idList.empty()) {
     queryString += " WHERE";
     for (int i = 0; i < idList.count(); ++i)
       queryString += QString(" id = :id%1 OR").arg(i);
     queryString = queryString.left(queryString.length() - 2);
   }
   queryString += " ORDER BY id";
 
   if (forUpdate)
     queryString += d->m_driver->forUpdateString();
 
   query.prepare(queryString);
 
   if (! idList.empty()) {
     QStringList::ConstIterator bindVal = idList.constBegin();
     for (int i = 0; bindVal != idList.constEnd(); ++i, ++bindVal) {
       query.bindValue(QString(":id%1").arg(i), *bindVal);
     }
   }
 
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Schedules"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Schedules")); // krazy:exclude=crashy
   int idCol = t.fieldNumber("id");
   int nameCol = t.fieldNumber("name");
   int typeCol = t.fieldNumber("type");
   int occurrenceCol = t.fieldNumber("occurence"); // krazy:exclude=spelling
   int occurrenceMultiplierCol = t.fieldNumber("occurenceMultiplier"); // krazy:exclude=spelling
   int paymentTypeCol = t.fieldNumber("paymentType");
   int startDateCol = t.fieldNumber("startDate");
   int endDateCol = t.fieldNumber("endDate");
   int fixedCol = t.fieldNumber("fixed");
   int lastDayInMonthCol = t.fieldNumber("lastDayInMonth");
   int autoEnterCol = t.fieldNumber("autoEnter");
   int lastPaymentCol = t.fieldNumber("lastPayment");
   int weekendOptionCol = t.fieldNumber("weekendOption");
   int nextPaymentDueCol = t.fieldNumber("nextPaymentDue");
 
   while (query.next()) {
     MyMoneySchedule s;
     QString boolChar;
 
     QString sId = GETSTRING(idCol);
     s.setName(GETSTRING(nameCol));
     s.setType(static_cast<Schedule::Type>(GETINT(typeCol)));
     s.setOccurrencePeriod(static_cast<Schedule::Occurrence>(GETINT(occurrenceCol)));
     s.setOccurrenceMultiplier(GETINT(occurrenceMultiplierCol));
     s.setPaymentType(static_cast<Schedule::PaymentType>(GETINT(paymentTypeCol)));
     s.setStartDate(GETDATE_D(startDateCol));
     s.setEndDate(GETDATE_D(endDateCol));
     boolChar = GETSTRING(fixedCol); s.setFixed(boolChar == "Y");
     boolChar = GETSTRING(lastDayInMonthCol); s.setLastDayInMonth(boolChar == "Y");
     boolChar = GETSTRING(autoEnterCol); s.setAutoEnter(boolChar == "Y");
     s.setLastPayment(GETDATE_D(lastPaymentCol));
     s.setWeekendOption(static_cast<Schedule::WeekendOption>(GETINT(weekendOptionCol)));
     QDate nextPaymentDue = GETDATE_D(nextPaymentDueCol);
 
     // convert simple occurrence to compound occurrence
     int mult = s.occurrenceMultiplier();
     Schedule::Occurrence occ = s.occurrencePeriod();
     MyMoneySchedule::simpleToCompoundOccurrence(mult, occ);
     s.setOccurrencePeriod(occ);
     s.setOccurrenceMultiplier(mult);
     // now assign the id to the schedule
     MyMoneySchedule _s(sId, s);
     s = _s;
     // read the associated transaction
 //    m_payeeList.clear();
 
     const MyMoneyDbTable& transactionTable = d->m_db.m_tables["kmmTransactions"];
     QSqlQuery q2(*const_cast <MyMoneyStorageSql*>(this));
     q2.prepare(transactionTable.selectAllString(false) + " WHERE id = :id;");
     q2.bindValue(":id", s.id());
     if (!q2.exec()) throw MYMONEYEXCEPTION(d->buildError(q2, Q_FUNC_INFO, QString("reading Scheduled Transaction"))); // krazy:exclude=crashy
     QSqlRecord rec = q2.record();
     if (!q2.next()) throw MYMONEYEXCEPTION(d->buildError(q2, Q_FUNC_INFO, QString("retrieving scheduled transaction")));
     MyMoneyTransaction tx(s.id(), MyMoneyTransaction());
     tx.setPostDate(d->GETDATE(q2.value(transactionTable.fieldNumber("postDate")).toString()));
     tx.setMemo(q2.value(transactionTable.fieldNumber("memo")).toString());
     tx.setEntryDate(d->GETDATE(q2.value(transactionTable.fieldNumber("entryDate")).toString()));
     tx.setCommodity(q2.value(transactionTable.fieldNumber("currencyId")).toString());
     tx.setBankID(q2.value(transactionTable.fieldNumber("bankId")).toString());
 
     qs.bindValue(":id", s.id());
     if (!qs.exec()) throw MYMONEYEXCEPTION(d->buildError(qs, Q_FUNC_INFO, "reading Scheduled Splits")); // krazy:exclude=crashy
     while (qs.next()) {
       MyMoneySplit sp;
       d->readSplit(sp, qs);
       tx.addSplit(sp);
     }
 //    if (!m_payeeList.isEmpty())
 //      readPayees(m_payeeList);
     // Process any key value pair
     tx.setPairs(d->readKeyValuePairs("TRANSACTION", s.id()).pairs());
 
     // If the transaction doesn't have a post date, setTransaction will reject it.
     // The old way of handling things was to store the next post date in the schedule object
     // and set the transaction post date to QDate().
     // For compatibility, if this is the case, copy the next post date from the schedule object
     // to the transaction object post date.
     if (!tx.postDate().isValid()) {
       tx.setPostDate(nextPaymentDue);
     }
 
     s.setTransaction(tx);
 
     // read in the recorded payments
     sq.bindValue(":id", s.id());
-    if (!sq.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading schedule payment history"))); // krazy:exclude=crashy
+    if (!sq.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading schedule payment history")); // krazy:exclude=crashy
     while (sq.next()) s.recordPayment(sq.value(0).toDate());
 
     sList[s.id()] = s;
 
     //FIXME: enable when schedules have KVPs.
     //  s.setPairs(readKeyValuePairs("SCHEDULE", s.id()).pairs());
 
     //ulong id = MyMoneyUtils::extractId(s.id().data());
     //if(id > lastId)
     //  lastId = id;
 
     d->signalProgress(++progress, 0);
   }
   return sList;
 }
 
 QMap<QString, MyMoneySchedule> MyMoneyStorageSql::fetchSchedules() const
 {
   return fetchSchedules(QStringList(), false);
 }
 
 QMap<QString, MyMoneySecurity> MyMoneyStorageSql::fetchSecurities(const QStringList& /*idList*/, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
   d->signalProgress(0, d->m_securities, QObject::tr("Loading securities..."));
   int progress = 0;
   QMap<QString, MyMoneySecurity> sList;
   ulong lastId = 0;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmSecurities"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   query.prepare(t.selectAllString(false) + " ORDER BY id;");
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Securities"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Securities")); // krazy:exclude=crashy
   int idCol = t.fieldNumber("id");
   int nameCol = t.fieldNumber("name");
   int symbolCol = t.fieldNumber("symbol");
   int typeCol = t.fieldNumber("type");
   int roundingMethodCol = t.fieldNumber("roundingMethod");
   int smallestAccountFractionCol = t.fieldNumber("smallestAccountFraction");
   int pricePrecisionCol = t.fieldNumber("pricePrecision");
   int tradingCurrencyCol = t.fieldNumber("tradingCurrency");
   int tradingMarketCol = t.fieldNumber("tradingMarket");
 
   while (query.next()) {
     MyMoneySecurity e;
     QString eid;
     eid = GETSTRING(idCol);
     e.setName(GETSTRING(nameCol));
     e.setTradingSymbol(GETSTRING(symbolCol));
     e.setSecurityType(static_cast<Security::Type>(GETINT(typeCol)));
     e.setRoundingMethod(static_cast<AlkValue::RoundingMethod>(GETINT(roundingMethodCol)));
     int saf = GETINT(smallestAccountFractionCol);
     int pp = GETINT(pricePrecisionCol);
     e.setTradingCurrency(GETSTRING(tradingCurrencyCol));
     e.setTradingMarket(GETSTRING(tradingMarketCol));
 
     if (e.tradingCurrency().isEmpty())
       e.setTradingCurrency(d->m_storage->pairs()["kmm-baseCurrency"]);
     if (saf == 0)
       saf = 100;
     if (pp == 0 || pp > 10)
       pp = 4;
     e.setSmallestAccountFraction(saf);
     e.setPricePrecision(pp);
 
     // Process any key value pairs
     e.setPairs(d->readKeyValuePairs("SECURITY", eid).pairs());
     //tell the storage objects we have a new security object.
 
     // FIXME: Adapt to new interface make sure, to take care of the currencies as well
     //   see MyMoneyStorageXML::readSecurites()
     MyMoneySecurity security(eid, e);
     sList[security.id()] = security;
 
     ulong id = MyMoneyUtils::extractId(security.id());
     if (id > lastId)
       lastId = id;
 
     d->signalProgress(++progress, 0);
   }
   return sList;
 }
 
 QMap<QString, MyMoneySecurity> MyMoneyStorageSql::fetchSecurities() const
 {
   return fetchSecurities(QStringList(), false);
 }
 
 MyMoneyPrice MyMoneyStorageSql::fetchSinglePrice(const QString& fromId, const QString& toId, const QDate& date_, bool exactDate, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmPrices"];
 
   static const int priceDateCol = t.fieldNumber("priceDate");
   static const int priceCol = t.fieldNumber("price");
   static const int priceSourceCol = t.fieldNumber("priceSource");
 
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   // See balance query for why the date logic seems odd.
   QString queryString = t.selectAllString(false) +
                         " WHERE fromId = :fromId  AND toId = :toId AND priceDate < :priceDate ";
 
   if (exactDate)
     queryString += "AND priceDate > :exactDate ";
 
   queryString += "ORDER BY priceDate DESC;";
 
   query.prepare(queryString);
 
   QDate date(date_);
 
   if (!date.isValid())
     date = QDate::currentDate();
 
   query.bindValue(":fromId", fromId);
   query.bindValue(":toId", toId);
   query.bindValue(":priceDate", date.addDays(1).toString(Qt::ISODate));
 
   if (exactDate)
     query.bindValue(":exactDate", date.toString(Qt::ISODate));
 
   if (! query.exec()) return MyMoneyPrice(); // krazy:exclude=crashy
 
   if (query.next()) {
 
     return MyMoneyPrice(fromId,
                         toId,
                         GETDATE_D(priceDateCol),
                         MyMoneyMoney(GETSTRING(priceCol)),
                         GETSTRING(priceSourceCol));
   }
 
   return MyMoneyPrice();
 }
 
 MyMoneyPriceList MyMoneyStorageSql::fetchPrices(const QStringList& fromIdList, const QStringList& toIdList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int pricesNb = (fromIdList.isEmpty() ? d->m_prices : fromIdList.size());
   d->signalProgress(0, pricesNb, QObject::tr("Loading prices..."));
   int progress = 0;
   const_cast <MyMoneyStorageSql*>(this)->d_func()->m_readingPrices = true;
   MyMoneyPriceList pList;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmPrices"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QString queryString = t.selectAllString(false);
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   if (! fromIdList.empty()) {
     queryString += " WHERE (";
     for (int i = 0; i < fromIdList.count(); ++i) {
       queryString += QString(" fromId = :fromId%1 OR").arg(i);
     }
     queryString = queryString.left(queryString.length() - 2) + ')';
   }
   if (! toIdList.empty()) {
     queryString += " AND (";
     for (int i = 0; i < toIdList.count(); ++i) {
       queryString += QString(" toId = :toId%1 OR").arg(i);
     }
     queryString = queryString.left(queryString.length() - 2) + ')';
   }
 
   if (forUpdate)
     queryString += d->m_driver->forUpdateString();
 
   queryString += ';';
 
   query.prepare(queryString);
 
   if (! fromIdList.empty()) {
     QStringList::ConstIterator bindVal = fromIdList.constBegin();
     for (int i = 0; bindVal != fromIdList.constEnd(); ++i, ++bindVal) {
       query.bindValue(QString(":fromId%1").arg(i), *bindVal);
     }
   }
   if (! toIdList.empty()) {
     QStringList::ConstIterator bindVal = toIdList.constBegin();
     for (int i = 0; bindVal != toIdList.constEnd(); ++i, ++bindVal) {
       query.bindValue(QString(":toId%1").arg(i), *bindVal);
     }
   }
 
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Prices"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Prices")); // krazy:exclude=crashy
   static const int fromIdCol = t.fieldNumber("fromId");
   static const int toIdCol = t.fieldNumber("toId");
   static const int priceDateCol = t.fieldNumber("priceDate");
   static const int priceCol = t.fieldNumber("price");
   static const int priceSourceCol = t.fieldNumber("priceSource");
 
   while (query.next()) {
     QString from = GETSTRING(fromIdCol);
     QString to = GETSTRING(toIdCol);
     QDate date = GETDATE_D(priceDateCol);
 
     pList [MyMoneySecurityPair(from, to)].insert(date, MyMoneyPrice(from, to, date, MyMoneyMoney(GETSTRING(priceCol)), GETSTRING(priceSourceCol)));
     d->signalProgress(++progress, 0);
   }
   const_cast <MyMoneyStorageSql*>(this)->d_func()->m_readingPrices = false;
 
   return pList;
 }
 
 MyMoneyPriceList MyMoneyStorageSql::fetchPrices() const
 {
   return fetchPrices(QStringList(), QStringList(), false);
 }
 
 QMap<QString, MyMoneySecurity> MyMoneyStorageSql::fetchCurrencies(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int currenciesNb = (idList.isEmpty() ? d->m_currencies : idList.size());
   d->signalProgress(0, currenciesNb, QObject::tr("Loading currencies..."));
   int progress = 0;
   QMap<QString, MyMoneySecurity> cList;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmCurrencies"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
 
   QString queryString(t.selectAllString(false));
 
   // Use bind variables, instead of just inserting the values in the queryString,
   // so that values containing a ':' will work.
   if (! idList.empty()) {
     queryString += " WHERE";
     for (int i = 0; i < idList.count(); ++i)
       queryString += QString(" isocode = :id%1 OR").arg(i);
     queryString = queryString.left(queryString.length() - 2);
   }
 
   queryString += " ORDER BY ISOcode";
 
   if (forUpdate)
     queryString += d->m_driver->forUpdateString();
 
   queryString += ';';
 
   query.prepare(queryString);
 
   if (! idList.empty()) {
     QStringList::ConstIterator bindVal = idList.constBegin();
     for (int i = 0; bindVal != idList.end(); ++i, ++bindVal) {
       query.bindValue(QString(":id%1").arg(i), *bindVal);
     }
   }
 
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading Currencies"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading Currencies")); // krazy:exclude=crashy
   int ISOcodeCol = t.fieldNumber("ISOcode");
   int nameCol = t.fieldNumber("name");
   int typeCol = t.fieldNumber("type");
   int symbol1Col = t.fieldNumber("symbol1");
   int symbol2Col = t.fieldNumber("symbol2");
   int symbol3Col = t.fieldNumber("symbol3");
   int smallestCashFractionCol = t.fieldNumber("smallestCashFraction");
   int smallestAccountFractionCol = t.fieldNumber("smallestAccountFraction");
   int pricePrecisionCol = t.fieldNumber("pricePrecision");
 
   while (query.next()) {
     QString id;
     MyMoneySecurity c;
     QChar symbol[3];
     id = GETSTRING(ISOcodeCol);
     c.setName(GETSTRING(nameCol));
     c.setSecurityType(static_cast<Security::Type>(GETINT(typeCol)));
     symbol[0] = QChar(GETINT(symbol1Col));
     symbol[1] = QChar(GETINT(symbol2Col));
     symbol[2] = QChar(GETINT(symbol3Col));
     c.setSmallestCashFraction(GETINT(smallestCashFractionCol));
     c.setSmallestAccountFraction(GETINT(smallestAccountFractionCol));
     c.setPricePrecision(GETINT(pricePrecisionCol));
     c.setTradingSymbol(QString(symbol, 3).trimmed());
 
     cList[id] = MyMoneySecurity(id, c);
 
     d->signalProgress(++progress, 0);
   }
   return cList;
 }
 
 QMap<QString, MyMoneySecurity> MyMoneyStorageSql::fetchCurrencies() const
 {
   return fetchCurrencies(QStringList(), false);
 }
 
 QMap<QString, MyMoneyReport> MyMoneyStorageSql::fetchReports(const QStringList& /*idList*/, bool /*forUpdate*/) const
 {
   Q_D(const MyMoneyStorageSql);
   d->signalProgress(0, d->m_reports, QObject::tr("Loading reports..."));
   int progress = 0;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmReportConfig"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   query.prepare(t.selectAllString(true));
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading reports"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading reports")); // krazy:exclude=crashy
   int xmlCol = t.fieldNumber("XML");
   QMap<QString, MyMoneyReport> rList;
   while (query.next()) {
     QDomDocument dom;
     dom.setContent(GETSTRING(xmlCol), false);
 
     QDomNode child = dom.firstChild();
     child = child.firstChild();
     MyMoneyReport report;
 
     if (report.read(child.toElement()))
       rList[report.id()] = report;
 
     d->signalProgress(++progress, 0);
   }
   return rList;
 }
 
 QMap<QString, MyMoneyReport> MyMoneyStorageSql::fetchReports() const
 {
   return fetchReports(QStringList(), false);
 }
 
 QMap<QString, MyMoneyBudget> MyMoneyStorageSql::fetchBudgets(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   int budgetsNb = (idList.isEmpty() ? d->m_budgets : idList.size());
   d->signalProgress(0, budgetsNb, QObject::tr("Loading budgets..."));
   int progress = 0;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmBudgetConfig"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   QString queryString(t.selectAllString(false));
   if (! idList.empty()) {
     queryString += " WHERE id = '" + idList.join("' OR id = '") + '\'';
   }
   if (forUpdate)
     queryString += d->m_driver->forUpdateString();
 
   queryString += ';';
 
   query.prepare(queryString);
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading budgets"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading budgets")); // krazy:exclude=crashy
   QMap<QString, MyMoneyBudget> budgets;
   int xmlCol = t.fieldNumber("XML");
   while (query.next()) {
     QDomDocument dom;
     dom.setContent(GETSTRING(xmlCol), false);
 
     QDomNode child = dom.firstChild();
     child = child.firstChild();
     MyMoneyBudget budget(child.toElement());
     budgets.insert(budget.id(), budget);
     d->signalProgress(++progress, 0);
   }
   return budgets;
 }
 
 QMap<QString, MyMoneyBudget> MyMoneyStorageSql::fetchBudgets() const
 {
   return fetchBudgets(QStringList(), false);
 }
 
 ulong MyMoneyStorageSql::getNextBudgetId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdBudgets>(QLatin1String("kmmBudgetConfig"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextAccountId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdAccounts>(QLatin1String("kmmAccounts"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextInstitutionId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdInstitutions>(QLatin1String("kmmInstitutions"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextPayeeId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdPayees>(QLatin1String("kmmPayees"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextTagId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdTags>(QLatin1String("kmmTags"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextReportId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdReports>(QLatin1String("kmmReportConfig"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextScheduleId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdSchedules>(QLatin1String("kmmSchedules"), QLatin1String("id"), 3);
 }
 
 ulong MyMoneyStorageSql::getNextSecurityId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdSecurities>(QLatin1String("kmmSecurities"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextTransactionId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdTransactions>(QLatin1String("kmmTransactions"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextOnlineJobId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdOnlineJobs>(QLatin1String("kmmOnlineJobs"), QLatin1String("id"), 1);
 }
 
 ulong MyMoneyStorageSql::getNextPayeeIdentifierId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdPayeeIdentifier>(QLatin1String("kmmPayeeIdentifier"), QLatin1String("id"), 5);
 }
 
 ulong MyMoneyStorageSql::getNextCostCenterId() const
 {
   Q_D(const MyMoneyStorageSql);
   return d->getNextId<&MyMoneyStorageSqlPrivate::m_hiIdCostCenter>(QLatin1String("kmmCostCenterIdentifier"), QLatin1String("id"), 5);
 }
 
 ulong MyMoneyStorageSql::incrementBudgetId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdBudgets = getNextBudgetId() + 1;
   return (d->m_hiIdBudgets - 1);
 }
 
 /**
  * @warning This method uses getNextAccountId() internaly. The database is not informed which can cause issues
  * when the database is accessed concurrently. Then maybe a single id is used twice but the RDBMS will detect the
  * issue and KMyMoney crashes. This issue can only occour when two instances of KMyMoney access the same database.
  * But in this unlikley case MyMoneyStorageSql will have a lot more issues, I think.
  */
 ulong MyMoneyStorageSql::incrementAccountId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdAccounts = getNextAccountId() + 1;
   return (d->m_hiIdAccounts - 1);
 }
 
 ulong MyMoneyStorageSql::incrementInstitutionId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdInstitutions = getNextInstitutionId() + 1;
   return (d->m_hiIdInstitutions - 1);
 }
 
 ulong MyMoneyStorageSql::incrementPayeeId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdPayees = getNextPayeeId() + 1;
   return (d->m_hiIdPayees - 1);
 }
 
 ulong MyMoneyStorageSql::incrementTagId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdTags = getNextTagId() + 1;
   return (d->m_hiIdTags - 1);
 }
 
 ulong MyMoneyStorageSql::incrementReportId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdReports = getNextReportId() + 1;
   return (d->m_hiIdReports - 1);
 }
 
 ulong MyMoneyStorageSql::incrementScheduleId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdSchedules = getNextScheduleId() + 1;
   return (d->m_hiIdSchedules - 1);
 }
 
 ulong MyMoneyStorageSql::incrementSecurityId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdSecurities = getNextSecurityId() + 1;
   return (d->m_hiIdSecurities - 1);
 }
 
 ulong MyMoneyStorageSql::incrementTransactionId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdTransactions = getNextTransactionId() + 1;
   return (d->m_hiIdTransactions - 1);
 }
 
 ulong MyMoneyStorageSql::incrementOnlineJobId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdOnlineJobs = getNextOnlineJobId() + 1;
   return (d->m_hiIdOnlineJobs - 1);
 }
 
 ulong MyMoneyStorageSql::incrementPayeeIdentfierId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdPayeeIdentifier = getNextPayeeIdentifierId() + 1;
   return (d->m_hiIdPayeeIdentifier - 1);
 }
 
 ulong MyMoneyStorageSql::incrementCostCenterId()
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdCostCenter = getNextCostCenterId() + 1;
   return (d->m_hiIdCostCenter - 1);
 }
 
 void MyMoneyStorageSql::loadAccountId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdAccounts = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadTransactionId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdTransactions = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadPayeeId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdPayees = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadTagId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdTags = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadInstitutionId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdInstitutions = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadScheduleId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdSchedules = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadSecurityId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdSecurities = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadReportId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdReports = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadBudgetId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdBudgets = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadOnlineJobId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdOnlineJobs = id;
   d->writeFileInfo();
 }
 
 void MyMoneyStorageSql::loadPayeeIdentifierId(ulong id)
 {
   Q_D(MyMoneyStorageSql);
   d->m_hiIdPayeeIdentifier = id;
   d->writeFileInfo();
 }
 
 //****************************************************
 
 void MyMoneyStorageSql::setProgressCallback(void(*callback)(int, int, const QString&))
 {
   Q_D(MyMoneyStorageSql);
   d->m_progressCallback = callback;
 }
 
 void MyMoneyStorageSql::readFile(QIODevice* s, MyMoneyStorageMgr* storage)
 {
   Q_UNUSED(s); Q_UNUSED(storage)
 }
 
 void MyMoneyStorageSql::writeFile(QIODevice* s, MyMoneyStorageMgr* storage)
 {
   Q_UNUSED(s); Q_UNUSED(storage)
 }
 
 // **************************** Error display routine *******************************
 
 
 QDate MyMoneyStorageSqlPrivate::m_startDate = QDate(1900, 1, 1);
 
 void MyMoneyStorageSql::setStartDate(const QDate& startDate)
 {
   MyMoneyStorageSqlPrivate::m_startDate = startDate;
 }
 
 QMap< QString, MyMoneyCostCenter > MyMoneyStorageSql::fetchCostCenters(const QStringList& idList, bool forUpdate) const
 {
   Q_D(const MyMoneyStorageSql);
   Q_UNUSED(forUpdate);
 
   MyMoneyDbTransaction trans(const_cast <MyMoneyStorageSql&>(*this), Q_FUNC_INFO);
   if (d->m_displayStatus) {
     int costCenterNb = (idList.isEmpty() ? 100 : idList.size());
     d->signalProgress(0, costCenterNb, QObject::tr("Loading cost center..."));
   }
   int progress = 0;
   QMap<QString, MyMoneyCostCenter> costCenterList;
   //ulong lastId;
   const MyMoneyDbTable& t = d->m_db.m_tables["kmmCostCenter"];
   QSqlQuery query(*const_cast <MyMoneyStorageSql*>(this));
   if (idList.isEmpty()) {
     query.prepare(t.selectAllString());
   } else {
     QString whereClause = " where (";
     QString itemConnector = "";
     foreach (const QString& it, idList) {
       whereClause.append(QString("%1id = '%2'").arg(itemConnector).arg(it));
       itemConnector = " or ";
     }
     whereClause += ')';
     query.prepare(t.selectAllString(false) + whereClause);
   }
-  if (!query.exec()) throw MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, QString("reading CostCenter"))); // krazy:exclude=crashy
+  if (!query.exec()) throw MYMONEYEXCEPTIONSQL_D(QString::fromLatin1("reading CostCenter")); // krazy:exclude=crashy
   const int idCol = t.fieldNumber("id");
   const int nameCol = t.fieldNumber("name");
 
   while (query.next()) {
     MyMoneyCostCenter costCenter;
     QString pid = GETSTRING(idCol);
     costCenter.setName(GETSTRING(nameCol));
     costCenterList[pid] = MyMoneyCostCenter(pid, costCenter);
     if (d->m_displayStatus) d->signalProgress(++progress, 0);
   }
   return costCenterList;
 }
 
 QMap< QString, MyMoneyCostCenter > MyMoneyStorageSql::fetchCostCenters() const
 {
   return fetchCostCenters(QStringList(), false);
 }
diff --git a/kmymoney/plugins/sql/mymoneystoragesql_p.h b/kmymoney/plugins/sql/mymoneystoragesql_p.h
index 95423bb5d..fa7c17568 100644
--- a/kmymoney/plugins/sql/mymoneystoragesql_p.h
+++ b/kmymoney/plugins/sql/mymoneystoragesql_p.h
@@ -1,2834 +1,2835 @@
 /***************************************************************************
                           mymoneystoragesql.cpp
                           ---------------------
     begin                : 11 November 2005
     copyright            : (C) 2005 by Tony Bloomfield
     email                : tonybloom@users.sourceforge.net
                          : Fernando Vilas <fvilas@iname.com>
                          : Christian Dávid <christian-david@web.de>
                          (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYSTORAGESQL_P_H
 #define MYMONEYSTORAGESQL_P_H
 
 #include "mymoneystoragesql.h"
 
 // ----------------------------------------------------------------------------
 // System Includes
 #include <algorithm>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QDateTime>
 #include <QStringList>
 #include <QIODevice>
 #include <QUrlQuery>
 #include <QSqlQuery>
 #include <QSqlError>
 #include <QList>
 #include <QSqlRecord>
 #include <QMap>
 #include <QFile>
 #include <QVariant>
 #include <QColor>
 #include <QDebug>
 #include <QStack>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KServiceTypeTrader>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneystoragemgr.h"
 #include "kmymoneystorageplugin.h"
 #include "onlinejobadministration.h"
 #include "payeeidentifier/payeeidentifierloader.h"
 #include "onlinetasks/interfaces/tasks/onlinetask.h"
 #include "mymoneycostcenter.h"
 #include "mymoneyexception.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneymoney.h"
 #include "mymoneyschedule.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneybudget.h"
 #include "mymoneyreport.h"
 #include "mymoneyprice.h"
 #include "mymoneyutils.h"
 #include "mymoneydbdef.h"
 #include "mymoneydbdriver.h"
 #include "payeeidentifier/payeeidentifierdata.h"
 #include "mymoneyenums.h"
 #include "mymoneystoragenames.h"
 
 using namespace eMyMoney;
 using namespace MyMoneyStandardAccounts;
 
 class FilterFail
 {
 public:
   explicit FilterFail(const MyMoneyTransactionFilter& filter) : m_filter(filter) {}
 
   inline bool operator()(const QPair<QString, MyMoneyTransaction>& transactionPair) {
     return (*this)(transactionPair.second);
   }
 
   inline bool operator()(const MyMoneyTransaction& transaction) {
     return !m_filter.match(transaction);
   }
 
 private:
   MyMoneyTransactionFilter m_filter;
 };
 
 //*****************************************************************************
 // Create a class to handle db transactions using scope
 //
 // Don't let the database object get destroyed while this object exists,
 // that would result in undefined behavior.
 class MyMoneyDbTransaction
 {
 public:
   explicit MyMoneyDbTransaction(MyMoneyStorageSql& db, const QString& name) :
     m_db(db), m_name(name)
   {
     db.startCommitUnit(name);
   }
 
   ~MyMoneyDbTransaction()
   {
     if (std::uncaught_exception()) {
       m_db.cancelCommitUnit(m_name);
     } else {
       try{
         m_db.endCommitUnit(m_name);
-      } catch(MyMoneyException&) {
+      } catch (const MyMoneyException &) {
         try {
           m_db.cancelCommitUnit(m_name);
-        } catch (const MyMoneyException & e) {
+        } catch (const MyMoneyException &e) {
           qDebug() << e.what();
         }
       }
     }
   }
 private:
   MyMoneyStorageSql& m_db;
   QString m_name;
 };
 
 /**
   * The MyMoneySqlQuery class is derived from QSqlQuery to provide
   * a way to adjust some queries based on database type and make
   * debugging easier by providing a place to put debug statements.
   */
 class MyMoneySqlQuery : public QSqlQuery
 {
 public:
   explicit MyMoneySqlQuery(MyMoneyStorageSql* db = 0) :
     QSqlQuery(*db)
   {
   }
 
   virtual ~MyMoneySqlQuery()
   {
   }
 
   bool exec()
   {
     qDebug() << "start sql:" << lastQuery();
     bool rc = QSqlQuery::exec();
     qDebug() << "end sql:" << QSqlQuery::executedQuery();
     qDebug() << "***Query returned:" << rc << ", row count:" << numRowsAffected();
     return (rc);
   }
 
   bool exec(const QString & query)
   {
     qDebug() << "start sql:" << query;
     bool rc = QSqlQuery::exec(query);
     qDebug() << "end sql:" << QSqlQuery::executedQuery();
     qDebug() << "***Query returned:" << rc << ", row count:" << numRowsAffected();
     return rc;
   }
 
   bool prepare(const QString & query)
   {
     return (QSqlQuery::prepare(query));
   }
 };
 
 #define GETSTRING(a) query.value(a).toString()
 #define GETDATE(a) getDate(GETSTRING(a))
 #define GETDATE_D(a) d->getDate(GETSTRING(a))
 #define GETDATETIME(a) getDateTime(GETSTRING(a))
 #define GETINT(a) query.value(a).toInt()
 #define GETULL(a) query.value(a).toULongLong()
+#define MYMONEYEXCEPTIONSQL(exceptionMessage) MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, exceptionMessage))
+#define MYMONEYEXCEPTIONSQL_D(exceptionMessage) MYMONEYEXCEPTION(d->buildError(query, Q_FUNC_INFO, exceptionMessage))
 
 class MyMoneyStorageSqlPrivate
 {
   Q_DISABLE_COPY(MyMoneyStorageSqlPrivate)
   Q_DECLARE_PUBLIC(MyMoneyStorageSql)
 
 public:
   explicit MyMoneyStorageSqlPrivate(MyMoneyStorageSql* qq) :
     q_ptr(qq),
     m_dbVersion(0),
     m_storage(nullptr),
     m_loadAll(false),
     m_override(false),
     m_institutions(0),
     m_accounts(0),
     m_payees(0),
     m_tags(0),
     m_transactions(0),
     m_splits(0),
     m_securities(0),
     m_prices(0),
     m_currencies(0),
     m_schedules(0),
     m_reports(0),
     m_kvps(0),
     m_budgets(0),
     m_onlineJobs(0),
     m_payeeIdentifier(0),
     m_hiIdInstitutions(0),
     m_hiIdPayees(0),
     m_hiIdTags(0),
     m_hiIdAccounts(0),
     m_hiIdTransactions(0),
     m_hiIdSchedules(0),
     m_hiIdSecurities(0),
     m_hiIdReports(0),
     m_hiIdBudgets(0),
     m_hiIdOnlineJobs(0),
     m_hiIdPayeeIdentifier(0),
     m_hiIdCostCenter(0),
     m_displayStatus(false),
     m_readingPrices(false),
     m_newDatabase(false),
     m_progressCallback(nullptr)
   {
     m_preferred.setReportAllSplits(false);
   }
 
   ~MyMoneyStorageSqlPrivate()
   {
   }
 
   /**
    * MyMoneyStorageSql get highest ID number from the database
    *
    * @return : highest ID number
    */
   ulong highestNumberFromIdString(QString tableName, QString tableField, int prefixLength)
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
 
     if (!query.exec(m_driver->highestNumberFromIdString(tableName, tableField, prefixLength)) || !query.next())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("retrieving highest ID number"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("retrieving highest ID number");
 
     return query.value(0).toULongLong();
   }
 
   /**
    * @name writeFromStorageMethods
    * @{
    * These method write all data from m_storage to the database. Data which is
    * stored in the database is deleted.
    */
   void writeUserInformation();
 
   void writeInstitutions()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database
     // anything not in the list needs to be inserted
     // anything which is will be updated and removed from the list
     // anything left over at the end will need to be deleted
     // this is an expensive and inconvenient way to do things; find a better way
     // one way would be to build the lists when reading the db
     // unfortunately this object does not persist between read and write
     // it would also be nice if we could tell which objects had been updated since we read them in
     QList<QString> dbList;
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmInstitutions;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Institution list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Institution list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     const QList<MyMoneyInstitution> list = m_storage->institutionList();
     QList<MyMoneyInstitution> insertList;
     QList<MyMoneyInstitution> updateList;
     QSqlQuery query2(*q);
     query.prepare(m_db.m_tables["kmmInstitutions"].updateString());
     query2.prepare(m_db.m_tables["kmmInstitutions"].insertString());
     signalProgress(0, list.count(), "Writing Institutions...");
     foreach (const MyMoneyInstitution& i, list) {
       if (dbList.contains(i.id())) {
         dbList.removeAll(i.id());
         updateList << i;
       } else {
         insertList << i;
       }
       signalProgress(++m_institutions, 0);
     }
     if (!insertList.isEmpty())
       writeInstitutionList(insertList, query2);
 
     if (!updateList.isEmpty())
       writeInstitutionList(updateList, query);
 
     if (!dbList.isEmpty()) {
       QVariantList deleteList;
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         deleteList << it;
       }
       query.prepare("DELETE FROM kmmInstitutions WHERE id = :id");
       query.bindValue(":id", deleteList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Institution"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Institution");
 
       deleteKeyValuePairs("OFXSETTINGS", deleteList);
     }
   }
 
   void writePayees()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
 
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmPayees;");
     if (!query.exec())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Payee list")); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("building Payee list"); // krazy:exclude=crashy
 
     QList<QString> dbList;
     dbList.reserve(query.numRowsAffected());
     while (query.next())
       dbList.append(query.value(0).toString());
 
     QList<MyMoneyPayee> list = m_storage->payeeList();
     MyMoneyPayee user(QString("USER"), m_storage->user());
     list.prepend(user);
     signalProgress(0, list.count(), "Writing Payees...");
 
     Q_FOREACH(const MyMoneyPayee& it, list) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         q->modifyPayee(it);
       } else {
         q->addPayee(it);
       }
       signalProgress(++m_payees, 0);
     }
 
     if (!dbList.isEmpty()) {
       QMap<QString, MyMoneyPayee> payeesToDelete = q->fetchPayees(dbList, true);
       Q_FOREACH(const MyMoneyPayee& payee, payeesToDelete) {
         q->removePayee(payee);
       }
     }
   }
 
   void writeTags()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmTags;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Tag list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Tag list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     QList<MyMoneyTag> list = m_storage->tagList();
     signalProgress(0, list.count(), "Writing Tags...");
     QSqlQuery query2(*q);
     query.prepare(m_db.m_tables["kmmTags"].updateString());
     query2.prepare(m_db.m_tables["kmmTags"].insertString());
     foreach (const MyMoneyTag& it, list) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         writeTag(it, query);
       } else {
         writeTag(it, query2);
       }
       signalProgress(++m_tags, 0);
     }
 
     if (!dbList.isEmpty()) {
       QVariantList deleteList;
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         deleteList << it;
       }
       query.prepare(m_db.m_tables["kmmTags"].deleteString());
       query.bindValue(":id", deleteList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Tag"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Tag");
       m_tags -= query.numRowsAffected();
     }
   }
 
   void writeAccounts()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmAccounts;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Account list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Account list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     QList<MyMoneyAccount> list;
     m_storage->accountList(list);
     unsigned progress = 0;
     signalProgress(0, list.count(), "Writing Accounts...");
     if (dbList.isEmpty()) { // new table, insert standard accounts
       query.prepare(m_db.m_tables["kmmAccounts"].insertString());
     } else {
       query.prepare(m_db.m_tables["kmmAccounts"].updateString());
     }
     // Attempt to write the standard accounts. For an empty db, this will fail.
     try {
       QList<MyMoneyAccount> stdList;
       stdList << m_storage->asset();
       stdList << m_storage->liability();
       stdList << m_storage->expense();
       stdList << m_storage->income();
       stdList << m_storage->equity();
       writeAccountList(stdList, query);
       m_accounts += stdList.size();
     } catch (const MyMoneyException &) {
       // If the above failed, assume that the database is empty and create
       // the standard accounts by hand before writing them.
       MyMoneyAccount acc_l;
       acc_l.setAccountType(Account::Type::Liability);
       acc_l.setName("Liability");
       MyMoneyAccount liability(stdAccNames[stdAccLiability], acc_l);
 
       MyMoneyAccount acc_a;
       acc_a.setAccountType(Account::Type::Asset);
       acc_a.setName("Asset");
       MyMoneyAccount asset(stdAccNames[stdAccAsset], acc_a);
 
       MyMoneyAccount acc_e;
       acc_e.setAccountType(Account::Type::Expense);
       acc_e.setName("Expense");
       MyMoneyAccount expense(stdAccNames[stdAccExpense], acc_e);
 
       MyMoneyAccount acc_i;
       acc_i.setAccountType(Account::Type::Income);
       acc_i.setName("Income");
       MyMoneyAccount income(stdAccNames[stdAccIncome], acc_i);
 
       MyMoneyAccount acc_q;
       acc_q.setAccountType(Account::Type::Equity);
       acc_q.setName("Equity");
       MyMoneyAccount equity(stdAccNames[stdAccEquity], acc_q);
 
       QList<MyMoneyAccount> stdList;
       stdList << asset;
       stdList << liability;
       stdList << expense;
       stdList << income;
       stdList << equity;
       writeAccountList(stdList, query);
       m_accounts += stdList.size();
     }
 
     QSqlQuery query2(*q);
     query.prepare(m_db.m_tables["kmmAccounts"].updateString());
     query2.prepare(m_db.m_tables["kmmAccounts"].insertString());
     QList<MyMoneyAccount> updateList;
     QList<MyMoneyAccount> insertList;
     // Update the accounts that exist; insert the ones that do not.
     foreach (const MyMoneyAccount& it, list) {
       m_transactionCountMap[it.id()] = m_storage->transactionCount(it.id());
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         updateList << it;
       } else {
         insertList << it;
       }
       signalProgress(++progress, 0);
       ++m_accounts;
     }
 
     writeAccountList(updateList, query);
     writeAccountList(insertList, query2);
 
     // Delete the accounts that are in the db but no longer in memory.
     if (!dbList.isEmpty()) {
       QVariantList kvpList;
 
       query.prepare("DELETE FROM kmmAccounts WHERE id = :id");
       foreach (const QString& it, dbList) {
         if (!m_storage->isStandardAccount(it)) {
           kvpList << it;
         }
       }
       query.bindValue(":id", kvpList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Account"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Account");
 
       deleteKeyValuePairs("ACCOUNT", kvpList);
       deleteKeyValuePairs("ONLINEBANKING", kvpList);
     }
   }
 
   void writeTransactions()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmTransactions WHERE txType = 'N';");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Transaction list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Transaction list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     MyMoneyTransactionFilter filter;
     filter.setReportAllSplits(false);
     QList<MyMoneyTransaction> list;
     m_storage->transactionList(list, filter);
     signalProgress(0, list.count(), "Writing Transactions...");
     QSqlQuery q2(*q);
     query.prepare(m_db.m_tables["kmmTransactions"].updateString());
     q2.prepare(m_db.m_tables["kmmTransactions"].insertString());
     foreach (const MyMoneyTransaction& it, list) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         writeTransaction(it.id(), it, query, "N");
       } else {
         writeTransaction(it.id(), it, q2, "N");
       }
       signalProgress(++m_transactions, 0);
     }
 
     if (!dbList.isEmpty()) {
       foreach (const QString& it, dbList) {
         deleteTransaction(it);
       }
     }
   }
 
   void writeSchedules()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     query.prepare("SELECT id FROM kmmSchedules;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Schedule list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Schedule list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     const auto list = m_storage->scheduleList(QString(), Schedule::Type::Any, Schedule::Occurrence::Any, Schedule::PaymentType::Any,
                                               QDate(), QDate(), false);
     QSqlQuery query2(*q);
     //TODO: find a way to prepare the queries outside of the loop.  writeSchedule()
     // modifies the query passed to it, so they have to be re-prepared every pass.
     signalProgress(0, list.count(), "Writing Schedules...");
     foreach (const MyMoneySchedule& it, list) {
       query.prepare(m_db.m_tables["kmmSchedules"].updateString());
       query2.prepare(m_db.m_tables["kmmSchedules"].insertString());
       bool insert = true;
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         insert = false;
         writeSchedule(it, query, insert);
       } else {
         writeSchedule(it, query2, insert);
       }
       signalProgress(++m_schedules, 0);
     }
 
     if (!dbList.isEmpty()) {
       foreach (const QString& it, dbList) {
         deleteSchedule(it);
       }
     }
   }
 
   void writeSecurities()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     QSqlQuery query2(*q);
     query.prepare("SELECT id FROM kmmSecurities;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building security list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building security list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     const QList<MyMoneySecurity> securityList = m_storage->securityList();
     signalProgress(0, securityList.count(), "Writing Securities...");
     query.prepare(m_db.m_tables["kmmSecurities"].updateString());
     query2.prepare(m_db.m_tables["kmmSecurities"].insertString());
     foreach (const MyMoneySecurity& it, securityList) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         writeSecurity(it, query);
       } else {
         writeSecurity(it, query2);
       }
       signalProgress(++m_securities, 0);
     }
 
     if (!dbList.isEmpty()) {
       QVariantList idList;
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         idList << it;
       }
 
       query.prepare("DELETE FROM kmmSecurities WHERE id = :id");
       query2.prepare("DELETE FROM kmmPrices WHERE fromId = :id OR toId = :id");
       query.bindValue(":id", idList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Security"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Security");
 
       query2.bindValue(":fromId", idList);
       query2.bindValue(":toId", idList);
-      if (!query2.execBatch()) throw MYMONEYEXCEPTION(buildError(query2, Q_FUNC_INFO, "deleting Security"));
+      if (!query2.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Security");
 
       deleteKeyValuePairs("SECURITY", idList);
     }
   }
 
   void writePrices()
   {
     Q_Q(MyMoneyStorageSql);
     // due to difficulties in matching and determining deletes
     // easiest way is to delete all and re-insert
     QSqlQuery query(*q);
     query.prepare("DELETE FROM kmmPrices");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("deleting Prices"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("deleting Prices"); // krazy:exclude=crashy
     m_prices = 0;
 
     const MyMoneyPriceList list = m_storage->priceList();
     signalProgress(0, list.count(), "Writing Prices...");
     MyMoneyPriceList::ConstIterator it;
     for (it = list.constBegin(); it != list.constEnd(); ++it)   {
       writePricePair(*it);
     }
   }
 
   void writeCurrencies()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     QSqlQuery query2(*q);
     query.prepare("SELECT ISOCode FROM kmmCurrencies;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Currency list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Currency list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     const QList<MyMoneySecurity> currencyList = m_storage->currencyList();
     signalProgress(0, currencyList.count(), "Writing Currencies...");
     query.prepare(m_db.m_tables["kmmCurrencies"].updateString());
     query2.prepare(m_db.m_tables["kmmCurrencies"].insertString());
     foreach (const MyMoneySecurity& it, currencyList) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         writeCurrency(it, query);
       } else {
         writeCurrency(it, query2);
       }
       signalProgress(++m_currencies, 0);
     }
 
     if (!dbList.isEmpty()) {
       QVariantList isoCodeList;
       query.prepare("DELETE FROM kmmCurrencies WHERE ISOCode = :ISOCode");
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         isoCodeList << it;
       }
 
       query.bindValue(":ISOCode", isoCodeList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Currency"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Currency");
     }
   }
 
   void writeFileInfo()
   {
     Q_Q(MyMoneyStorageSql);
     // we have no real way of knowing when these change, so re-write them every time
     QVariantList kvpList;
     kvpList << "";
     QList<QMap<QString, QString> > pairs;
     pairs << m_storage->pairs();
     deleteKeyValuePairs("STORAGE", kvpList);
     writeKeyValuePairs("STORAGE", kvpList, pairs);
 
     QSqlQuery query(*q);
     query.prepare("SELECT count(*) FROM kmmFileInfo;");
     if (!query.exec() || !query.next())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "checking fileinfo")); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("checking fileinfo"); // krazy:exclude=crashy
 
     if (query.value(0).toInt() == 0) {
       // Cannot use "INSERT INTO kmmFileInfo DEFAULT VALUES;" because it is not supported by MySQL
       query.prepare(QLatin1String("INSERT INTO kmmFileInfo (version) VALUES (null);"));
-      if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "inserting fileinfo")); // krazy:exclude=crashy
+      if (!query.exec()) throw MYMONEYEXCEPTIONSQL("inserting fileinfo"); // krazy:exclude=crashy
     }
 
     query.prepare(QLatin1String(
       "UPDATE kmmFileInfo SET "
         "version = :version, "
         "fixLevel = :fixLevel, "
         "created = :created, "
         "lastModified = :lastModified, "
         "baseCurrency = :baseCurrency, "
         "dateRangeStart = :dateRangeStart, "
         "dateRangeEnd = :dateRangeEnd, "
         "hiInstitutionId = :hiInstitutionId, "
         "hiPayeeId = :hiPayeeId, "
         "hiTagId = :hiTagId, "
         "hiAccountId = :hiAccountId, "
         "hiTransactionId = :hiTransactionId, "
         "hiScheduleId = :hiScheduleId, "
         "hiSecurityId = :hiSecurityId, "
         "hiReportId = :hiReportId, "
         "hiBudgetId = :hiBudgetId, "
         "hiOnlineJobId = :hiOnlineJobId, "
         "hiPayeeIdentifierId = :hiPayeeIdentifierId, "
         "encryptData = :encryptData, "
         "updateInProgress = :updateInProgress, "
         "logonUser = :logonUser, "
         "logonAt = :logonAt, "
         //! @todo The following updates are for backwards compatibility only
         //! remove backwards compatibility in a later version
         "institutions = :institutions, "
         "accounts = :accounts, "
         "payees = :payees, "
         "tags = :tags, "
         "transactions = :transactions, "
         "splits = :splits, "
         "securities = :securities, "
         "prices = :prices, "
         "currencies = :currencies, "
         "schedules = :schedules, "
         "reports = :reports, "
         "kvps = :kvps, "
         "budgets = :budgets; "
       )
     );
 
     query.bindValue(":version", m_dbVersion);
     query.bindValue(":fixLevel", m_storage->fileFixVersion());
     query.bindValue(":created", m_storage->creationDate().toString(Qt::ISODate));
     //q.bindValue(":lastModified", m_storage->lastModificationDate().toString(Qt::ISODate));
     query.bindValue(":lastModified", QDate::currentDate().toString(Qt::ISODate));
     query.bindValue(":baseCurrency", m_storage->pairs()["kmm-baseCurrency"]);
     query.bindValue(":dateRangeStart", QDate());
     query.bindValue(":dateRangeEnd", QDate());
 
     //FIXME: This modifies all m_<variable> used in this function.
     // Sometimes the memory has been updated.
 
     // Should most of these be tracked in a view?
     // Variables actually needed are: version, fileFixVersion, creationDate,
     // baseCurrency, encryption, update info, and logon info.
     //try {
     //readFileInfo();
     //} catch (...) {
     //q->startCommitUnit(Q_FUNC_INFO);
     //}
 
     //! @todo The following bindings are for backwards compatibility only
     //! remove backwards compatibility in a later version
     query.bindValue(":hiInstitutionId", QVariant::fromValue(q->getNextInstitutionId()));
     query.bindValue(":hiPayeeId", QVariant::fromValue(q->getNextPayeeId()));
     query.bindValue(":hiTagId", QVariant::fromValue(q->getNextTagId()));
     query.bindValue(":hiAccountId", QVariant::fromValue(q->getNextAccountId()));
     query.bindValue(":hiTransactionId", QVariant::fromValue(q->getNextTransactionId()));
     query.bindValue(":hiScheduleId", QVariant::fromValue(q->getNextScheduleId()));
     query.bindValue(":hiSecurityId", QVariant::fromValue(q->getNextSecurityId()));
     query.bindValue(":hiReportId", QVariant::fromValue(q->getNextReportId()));
     query.bindValue(":hiBudgetId", QVariant::fromValue(q->getNextBudgetId()));
     query.bindValue(":hiOnlineJobId", QVariant::fromValue(q->getNextOnlineJobId()));
     query.bindValue(":hiPayeeIdentifierId", QVariant::fromValue(q->getNextPayeeIdentifierId()));
 
     query.bindValue(":encryptData", m_encryptData);
     query.bindValue(":updateInProgress", "N");
     query.bindValue(":logonUser", m_logonUser);
     query.bindValue(":logonAt", m_logonAt.toString(Qt::ISODate));
 
     //! @todo The following bindings are for backwards compatibility only
     //! remove backwards compatibility in a later version
     query.bindValue(":institutions", (unsigned long long) m_institutions);
     query.bindValue(":accounts", (unsigned long long) m_accounts);
     query.bindValue(":payees", (unsigned long long) m_payees);
     query.bindValue(":tags", (unsigned long long) m_tags);
     query.bindValue(":transactions", (unsigned long long) m_transactions);
     query.bindValue(":splits", (unsigned long long) m_splits);
     query.bindValue(":securities", (unsigned long long) m_securities);
     query.bindValue(":prices", (unsigned long long) m_prices);
     query.bindValue(":currencies", (unsigned long long) m_currencies);
     query.bindValue(":schedules", (unsigned long long) m_schedules);
     query.bindValue(":reports", (unsigned long long) m_reports);
     query.bindValue(":kvps", (unsigned long long) m_kvps);
     query.bindValue(":budgets", (unsigned long long) m_budgets);
 
     if (!query.exec())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing FileInfo"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("writing FileInfo"); // krazy:exclude=crashy
   }
 
   void writeReports()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     QSqlQuery query2(*q);
     query.prepare("SELECT id FROM kmmReportConfig;");
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Report list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Report list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toString());
 
     QList<MyMoneyReport> list = m_storage->reportList();
     signalProgress(0, list.count(), "Writing Reports...");
     query.prepare(m_db.m_tables["kmmReportConfig"].updateString());
     query2.prepare(m_db.m_tables["kmmReportConfig"].insertString());
     foreach (const MyMoneyReport& it, list) {
       if (dbList.contains(it.id())) {
         dbList.removeAll(it.id());
         writeReport(it, query);
       } else {
         writeReport(it, query2);
       }
       signalProgress(++m_reports, 0);
     }
 
     if (!dbList.isEmpty()) {
       QVariantList idList;
       query.prepare("DELETE FROM kmmReportConfig WHERE id = :id");
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         idList << it;
       }
 
       query.bindValue(":id", idList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Report"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Report");
     }
   }
 
   void writeBudgets()
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<QString> dbList;
     QSqlQuery query(*q);
     QSqlQuery query2(*q);
     query.prepare("SELECT name FROM kmmBudgetConfig;");
     if (!query.exec())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Budget list")); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("building Budget list"); // krazy:exclude=crashy
     while (query.next())
       dbList.append(query.value(0).toString());
 
     QList<MyMoneyBudget> list = m_storage->budgetList();
     signalProgress(0, list.count(), "Writing Budgets...");
     query.prepare(m_db.m_tables["kmmBudgetConfig"].updateString());
     query2.prepare(m_db.m_tables["kmmBudgetConfig"].insertString());
     foreach (const MyMoneyBudget& it, list) {
       if (dbList.contains(it.name())) {
         dbList.removeAll(it.name());
         writeBudget(it, query);
       } else {
         writeBudget(it, query2);
       }
       signalProgress(++m_budgets, 0);
     }
 
     if (!dbList.isEmpty()) {
       QVariantList idList;
       query.prepare("DELETE FROM kmmBudgetConfig WHERE id = :id");
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (const QString& it, dbList) {
         idList << it;
       }
 
       query.bindValue(":name", idList);
       if (!query.execBatch())
-        throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Budget"));
+        throw MYMONEYEXCEPTIONSQL("deleting Budget");
     }
   }
 
   void writeOnlineJobs()
   {
     Q_Q(MyMoneyStorageSql);
     QSqlQuery query(*q);
     if (!query.exec("DELETE FROM kmmOnlineJobs;"))
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QLatin1String("Clean kmmOnlineJobs table")));
+      throw MYMONEYEXCEPTIONSQL("Clean kmmOnlineJobs table");
 
     const QList<onlineJob> jobs(m_storage->onlineJobList());
     signalProgress(0, jobs.count(), i18n("Inserting online jobs."));
     // Create list for onlineJobs which failed and the reason therefor
     QList<QPair<onlineJob, QString> > failedJobs;
     int jobCount = 0;
     foreach (const onlineJob& job, jobs) {
       try {
         q->addOnlineJob(job);
-      } catch (MyMoneyException& e) {
+      } catch (const MyMoneyException &e) {
         // Do not save e as this may point to an inherited class
         failedJobs.append(QPair<onlineJob, QString>(job, e.what()));
         qDebug() << "Failed to save onlineJob" << job.id() << "Reson:" << e.what();
       }
 
       signalProgress(++jobCount, 0);
     }
 
     if (!failedJobs.isEmpty()) {
       /** @todo Improve error message */
-      throw MYMONEYEXCEPTION(i18np("Could not save one onlineJob.", "Could not save %1 onlineJobs.", failedJobs.count()));
+      throw MYMONEYEXCEPTION_CSTRING("Could not save onlineJob.");
     }
   }
   /** @} */
 
   /**
    * @name writeMethods
    * @{
    * These methods bind the data fields of MyMoneyObjects to a given query and execute the query.
    * This is helpfull as the query has usually an update and a insert format.
    */
   void writeInstitutionList(const QList<MyMoneyInstitution>& iList, QSqlQuery& query)
   {
     QVariantList idList;
     QVariantList nameList;
     QVariantList managerList;
     QVariantList routingCodeList;
     QVariantList addressStreetList;
     QVariantList addressCityList;
     QVariantList addressZipcodeList;
     QVariantList telephoneList;
     QList<QMap<QString, QString> > kvpPairsList;
 
     foreach (const MyMoneyInstitution& i, iList) {
       idList << i.id();
       nameList << i.name();
       managerList << i.manager();
       routingCodeList << i.sortcode();
       addressStreetList << i.street();
       addressCityList << i.city();
       addressZipcodeList << i.postcode();
       telephoneList << i.telephone();
       kvpPairsList << i.pairs();
     }
 
     query.bindValue(":id", idList);
     query.bindValue(":name", nameList);
     query.bindValue(":manager", managerList);
     query.bindValue(":routingCode", routingCodeList);
     query.bindValue(":addressStreet", addressStreetList);
     query.bindValue(":addressCity", addressCityList);
     query.bindValue(":addressZipcode", addressZipcodeList);
     query.bindValue(":telephone", telephoneList);
 
     if (!query.execBatch())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Institution")));
+      throw MYMONEYEXCEPTIONSQL("writing Institution");
     writeKeyValuePairs("OFXSETTINGS", idList, kvpPairsList);
     // Set m_hiIdInstitutions to 0 to force recalculation the next time it is requested
     m_hiIdInstitutions = 0;
   }
 
   void writePayee(const MyMoneyPayee& p, QSqlQuery& query, bool isUserInfo = false)
   {
     if (isUserInfo) {
       query.bindValue(":id", "USER");
     } else {
       query.bindValue(":id", p.id());
     }
     query.bindValue(":name", p.name());
     query.bindValue(":reference", p.reference());
     query.bindValue(":email", p.email());
     query.bindValue(":addressStreet", p.address());
     query.bindValue(":addressCity", p.city());
     query.bindValue(":addressZipcode", p.postcode());
     query.bindValue(":addressState", p.state());
     query.bindValue(":telephone", p.telephone());
     query.bindValue(":notes", p.notes());
     query.bindValue(":defaultAccountId", p.defaultAccountId());
     bool ignoreCase;
     QString matchKeys;
     MyMoneyPayee::payeeMatchType type = p.matchData(ignoreCase, matchKeys);
     query.bindValue(":matchData", static_cast<uint>(type));
 
     if (ignoreCase)
       query.bindValue(":matchIgnoreCase", "Y");
     else
       query.bindValue(":matchIgnoreCase", "N");
 
     query.bindValue(":matchKeys", matchKeys);
     if (!query.exec()) // krazy:exclude=crashy
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Payee"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("writing Payee"); // krazy:exclude=crashy
 
     if (!isUserInfo)
       m_hiIdPayees = 0;
   }
 
   void writeTag(const MyMoneyTag& ta, QSqlQuery& query)
   {
     query.bindValue(":id", ta.id());
     query.bindValue(":name", ta.name());
     query.bindValue(":tagColor", ta.tagColor().name());
     if (ta.isClosed()) query.bindValue(":closed", "Y");
     else query.bindValue(":closed", "N");
     query.bindValue(":notes", ta.notes());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Tag"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Tag"); // krazy:exclude=crashy
     m_hiIdTags = 0;
   }
 
   void writeAccountList(const QList<MyMoneyAccount>& accList, QSqlQuery& query)
   {
     //MyMoneyMoney balance = m_storagePtr->balance(acc.id(), QDate());
 
     QVariantList idList;
     QVariantList institutionIdList;
     QVariantList parentIdList;
     QVariantList lastReconciledList;
     QVariantList lastModifiedList;
     QVariantList openingDateList;
     QVariantList accountNumberList;
     QVariantList accountTypeList;
     QVariantList accountTypeStringList;
     QVariantList isStockAccountList;
     QVariantList accountNameList;
     QVariantList descriptionList;
     QVariantList currencyIdList;
     QVariantList balanceList;
     QVariantList balanceFormattedList;
     QVariantList transactionCountList;
 
     QList<QMap<QString, QString> > pairs;
     QList<QMap<QString, QString> > onlineBankingPairs;
 
     foreach (const MyMoneyAccount& a, accList) {
       idList << a.id();
       institutionIdList << a.institutionId();
       parentIdList << a.parentAccountId();
       if (a.lastReconciliationDate() == QDate())
         lastReconciledList << a.lastReconciliationDate();
       else
         lastReconciledList << a.lastReconciliationDate().toString(Qt::ISODate);
       lastModifiedList << a.lastModified();
       if (a.openingDate() == QDate())
         openingDateList << a.openingDate();
       else
         openingDateList << a.openingDate().toString(Qt::ISODate);
       accountNumberList << a.number();
       accountTypeList << (int)a.accountType();
       accountTypeStringList << MyMoneyAccount::accountTypeToString(a.accountType());
       if (a.accountType() == Account::Type::Stock)
         isStockAccountList << "Y";
       else
         isStockAccountList << "N";
       accountNameList << a.name();
       descriptionList << a.description();
       currencyIdList << a.currencyId();
       // This section attempts to get the balance from the database, if possible
       // That way, the balance fields are kept in sync. If that fails, then
       // It is assumed that the account actually knows its correct balance.
 
       //FIXME: Using exceptions for branching always feels like a kludge.
       //       Look for a better way.
       try {
         MyMoneyMoney bal = m_storage->balance(a.id(), QDate());
         balanceList << bal.toString();
         balanceFormattedList << bal.formatMoney("", -1, false);
       } catch (const MyMoneyException &) {
         balanceList << a.balance().toString();
         balanceFormattedList << a.balance().formatMoney("", -1, false);
       }
       transactionCountList << quint64(m_transactionCountMap[a.id()]);
 
       //MMAccount inherits from KVPContainer AND has a KVPContainer member
       //so handle both
       pairs << a.pairs();
       onlineBankingPairs << a.onlineBankingSettings().pairs();
     }
 
     query.bindValue(":id", idList);
     query.bindValue(":institutionId", institutionIdList);
     query.bindValue(":parentId", parentIdList);
     query.bindValue(":lastReconciled", lastReconciledList);
     query.bindValue(":lastModified", lastModifiedList);
     query.bindValue(":openingDate", openingDateList);
     query.bindValue(":accountNumber", accountNumberList);
     query.bindValue(":accountType", accountTypeList);
     query.bindValue(":accountTypeString", accountTypeStringList);
     query.bindValue(":isStockAccount", isStockAccountList);
     query.bindValue(":accountName", accountNameList);
     query.bindValue(":description", descriptionList);
     query.bindValue(":currencyId", currencyIdList);
     query.bindValue(":balance", balanceList);
     query.bindValue(":balanceFormatted", balanceFormattedList);
     query.bindValue(":transactionCount", transactionCountList);
 
     if (!query.execBatch())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Account")));
+      throw MYMONEYEXCEPTIONSQL("writing Account");
 
     //Add in Key-Value Pairs for accounts.
     writeKeyValuePairs("ACCOUNT", idList, pairs);
     writeKeyValuePairs("ONLINEBANKING", idList, onlineBankingPairs);
     m_hiIdAccounts = 0;
   }
 
   void writeTransaction(const QString& txId, const MyMoneyTransaction& tx, QSqlQuery& query, const QString& type)
   {
     query.bindValue(":id", txId);
     query.bindValue(":txType", type);
     query.bindValue(":postDate", tx.postDate().toString(Qt::ISODate));
     query.bindValue(":memo", tx.memo());
     query.bindValue(":entryDate", tx.entryDate().toString(Qt::ISODate));
     query.bindValue(":currencyId", tx.commodity());
     query.bindValue(":bankId", tx.bankID());
 
     if (!query.exec()) // krazy:exclude=crashy
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Transaction"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("writing Transaction"); // krazy:exclude=crashy
 
     m_txPostDate = tx.postDate(); // FIXME: TEMP till Tom puts date in split object
     QList<MyMoneySplit> splitList = tx.splits();
     writeSplits(txId, type, splitList);
 
     //Add in Key-Value Pairs for transactions.
     QVariantList idList;
     idList << txId;
     deleteKeyValuePairs("TRANSACTION", idList);
     QList<QMap<QString, QString> > pairs;
     pairs << tx.pairs();
     writeKeyValuePairs("TRANSACTION", idList, pairs);
     m_hiIdTransactions = 0;
   }
 
   void writeSplits(const QString& txId, const QString& type, const QList<MyMoneySplit>& splitList)
   {
     Q_Q(MyMoneyStorageSql);
     // first, get a list of what's on the database (see writeInstitutions)
     QList<uint> dbList;
     QList<MyMoneySplit> insertList;
     QList<MyMoneySplit> updateList;
     QList<int> insertIdList;
     QList<int> updateIdList;
     QSqlQuery query(*q);
     query.prepare("SELECT splitId FROM kmmSplits where transactionId = :id;");
     query.bindValue(":id", txId);
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "building Split list")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("building Split list"); // krazy:exclude=crashy
     while (query.next()) dbList.append(query.value(0).toUInt());
 
     QSqlQuery query2(*q);
     query.prepare(m_db.m_tables["kmmSplits"].updateString());
     query2.prepare(m_db.m_tables["kmmSplits"].insertString());
     auto i = 0;
     for (auto it = splitList.constBegin(); it != splitList.constEnd(); ++it) {
       if (dbList.contains(i)) {
         dbList.removeAll(i);
         updateList << *it;
         updateIdList << i;
       } else {
         ++m_splits;
         insertList << *it;
         insertIdList << i;
       }
       ++i;
     }
 
     if (!insertList.isEmpty()) {
       writeSplitList(txId, insertList, type, insertIdList, query2);
       writeTagSplitsList(txId, insertList, insertIdList);
     }
 
     if (!updateList.isEmpty()) {
       writeSplitList(txId, updateList, type, updateIdList, query);
       deleteTagSplitsList(txId, updateIdList);
       writeTagSplitsList(txId, updateList, updateIdList);
     }
 
     if (!dbList.isEmpty()) {
       QVector<QVariant> txIdList(dbList.count(), txId);
       QVariantList splitIdList;
       query.prepare("DELETE FROM kmmSplits WHERE transactionId = :txId AND splitId = :splitId");
       // qCopy segfaults here, so do it with a hand-rolled loop
       foreach (int it, dbList) {
         splitIdList << it;
       }
       query.bindValue(":txId", txIdList.toList());
       query.bindValue(":splitId", splitIdList);
-      if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Splits"));
+      if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Splits");
     }
   }
 
   void writeTagSplitsList
   (const QString& txId,
    const QList<MyMoneySplit>& splitList,
    const QList<int>& splitIdList)
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QVariantList tagIdList;
     QVariantList txIdList;
     QVariantList splitIdList_TagSplits;
     QVariantList tagSplitsIdList;
 
     int i = 0, l = 0;
     foreach (const MyMoneySplit& s, splitList) {
       for (l = 0; l < s.tagIdList().size(); ++l) {
         tagIdList << s.tagIdList()[l];
         splitIdList_TagSplits << splitIdList[i];
         txIdList << txId;
       }
       i++;
     }
     QSqlQuery query(*q);
     query.prepare(m_db.m_tables["kmmTagSplits"].insertString());
     query.bindValue(":tagId", tagIdList);
     query.bindValue(":splitId", splitIdList_TagSplits);
     query.bindValue(":transactionId", txIdList);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing tagSplits")));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("writing tagSplits");
   }
 
   void writeSplitList
   (const QString& txId,
    const QList<MyMoneySplit>& splitList,
    const QString& type,
    const QList<int>& splitIdList,
    QSqlQuery& query)
   {
     QVariantList txIdList;
     QVariantList typeList;
     QVariantList payeeIdList;
     QVariantList reconcileDateList;
     QVariantList actionList;
     QVariantList reconcileFlagList;
     QVariantList valueList;
     QVariantList valueFormattedList;
     QVariantList sharesList;
     QVariantList sharesFormattedList;
     QVariantList priceList;
     QVariantList priceFormattedList;
     QVariantList memoList;
     QVariantList accountIdList;
     QVariantList costCenterIdList;
     QVariantList checkNumberList;
     QVariantList postDateList;
     QVariantList bankIdList;
     QVariantList kvpIdList;
     QList<QMap<QString, QString> > kvpPairsList;
 
     int i = 0;
     foreach (const MyMoneySplit& s, splitList) {
       txIdList << txId;
       typeList << type;
       payeeIdList << s.payeeId();
       if (s.reconcileDate() == QDate())
         reconcileDateList << s.reconcileDate();
       else
         reconcileDateList << s.reconcileDate().toString(Qt::ISODate);
       actionList << s.action();
       reconcileFlagList << (int)s.reconcileFlag();
       valueList << s.value().toString();
       valueFormattedList << s.value().formatMoney("", -1, false).replace(QChar(','), QChar('.'));
       sharesList << s.shares().toString();
       MyMoneyAccount acc = m_storage->account(s.accountId());
       MyMoneySecurity sec = m_storage->security(acc.currencyId());
       sharesFormattedList << s.price().
       formatMoney("", MyMoneyMoney::denomToPrec(sec.smallestAccountFraction()), false).
       replace(QChar(','), QChar('.'));
       MyMoneyMoney price = s.actualPrice();
       if (!price.isZero()) {
         priceList << price.toString();
         priceFormattedList << price.formatMoney
         ("", sec.pricePrecision(), false)
         .replace(QChar(','), QChar('.'));
       } else {
         priceList << QString();
         priceFormattedList << QString();
       }
       memoList << s.memo();
       accountIdList << s.accountId();
       costCenterIdList << s.costCenterId();
       checkNumberList << s.number();
       postDateList << m_txPostDate.toString(Qt::ISODate); // FIXME: when Tom puts date into split object
       bankIdList << s.bankID();
 
       kvpIdList << QString(txId + QString::number(splitIdList[i]));
       kvpPairsList << s.pairs();
       ++i;
     }
 
     query.bindValue(":transactionId", txIdList);
     query.bindValue(":txType", typeList);
     QVariantList iList;
     // qCopy segfaults here, so do it with a hand-rolled loop
     foreach (int it_s, splitIdList) {
       iList << it_s;
     }
 
     query.bindValue(":splitId", iList);
     query.bindValue(":payeeId", payeeIdList);
     query.bindValue(":reconcileDate", reconcileDateList);
     query.bindValue(":action", actionList);
     query.bindValue(":reconcileFlag", reconcileFlagList);
     query.bindValue(":value", valueList);
     query.bindValue(":valueFormatted", valueFormattedList);
     query.bindValue(":shares", sharesList);
     query.bindValue(":sharesFormatted", sharesFormattedList);
     query.bindValue(":price", priceList);
     query.bindValue(":priceFormatted", priceFormattedList);
     query.bindValue(":memo", memoList);
     query.bindValue(":accountId", accountIdList);
     query.bindValue(":costCenterId", costCenterIdList);
     query.bindValue(":checkNumber", checkNumberList);
     query.bindValue(":postDate", postDateList);
     query.bindValue(":bankId", bankIdList);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Split")));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("writing Split");
     deleteKeyValuePairs("SPLIT", kvpIdList);
     writeKeyValuePairs("SPLIT", kvpIdList, kvpPairsList);
   }
 
   void writeSchedule(const MyMoneySchedule& sch, QSqlQuery& query, bool insert)
   {
     query.bindValue(":id", sch.id());
     query.bindValue(":name", sch.name());
     query.bindValue(":type", (int)sch.type());
     query.bindValue(":typeString", MyMoneySchedule::scheduleTypeToString(sch.type()));
     query.bindValue(":occurence", (int)sch.occurrencePeriod()); // krazy:exclude=spelling
     query.bindValue(":occurenceMultiplier", sch.occurrenceMultiplier()); // krazy:exclude=spelling
     query.bindValue(":occurenceString", sch.occurrenceToString()); // krazy:exclude=spelling
     query.bindValue(":paymentType", (int)sch.paymentType());
     query.bindValue(":paymentTypeString", MyMoneySchedule::paymentMethodToString(sch.paymentType()));
     query.bindValue(":startDate", sch.startDate().toString(Qt::ISODate));
     query.bindValue(":endDate", sch.endDate().toString(Qt::ISODate));
     if (sch.isFixed()) {
       query.bindValue(":fixed", "Y");
     } else {
       query.bindValue(":fixed", "N");
     }
     if (sch.lastDayInMonth()) {
       query.bindValue(":lastDayInMonth", "Y");
     } else {
       query.bindValue(":lastDayInMonth", "N");
     }
     if (sch.autoEnter()) {
       query.bindValue(":autoEnter", "Y");
     } else {
       query.bindValue(":autoEnter", "N");
     }
     query.bindValue(":lastPayment", sch.lastPayment());
     query.bindValue(":nextPaymentDue", sch.nextDueDate().toString(Qt::ISODate));
     query.bindValue(":weekendOption", (int)sch.weekendOption());
     query.bindValue(":weekendOptionString", MyMoneySchedule::weekendOptionToString(sch.weekendOption()));
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Schedules"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Schedules"); // krazy:exclude=crashy
 
     //store the payment history for this scheduled task.
     //easiest way is to delete all and re-insert; it's not a high use table
     query.prepare("DELETE FROM kmmSchedulePaymentHistory WHERE schedId = :id;");
     query.bindValue(":id", sch.id());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("deleting  Schedule Payment History"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("deleting  Schedule Payment History"); // krazy:exclude=crashy
 
     query.prepare(m_db.m_tables["kmmSchedulePaymentHistory"].insertString());
     foreach (const QDate& it, sch.recordedPayments()) {
       query.bindValue(":schedId", sch.id());
       query.bindValue(":payDate", it.toString(Qt::ISODate));
-      if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Schedule Payment History"))); // krazy:exclude=crashy
+      if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Schedule Payment History"); // krazy:exclude=crashy
     }
 
     //store the transaction data for this task.
     if (!insert) {
       query.prepare(m_db.m_tables["kmmTransactions"].updateString());
     } else {
       query.prepare(m_db.m_tables["kmmTransactions"].insertString());
     }
     writeTransaction(sch.id(), sch.transaction(), query, "S");
 
     //FIXME: enable when schedules have KVPs.
 
     //Add in Key-Value Pairs for transactions.
     //deleteKeyValuePairs("SCHEDULE", sch.id());
     //writeKeyValuePairs("SCHEDULE", sch.id(), sch.pairs());
   }
 
   void writeSecurity(const MyMoneySecurity& security, QSqlQuery& query)
   {
     query.bindValue(":id", security.id());
     query.bindValue(":name", security.name());
     query.bindValue(":symbol", security.tradingSymbol());
     query.bindValue(":type", static_cast<int>(security.securityType()));
     query.bindValue(":typeString", MyMoneySecurity::securityTypeToString(security.securityType()));
     query.bindValue(":roundingMethod", static_cast<int>(security.roundingMethod()));
     query.bindValue(":smallestAccountFraction", security.smallestAccountFraction());
     query.bindValue(":pricePrecision", security.pricePrecision());
     query.bindValue(":tradingCurrency", security.tradingCurrency());
     query.bindValue(":tradingMarket", security.tradingMarket());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Securities"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Securities"); // krazy:exclude=crashy
 
     //Add in Key-Value Pairs for security
     QVariantList idList;
     idList << security.id();
     QList<QMap<QString, QString> > pairs;
     pairs << security.pairs();
     writeKeyValuePairs("SECURITY", idList, pairs);
     m_hiIdSecurities = 0;
   }
 
   void writePricePair(const MyMoneyPriceEntries& p)
   {
     MyMoneyPriceEntries::ConstIterator it;
     for (it = p.constBegin(); it != p.constEnd(); ++it) {
       writePrice(*it);
       signalProgress(++m_prices, 0);
     }
   }
 
   void writePrice(const MyMoneyPrice& p)
   {
     Q_Q(MyMoneyStorageSql);
     QSqlQuery query(*q);
     query.prepare(m_db.m_tables["kmmPrices"].insertString());
     query.bindValue(":fromId", p.from());
     query.bindValue(":toId", p.to());
     query.bindValue(":priceDate", p.date().toString(Qt::ISODate));
     query.bindValue(":price", p.rate(QString()).toString());
     query.bindValue(":priceFormatted", p.rate(QString()).formatMoney("", 2));
     query.bindValue(":priceSource", p.source());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Prices"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Prices"); // krazy:exclude=crashy
   }
 
   void writeCurrency(const MyMoneySecurity& currency, QSqlQuery& query)
   {
     query.bindValue(":ISOcode", currency.id());
     query.bindValue(":name", currency.name());
     query.bindValue(":type", static_cast<int>(currency.securityType()));
     query.bindValue(":typeString", MyMoneySecurity::securityTypeToString(currency.securityType()));
     // writing the symbol as three short ints is a PITA, but the
     // problem is that database drivers have incompatible ways of declaring UTF8
     QString symbol = currency.tradingSymbol() + "   ";
     const ushort* symutf = symbol.utf16();
     //int ix = 0;
     //while (x[ix] != '\0') qDebug() << "symbol" << symbol << "char" << ix << "=" << x[ix++];
     //q.bindValue(":symbol1", symbol.mid(0,1).unicode()->unicode());
     //q.bindValue(":symbol2", symbol.mid(1,1).unicode()->unicode());
     //q.bindValue(":symbol3", symbol.mid(2,1).unicode()->unicode());
     query.bindValue(":symbol1", symutf[0]);
     query.bindValue(":symbol2", symutf[1]);
     query.bindValue(":symbol3", symutf[2]);
     query.bindValue(":symbolString", symbol);
     query.bindValue(":smallestCashFraction", currency.smallestCashFraction());
     query.bindValue(":smallestAccountFraction", currency.smallestAccountFraction());
     query.bindValue(":pricePrecision", currency.pricePrecision());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Currencies"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Currencies"); // krazy:exclude=crashy
   }
 
   void writeReport(const MyMoneyReport& rep, QSqlQuery& query)
   {
     QDomDocument d; // create a dummy XML document
     QDomElement e = d.createElement("REPORTS");
     d.appendChild(e);
     rep.writeXML(d, e); // write the XML to document
     query.bindValue(":id", rep.id());
     query.bindValue(":name", rep.name());
     query.bindValue(":XML", d.toString());
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Reports"))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("writing Reports"); // krazy:exclude=crashy
   }
 
   void writeBudget(const MyMoneyBudget& bud, QSqlQuery& query)
   {
     QDomDocument d; // create a dummy XML document
     QDomElement e = d.createElement("BUDGETS");
     d.appendChild(e);
     bud.writeXML(d, e); // write the XML to document
     query.bindValue(":id", bud.id());
     query.bindValue(":name", bud.name());
     query.bindValue(":start", bud.budgetStart());
     query.bindValue(":XML", d.toString());
     if (!query.exec()) // krazy:exclude=crashy
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing Budgets"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("writing Budgets"); // krazy:exclude=crashy
   }
 
   void writeKeyValuePairs(const QString& kvpType, const QVariantList& kvpId, const QList<QMap<QString, QString> >& pairs)
   {
     Q_Q(MyMoneyStorageSql);
     if (pairs.empty())
       return;
 
     QVariantList type;
     QVariantList id;
     QVariantList key;
     QVariantList value;
     int pairCount = 0;
 
     for (int i = 0; i < kvpId.size(); ++i) {
       QMap<QString, QString>::ConstIterator it;
       for (it = pairs[i].constBegin(); it != pairs[i].constEnd(); ++it) {
         type << kvpType;
         id << kvpId[i];
         key << it.key();
         value << it.value();
       }
       pairCount += pairs[i].size();
     }
 
     QSqlQuery query(*q);
     query.prepare(m_db.m_tables["kmmKeyValuePairs"].insertString());
     query.bindValue(":kvpType", type);
     query.bindValue(":kvpId", id);
     query.bindValue(":kvpKey", key);
     query.bindValue(":kvpData", value);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("writing KVP")));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("writing KVP");
     m_kvps += pairCount;
   }
 
   void writeOnlineJob(const onlineJob& job, QSqlQuery& query)
   {
     Q_ASSERT(job.id().startsWith('O'));
 
     query.bindValue(":id", job.id());
     query.bindValue(":type", job.taskIid());
     query.bindValue(":jobSend", job.sendDate());
     query.bindValue(":bankAnswerDate", job.bankAnswerDate());
     switch (job.bankAnswerState()) {
       case onlineJob::acceptedByBank: query.bindValue(":state", QLatin1String("acceptedByBank")); break;
       case onlineJob::rejectedByBank: query.bindValue(":state", QLatin1String("rejectedByBank")); break;
       case onlineJob::abortedByUser: query.bindValue(":state", QLatin1String("abortedByUser")); break;
       case onlineJob::sendingError: query.bindValue(":state", QLatin1String("sendingError")); break;
       case onlineJob::noBankAnswer:
       default: query.bindValue(":state", QLatin1String("noBankAnswer"));
     }
     query.bindValue(":locked", QVariant::fromValue<QString>(job.isLocked() ? QLatin1String("Y") : QLatin1String("N")));
   }
 
   void writePayeeIdentifier(const payeeIdentifier& pid, QSqlQuery& query)
   {
     query.bindValue(":id", pid.idString());
     query.bindValue(":type", pid.iid());
     if (!query.exec()) { // krazy:exclude=crashy
       qWarning() << buildError(query, Q_FUNC_INFO, QString("modifying payeeIdentifier"));
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("modifying payeeIdentifier"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("modifying payeeIdentifier"); // krazy:exclude=crashy
     }
   }
     /** @} */
 
   /**
    * @name readMethods
    * @{
    */
   void readFileInfo()
   {
     Q_Q(MyMoneyStorageSql);
     signalProgress(0, 1, QObject::tr("Loading file information..."));
 
     QSqlQuery query(*q);
 
     query.prepare(
       "SELECT "
       "  created, lastModified, "
       "  encryptData, logonUser, logonAt, "
       "  (SELECT count(*) FROM kmmInstitutions) AS institutions, "
       "  (SELECT count(*) from kmmAccounts) AS accounts, "
       "  (SELECT count(*) FROM kmmCurrencies) AS currencies, "
       "  (SELECT count(*) FROM kmmPayees) AS payees, "
       "  (SELECT count(*) FROM kmmTags) AS tags, "
       "  (SELECT count(*) FROM kmmTransactions) AS transactions, "
       "  (SELECT count(*) FROM kmmSplits) AS splits, "
       "  (SELECT count(*) FROM kmmSecurities) AS securities, "
       "  (SELECT count(*) FROM kmmCurrencies) AS currencies, "
       "  (SELECT count(*) FROM kmmSchedules) AS schedules, "
       "  (SELECT count(*) FROM kmmPrices) AS prices, "
       "  (SELECT count(*) FROM kmmKeyValuePairs) AS kvps, "
       "  (SELECT count(*) FROM kmmReportConfig) AS reports, "
       "  (SELECT count(*) FROM kmmBudgetConfig) AS budgets, "
       "  (SELECT count(*) FROM kmmOnlineJobs) AS onlineJobs, "
       "  (SELECT count(*) FROM kmmPayeeIdentifier) AS payeeIdentifier "
       "FROM kmmFileInfo;"
     );
 
     if (!query.exec())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("reading FileInfo"))); // krazy:exclude=crashy
+      throw MYMONEYEXCEPTIONSQL("reading FileInfo"); // krazy:exclude=crashy
     if (!query.next())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("retrieving FileInfo")));
+      throw MYMONEYEXCEPTIONSQL("retrieving FileInfo");
 
     QSqlRecord rec = query.record();
     m_storage->setCreationDate(GETDATE(rec.indexOf("created")));
     m_storage->setLastModificationDate(GETDATE(rec.indexOf("lastModified")));
 
     m_institutions = (ulong) GETULL(rec.indexOf("institutions"));
     m_accounts = (ulong) GETULL(rec.indexOf("accounts"));
     m_payees = (ulong) GETULL(rec.indexOf("payees"));
     m_tags = (ulong) GETULL(rec.indexOf("tags"));
     m_transactions = (ulong) GETULL(rec.indexOf("transactions"));
     m_splits = (ulong) GETULL(rec.indexOf("splits"));
     m_securities = (ulong) GETULL(rec.indexOf("securities"));
     m_currencies = (ulong) GETULL(rec.indexOf("currencies"));
     m_schedules = (ulong) GETULL(rec.indexOf("schedules"));
     m_prices = (ulong) GETULL(rec.indexOf("prices"));
     m_kvps = (ulong) GETULL(rec.indexOf("kvps"));
     m_reports = (ulong) GETULL(rec.indexOf("reports"));
     m_budgets = (ulong) GETULL(rec.indexOf("budgets"));
     m_onlineJobs = (ulong) GETULL(rec.indexOf("onlineJobs"));
     m_payeeIdentifier = (ulong) GETULL(rec.indexOf("payeeIdentifier"));
 
     m_encryptData = GETSTRING(rec.indexOf("encryptData"));
     m_logonUser = GETSTRING(rec.indexOf("logonUser"));
     m_logonAt = GETDATETIME(rec.indexOf("logonAt"));
 
     signalProgress(1, 0);
     m_storage->setPairs(readKeyValuePairs("STORAGE", QString("")).pairs());
   }
 
   void readLogonData();
   void readUserInformation();
 
   void readInstitutions()
   {
     Q_Q(MyMoneyStorageSql);
     try {
       QMap<QString, MyMoneyInstitution> iList = q->fetchInstitutions();
       m_storage->loadInstitutions(iList);
       readFileInfo();
     } catch (const MyMoneyException &) {
       throw;
     }
   }
 
   void readAccounts()
   {
     Q_Q(MyMoneyStorageSql);
     m_storage->loadAccounts(q->fetchAccounts());
   }
 
   void readTransactions(const QString& tidList, const QString& dateClause)
   {
     Q_Q(MyMoneyStorageSql);
     try {
       m_storage->loadTransactions(q->fetchTransactions(tidList, dateClause));
     } catch (const MyMoneyException &) {
       throw;
     }
   }
 
   void readTransactions()
   {
     readTransactions(QString(), QString());
   }
 
   void readSplit(MyMoneySplit& s, const QSqlQuery& query) const
   {
     Q_Q(const MyMoneyStorageSql);
     // Set these up as statics, since the field numbers should not change
     // during execution.
     static const MyMoneyDbTable& t = m_db.m_tables["kmmSplits"];
     static const int splitIdCol = t.fieldNumber("splitId");
     static const int transactionIdCol = t.fieldNumber("transactionId");
     static const int payeeIdCol = t.fieldNumber("payeeId");
     static const int reconcileDateCol = t.fieldNumber("reconcileDate");
     static const int actionCol = t.fieldNumber("action");
     static const int reconcileFlagCol = t.fieldNumber("reconcileFlag");
     static const int valueCol = t.fieldNumber("value");
     static const int sharesCol = t.fieldNumber("shares");
     static const int priceCol = t.fieldNumber("price");
     static const int memoCol = t.fieldNumber("memo");
     static const int accountIdCol = t.fieldNumber("accountId");
     static const int costCenterIdCol = t.fieldNumber("costCenterId");
     static const int checkNumberCol = t.fieldNumber("checkNumber");
   //  static const int postDateCol = t.fieldNumber("postDate"); // FIXME - when Tom puts date into split object
     static const int bankIdCol = t.fieldNumber("bankId");
 
     s.clearId();
 
     QList<QString> tagIdList;
     QSqlQuery query1(*const_cast <MyMoneyStorageSql*>(q));
     query1.prepare("SELECT tagId from kmmTagSplits where splitId = :id and transactionId = :transactionId");
     query1.bindValue(":id", GETSTRING(splitIdCol));
     query1.bindValue(":transactionId", GETSTRING(transactionIdCol));
-    if (!query1.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("reading tagId in Split"))); // krazy:exclude=crashy
+    if (!query1.exec()) throw MYMONEYEXCEPTIONSQL("reading tagId in Split"); // krazy:exclude=crashy
     while (query1.next())
       tagIdList << query1.value(0).toString();
 
     s.setTagIdList(tagIdList);
     s.setPayeeId(GETSTRING(payeeIdCol));
     s.setReconcileDate(GETDATE(reconcileDateCol));
     s.setAction(GETSTRING(actionCol));
     s.setReconcileFlag(static_cast<Split::State>(GETINT(reconcileFlagCol)));
     s.setValue(MyMoneyMoney(MyMoneyUtils::QStringEmpty(GETSTRING(valueCol))));
     s.setShares(MyMoneyMoney(MyMoneyUtils::QStringEmpty(GETSTRING(sharesCol))));
     s.setPrice(MyMoneyMoney(MyMoneyUtils::QStringEmpty(GETSTRING(priceCol))));
     s.setMemo(GETSTRING(memoCol));
     s.setAccountId(GETSTRING(accountIdCol));
     s.setCostCenterId(GETSTRING(costCenterIdCol));
     s.setNumber(GETSTRING(checkNumberCol));
     //s.setPostDate(GETDATETIME(postDateCol)); // FIXME - when Tom puts date into split object
     s.setBankID(GETSTRING(bankIdCol));
 
     return;
   }
 
   const MyMoneyKeyValueContainer readKeyValuePairs(const QString& kvpType, const QString& kvpId) const
   {
     Q_Q(const MyMoneyStorageSql);
     MyMoneyKeyValueContainer list;
     QSqlQuery query(*const_cast <MyMoneyStorageSql*>(q));
     query.prepare("SELECT kvpKey, kvpData from kmmKeyValuePairs where kvpType = :type and kvpId = :id;");
     query.bindValue(":type", kvpType);
     query.bindValue(":id", kvpId);
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("reading Kvp for %1 %2").arg(kvpType) // krazy:exclude=crashy
-                                            .arg(kvpId)));
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("reading Kvp for %1 %2").arg(kvpType) // krazy:exclude=crashy
+                                            .arg(kvpId));
     while (query.next()) list.setValue(query.value(0).toString(), query.value(1).toString());
     return (list);
   }
 
   const QHash<QString, MyMoneyKeyValueContainer> readKeyValuePairs(const QString& kvpType, const QStringList& kvpIdList) const
   {
     Q_Q(const MyMoneyStorageSql);
     QHash<QString, MyMoneyKeyValueContainer> retval;
 
     QSqlQuery query(*const_cast <MyMoneyStorageSql*>(q));
 
     QString idList;
     if (!kvpIdList.empty()) {
       idList = QString(" and kvpId IN ('%1')").arg(kvpIdList.join("', '"));
     }
 
     QString sQuery = QString("SELECT kvpId, kvpKey, kvpData from kmmKeyValuePairs where kvpType = :type %1 order by kvpId;").arg(idList);
 
     query.prepare(sQuery);
     query.bindValue(":type", kvpType);
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("reading Kvp List for %1").arg(kvpType))); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("reading Kvp List for %1").arg(kvpType)); // krazy:exclude=crashy
 
     // Reserve enough space for all values.
     retval.reserve(kvpIdList.size());
 
     // The loop below is designed to limit the number of calls to
     // QHash::operator[] in order to speed up calls to this function. This
     // assumes that QString::operator== is faster.
     /*
       if (q.next()) {
         QString oldkey = q.value(0).toString();
         MyMoneyKeyValueContainer& kvpc = retval[oldkey];
 
         kvpc.setValue(q.value(1).toString(), q.value(2).toString());
 
         while (q.next()) {
           if (q.value(0).toString() != oldkey) {
             oldkey = q.value(0).toString();
             kvpc = retval[oldkey];
           }
           kvpc.setValue(q.value(1).toString(), q.value(2).toString());
         }
       }
     */
     while (query.next()) {
       retval[query.value(0).toString()].setValue(query.value(1).toString(), query.value(2).toString());
     }
     return (retval);
   }
 
   void readSchedules()
   {
     Q_Q(MyMoneyStorageSql);
     try {
       m_storage->loadSchedules(q->fetchSchedules());
     } catch (const MyMoneyException &) {
       throw;
     }
 
   }
 
   void readSecurities()
   {
     Q_Q(MyMoneyStorageSql);
     try {
       m_storage->loadSecurities(q->fetchSecurities());
     } catch (const MyMoneyException &) {
       throw;
     }
 
   }
 
   void readPrices()
   {
   //  try {
   //    m_storage->addPrice(MyMoneyPrice(from, to,  date, rate, source));
   //  } catch (const MyMoneyException &) {
   //    throw;
   //  }
   }
 
   void readCurrencies()
   {
     Q_Q(MyMoneyStorageSql);
     try {
       m_storage->loadCurrencies(q->fetchCurrencies());
     } catch (const MyMoneyException &) {
       throw;
     }
   }
 
   void readReports()
   {
     Q_Q(MyMoneyStorageSql);
     try {
       m_storage->loadReports(q->fetchReports());
     } catch (const MyMoneyException &) {
       throw;
     }
   }
 
   void readBudgets()
   {
     Q_Q(MyMoneyStorageSql);
     m_storage->loadBudgets(q->fetchBudgets());
   }
 
   /** @} */
 
   void deleteTransaction(const QString& id)
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     QVariantList idList;
     idList << id;
     query.prepare("DELETE FROM kmmSplits WHERE transactionId = :transactionId;");
     query.bindValue(":transactionId", idList);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Splits"));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Splits");
 
     query.prepare("DELETE FROM kmmKeyValuePairs WHERE kvpType = 'SPLIT' "
               "AND kvpId LIKE '?%'");
     query.bindValue(1, idList);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Splits KVP"));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting Splits KVP");
 
     m_splits -= query.numRowsAffected();
     deleteKeyValuePairs("TRANSACTION", idList);
     query.prepare(m_db.m_tables["kmmTransactions"].deleteString());
     query.bindValue(":id", idList);
     if (!query.execBatch())
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Transaction"));
+      throw MYMONEYEXCEPTIONSQL("deleting Transaction");
   }
 
   void deleteTagSplitsList(const QString& txId, const QList<int>& splitIdList)
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QVariantList iList;
     QVariantList transactionIdList;
 
     // qCopy segfaults here, so do it with a hand-rolled loop
     foreach (int it_s, splitIdList) {
       iList << it_s;
       transactionIdList << txId;
     }
     QSqlQuery query(*q);
     query.prepare("DELETE FROM kmmTagSplits WHERE transactionId = :transactionId AND splitId = :splitId");
     query.bindValue(":splitId", iList);
     query.bindValue(":transactionId", transactionIdList);
-    if (!query.execBatch()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("deleting tagSplits")));
+    if (!query.execBatch()) throw MYMONEYEXCEPTIONSQL("deleting tagSplits");
   }
 
   void deleteSchedule(const QString& id)
   {
     Q_Q(MyMoneyStorageSql);
     deleteTransaction(id);
     QSqlQuery query(*q);
     query.prepare("DELETE FROM kmmSchedulePaymentHistory WHERE schedId = :id");
     query.bindValue(":id", id);
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Schedule Payment History")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("deleting Schedule Payment History"); // krazy:exclude=crashy
     query.prepare(m_db.m_tables["kmmSchedules"].deleteString());
     query.bindValue(":id", id);
-    if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "deleting Schedule")); // krazy:exclude=crashy
+    if (!query.exec()) throw MYMONEYEXCEPTIONSQL("deleting Schedule"); // krazy:exclude=crashy
     //FIXME: enable when schedules have KVPs.
     //deleteKeyValuePairs("SCHEDULE", id);
   }
 
   void deleteKeyValuePairs(const QString& kvpType, const QVariantList& idList)
   {
     Q_Q(MyMoneyStorageSql);
     QSqlQuery query(*q);
     query.prepare("DELETE FROM kmmKeyValuePairs WHERE kvpType = :kvpType AND kvpId = :kvpId;");
     QVariantList typeList;
     for (int i = 0; i < idList.size(); ++i) {
       typeList << kvpType;
     }
     query.bindValue(":kvpType", typeList);
     query.bindValue(":kvpId", idList);
     if (!query.execBatch()) {
       QString idString;
       for (int i = 0; i < idList.size(); ++i) {
         idString.append(idList[i].toString() + ' ');
       }
-      throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("deleting kvp for %1 %2").arg(kvpType).arg(idString)));
+      throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("deleting kvp for %1 %2").arg(kvpType).arg(idString));
     }
     m_kvps -= query.numRowsAffected();
   }
 
   ulong calcHighId(ulong i, const QString& id)
   {
     QString nid = id;
     ulong high = (ulong) nid.remove(QRegExp("[A-Z]*")).toULongLong();
     return std::max(high, i);
   }
 
   void setVersion(const QString& version);
 
   int splitState(const TransactionFilter::State& state) const
   {
     auto rc = (int)Split::State::NotReconciled;
 
     switch (state) {
       default:
       case TransactionFilter::State::NotReconciled:
         break;
 
       case TransactionFilter::State::Cleared:
         rc = (int)Split::State::Cleared;
         break;
 
       case TransactionFilter::State::Reconciled:
         rc = (int)Split::State::Reconciled;
         break;
 
       case TransactionFilter::State::Frozen:
         rc = (int)Split::State::Frozen;
         break;
     }
     return rc;
   }
 
   QDate getDate(const QString& date) const
   {
     return (date.isNull() ? QDate() : QDate::fromString(date, Qt::ISODate));
   }
 
   QDateTime getDateTime(const QString& date) const
   {
     return (date.isNull() ? QDateTime() : QDateTime::fromString(date, Qt::ISODate));
   }
 
   bool fileExists(const QString& dbName)
   {
     QFile f(dbName);
     if (!f.exists()) {
       m_error = i18n("SQLite file %1 does not exist", dbName);
       return (false);
     }
     return (true);
   }
 
   /** @brief a function to build a comprehensive error message for an SQL error */
   QString& buildError(const QSqlQuery& query, const QString& function,
                                          const QString& messageb) const
   {
     Q_Q(const MyMoneyStorageSql);
     return (buildError(query, function, messageb, q));
   }
 
   QString& buildError(const QSqlQuery& query, const QString& function,
                                          const QString& message, const QSqlDatabase* db) const
   {
     Q_Q(const MyMoneyStorageSql);
     QString s = QString("Error in function %1 : %2").arg(function).arg(message);
     s += QString("\nDriver = %1, Host = %2, User = %3, Database = %4")
          .arg(db->driverName()).arg(db->hostName()).arg(db->userName()).arg(db->databaseName());
     QSqlError e = db->lastError();
     s += QString("\nDriver Error: %1").arg(e.driverText());
     s += QString("\nDatabase Error No %1: %2").arg(e.number()).arg(e.databaseText());
     s += QString("\nText: %1").arg(e.text());
     s += QString("\nError type %1").arg(e.type());
     e = query.lastError();
     s += QString("\nExecuted: %1").arg(query.executedQuery());
     s += QString("\nQuery error No %1: %2").arg(e.number()).arg(e.text());
     s += QString("\nError type %1").arg(e.type());
 
     const_cast <MyMoneyStorageSql*>(q)->d_func()->m_error = s;
     qDebug("%s", qPrintable(s));
     const_cast <MyMoneyStorageSql*>(q)->cancelCommitUnit(function);
     return (const_cast <MyMoneyStorageSql*>(q)->d_func()->m_error);
   }
 
   /**
    * MyMoneyStorageSql create database
    *
    * @param url pseudo-URL of database to be opened
    *
    * @return true - creation successful
    * @return false - could not create
    *
    */
 
   bool createDatabase(const QUrl &url)
   {
     Q_Q(MyMoneyStorageSql);
     int rc = true;
     if (!m_driver->requiresCreation()) return(true); // not needed for sqlite
     QString dbName = url.path().right(url.path().length() - 1); // remove separator slash
     if (!m_driver->canAutocreate()) {
       m_error = i18n("Automatic database creation for type %1 is not currently implemented.\n"
                      "Please create database %2 manually", q->driverName(), dbName);
       return (false);
     }
     // create the database (only works for mysql and postgre at present)
     { // for this code block, see QSqlDatabase API re removeDatabase
       QSqlDatabase maindb = QSqlDatabase::addDatabase(q->driverName(), "main");
       maindb.setDatabaseName(m_driver->defaultDbName());
       maindb.setHostName(url.host());
       maindb.setUserName(url.userName());
       maindb.setPassword(url.password());
       if (!maindb.open()) {
-        throw MYMONEYEXCEPTION(QString("opening database %1 in function %2")
-                               .arg(maindb.databaseName()).arg(Q_FUNC_INFO));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("opening database %1 in function %2")
+                                  .arg(maindb.databaseName()).arg(Q_FUNC_INFO));
       } else {
         QSqlQuery qm(maindb);
         QString qs = m_driver->createDbString(dbName) + ';';
         if (!qm.exec(qs)) { // krazy:exclude=crashy
           buildError(qm, Q_FUNC_INFO,
                      i18n("Error in create database %1; do you have create permissions?", dbName), &maindb);
           rc = false;
         }
         maindb.close();
       }
     }
     QSqlDatabase::removeDatabase("main");
     return (rc);
   }
 
 
   int upgradeDb()
   {
     Q_Q(MyMoneyStorageSql);
     //signalProgress(0, 1, QObject::tr("Upgrading database..."));
     QSqlQuery query(*q);
     query.prepare("SELECT version FROM kmmFileInfo;");
     if (!query.exec() || !query.next()) { // krazy:exclude=crashy
       if (!m_newDatabase) {
         buildError(query, Q_FUNC_INFO, "Error retrieving file info (version)");
         return(1);
       } else {
         m_dbVersion = m_db.currentVersion();
         m_storage->setFileFixVersion(m_storage->currentFixVersion());
         QSqlQuery query2(*q);
         query2.prepare("UPDATE kmmFileInfo SET version = :version, \
                   fixLevel = :fixLevel;");
         query2.bindValue(":version", m_dbVersion);
         query2.bindValue(":fixLevel", m_storage->currentFixVersion());
         if (!query2.exec()) { // krazy:exclude=crashy
           buildError(query2, Q_FUNC_INFO, "Error updating file info(version)");
           return(1);
         }
         return (0);
       }
     }
     // prior to dbv6, 'version' format was 'dbversion.fixLevel+1'
     // as of dbv6, these are separate fields
     QString version = query.value(0).toString();
     if (version.contains('.')) {
       m_dbVersion = query.value(0).toString().section('.', 0, 0).toUInt();
       m_storage->setFileFixVersion(query.value(0).toString().section('.', 1, 1).toUInt() - 1);
     } else {
       m_dbVersion = version.toUInt();
       query.prepare("SELECT fixLevel FROM kmmFileInfo;");
       if (!query.exec() || !query.next()) { // krazy:exclude=crashy
         buildError(query, Q_FUNC_INFO, "Error retrieving file info (fixLevel)");
         return(1);
       }
       m_storage->setFileFixVersion(query.value(0).toUInt());
     }
 
     if (m_dbVersion == m_db.currentVersion())
       return 0;
 
     int rc = 0;
 
     // Drop VIEWs
     QStringList lowerTables = tables(QSql::AllTables);
     for (QStringList::iterator i = lowerTables.begin(); i != lowerTables.end(); ++i) {
       (*i) = (*i).toLower();
     }
 
     for (QMap<QString, MyMoneyDbView>::ConstIterator tt = m_db.viewBegin(); tt != m_db.viewEnd(); ++tt) {
       if (lowerTables.contains(tt.key().toLower())) {
         if (!query.exec("DROP VIEW " + tt.value().name() + ';')) // krazy:exclude=crashy
-          throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("dropping view %1").arg(tt.key())));
+          throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("dropping view %1").arg(tt.key()));
       }
     }
 
     while ((m_dbVersion < m_db.currentVersion()) && (rc == 0)) {
       switch (m_dbVersion) {
         case 0:
           if ((rc = upgradeToV1()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 1:
           if ((rc = upgradeToV2()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 2:
           if ((rc = upgradeToV3()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 3:
           if ((rc = upgradeToV4()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 4:
           if ((rc = upgradeToV5()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 5:
           if ((rc = upgradeToV6()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 6:
           if ((rc = upgradeToV7()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 7:
           if ((rc = upgradeToV8()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 8:
           if ((rc = upgradeToV9()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 9:
           if ((rc = upgradeToV10()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 10:
           if ((rc = upgradeToV11()) != 0) return (1);
           ++m_dbVersion;
           break;
         case 11:
           if ((rc = upgradeToV12()) != 0) return (1);
           ++m_dbVersion;
           break;
         default:
           qWarning("Unknown version number in database - %d", m_dbVersion);
       }
     }
 
     // restore VIEWs
     lowerTables = tables(QSql::AllTables);
     for (QStringList::iterator i = lowerTables.begin(); i != lowerTables.end(); ++i) {
       (*i) = (*i).toLower();
     }
 
     for (QMap<QString, MyMoneyDbView>::ConstIterator tt = m_db.viewBegin(); tt != m_db.viewEnd(); ++tt) {
       if (!lowerTables.contains(tt.key().toLower())) {
         if (!query.exec(tt.value().createString())) // krazy:exclude=crashy
-          throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO,
-                                            QString("creating view %1").arg(tt.key())));
+          throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("creating view %1").arg(tt.key()));
       }
     }
 
     // write updated version to DB
     //setVersion(QString("%1.%2").arg(m_dbVersion).arg(m_minorVersion))
     query.prepare(QString("UPDATE kmmFileInfo SET version = :version;"));
     query.bindValue(":version", m_dbVersion);
     if (!query.exec()) { // krazy:exclude=crashy
       buildError(query, Q_FUNC_INFO, "Error updating db version");
       return (1);
     }
     //signalProgress(-1,-1);
     return (0);
   }
 
   int upgradeToV1()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     // change kmmSplits pkey to (transactionId, splitId)
     if (!query.exec("ALTER TABLE kmmSplits ADD PRIMARY KEY (transactionId, splitId);")) { // krazy:exclude=crashy
       buildError(query, Q_FUNC_INFO, "Error updating kmmSplits pkey");
       return (1);
     }
     // change kmmSplits alter checkNumber varchar(32)
     if (!query.exec(m_db.m_tables["kmmSplits"].modifyColumnString(m_driver, "checkNumber", // krazy:exclude=crashy
                 MyMoneyDbColumn("checkNumber", "varchar(32)")))) {
       buildError(query, Q_FUNC_INFO, "Error expanding kmmSplits.checkNumber");
       return (1);
     }
     // change kmmSplits add postDate datetime
     if (!alterTable(m_db.m_tables["kmmSplits"], m_dbVersion))
       return (1);
     // initialize it to same value as transaction (do it the long way round)
     query.prepare("SELECT id, postDate FROM kmmTransactions WHERE txType = 'N';");
     if (!query.exec()) { // krazy:exclude=crashy
       buildError(query, Q_FUNC_INFO, "Error priming kmmSplits.postDate");
       return (1);
     }
     QMap<QString, QDateTime> tids;
     while (query.next()) tids[query.value(0).toString()] = query.value(1).toDateTime();
     QMap<QString, QDateTime>::ConstIterator it;
     for (it = tids.constBegin(); it != tids.constEnd(); ++it) {
       query.prepare("UPDATE kmmSplits SET postDate=:postDate WHERE transactionId = :id;");
       query.bindValue(":postDate", it.value().toString(Qt::ISODate));
       query.bindValue(":id", it.key());
       if (!query.exec()) { // krazy:exclude=crashy
         buildError(query, Q_FUNC_INFO, "priming kmmSplits.postDate");
         return(1);
       }
     }
     // add index to kmmKeyValuePairs to (kvpType,kvpId)
     QStringList list;
     list << "kvpType" << "kvpId";
     if (!query.exec(MyMoneyDbIndex("kmmKeyValuePairs", "kmmKVPtype_id", list, false).generateDDL(m_driver) + ';')) {
       buildError(query, Q_FUNC_INFO, "Error adding kmmKeyValuePairs index");
       return (1);
     }
     // add index to kmmSplits to (accountId, txType)
     list.clear();
     list << "accountId" << "txType";
     if (!query.exec(MyMoneyDbIndex("kmmSplits", "kmmSplitsaccount_type", list, false).generateDDL(m_driver) + ';')) {
       buildError(query, Q_FUNC_INFO, "Error adding kmmSplits index");
       return (1);
     }
     // change kmmSchedulePaymentHistory pkey to (schedId, payDate)
     if (!query.exec("ALTER TABLE kmmSchedulePaymentHistory ADD PRIMARY KEY (schedId, payDate);")) {
       buildError(query, Q_FUNC_INFO, "Error updating kmmSchedulePaymentHistory pkey");
       return (1);
     }
     // change kmmPrices pkey to (fromId, toId, priceDate)
     if (!query.exec("ALTER TABLE kmmPrices ADD PRIMARY KEY (fromId, toId, priceDate);")) {
       buildError(query, Q_FUNC_INFO, "Error updating kmmPrices pkey");
       return (1);
     }
     // change kmmReportConfig pkey to (name)
     // There wasn't one previously, so no need to drop it.
     if (!query.exec("ALTER TABLE kmmReportConfig ADD PRIMARY KEY (name);")) {
       buildError(query, Q_FUNC_INFO, "Error updating kmmReportConfig pkey");
       return (1);
     }
     // change kmmFileInfo add budgets, hiBudgetId unsigned bigint
     // change kmmFileInfo add logonUser
     // change kmmFileInfo add logonAt datetime
     if (!alterTable(m_db.m_tables["kmmFileInfo"], m_dbVersion))
       return (1);
     // change kmmAccounts add transactionCount unsigned bigint as last field
     if (!alterTable(m_db.m_tables["kmmAccounts"], m_dbVersion))
       return (1);
     // calculate the transaction counts. the application logic defines an account's tx count
     // in such a way as to count multiple splits in a tx which reference the same account as one.
     // this is the only way I can think of to do this which will work in sqlite too.
     // inefficient, but it only gets done once...
     // get a list of all accounts so we'll get a zero value for those without txs
     query.prepare("SELECT id FROM kmmAccounts");
     if (!query.exec()) { // krazy:exclude=crashy
       buildError(query, Q_FUNC_INFO, "Error retrieving accounts for transaction counting");
       return(1);
     }
     while (query.next()) {
       m_transactionCountMap[query.value(0).toString()] = 0;
     }
     query.prepare("SELECT accountId, transactionId FROM kmmSplits WHERE txType = 'N' ORDER BY 1, 2");
     if (!query.exec()) { // krazy:exclude=crashy
       buildError(query, Q_FUNC_INFO, "Error retrieving splits for transaction counting");
       return(1);
     }
     QString lastAcc, lastTx;
     while (query.next()) {
       QString thisAcc = query.value(0).toString();
       QString thisTx = query.value(1).toString();
       if ((thisAcc != lastAcc) || (thisTx != lastTx)) ++m_transactionCountMap[thisAcc];
       lastAcc = thisAcc;
       lastTx = thisTx;
     }
     QHash<QString, ulong>::ConstIterator itm;
     query.prepare("UPDATE kmmAccounts SET transactionCount = :txCount WHERE id = :id;");
     for (itm = m_transactionCountMap.constBegin(); itm != m_transactionCountMap.constEnd(); ++itm) {
       query.bindValue(":txCount", QString::number(itm.value()));
       query.bindValue(":id", itm.key());
       if (!query.exec()) { // krazy:exclude=crashy
         buildError(query, Q_FUNC_INFO, "Error updating transaction count");
         return (1);
       }
     }
     m_transactionCountMap.clear();
     return (0);
   }
 
   int upgradeToV2()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     // change kmmSplits add price, priceFormatted fields
     if (!alterTable(m_db.m_tables["kmmSplits"], m_dbVersion))
       return (1);
     return (0);
   }
 
   int upgradeToV3()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     // kmmSchedules - add occurrenceMultiplier
     // The default value is given here to populate the column.
     if (!query.exec("ALTER TABLE kmmSchedules ADD COLUMN " +
                 MyMoneyDbIntColumn("occurenceMultiplier",
                                    MyMoneyDbIntColumn::SMALL, false, false, true)
                 .generateDDL(m_driver) + " DEFAULT 0;")) {
       buildError(query, Q_FUNC_INFO, "Error adding kmmSchedules.occurenceMultiplier");
       return (1);
     }
     //The default is less than any useful value, so as each schedule is hit, it will update
     //itself to the appropriate value.
     return 0;
   }
 
   int upgradeToV4()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     // kmmSplits - add index on transactionId + splitId
     QStringList list;
     list << "transactionId" << "splitId";
     if (!query.exec(MyMoneyDbIndex("kmmSplits", "kmmTx_Split", list, false).generateDDL(m_driver) + ';')) {
       buildError(query, Q_FUNC_INFO, "Error adding kmmSplits index on (transactionId, splitId)");
       return (1);
     }
     return 0;
   }
 
   int upgradeToV5()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
     // kmmSplits - add bankId
     if (!alterTable(m_db.m_tables["kmmSplits"], m_dbVersion))
       return (1);
     //kmmPayees - add columns "notes" "defaultAccountId" "matchData" "matchIgnoreCase" "matchKeys";
     if (!alterTable(m_db.m_tables["kmmPayees"], m_dbVersion))
       return (1);
     // kmmReportConfig - drop primary key on name since duplicate names are allowed
     if (!alterTable(m_db.m_tables["kmmReportConfig"], m_dbVersion))
       return (1);
     //}
     return 0;
   }
 
   int upgradeToV6()
   {
     Q_Q(MyMoneyStorageSql);
     q->startCommitUnit(Q_FUNC_INFO);
     QSqlQuery query(*q);
     // kmmFileInfo - add fixLevel
     if (!alterTable(m_db.m_tables["kmmFileInfo"], m_dbVersion))
       return (1);
     // upgrade Mysql to InnoDB transaction-safe engine
     // the following is not a good way to test for mysql - think of a better way
     if (!m_driver->tableOptionString().isEmpty()) {
       for (QMap<QString, MyMoneyDbTable>::ConstIterator tt = m_db.tableBegin(); tt != m_db.tableEnd(); ++tt) {
         if (!query.exec(QString("ALTER TABLE %1 ENGINE = InnoDB;").arg(tt.value().name()))) {
           buildError(query, Q_FUNC_INFO, "Error updating to InnoDB");
           return (1);
         }
       }
     }
 
     // the alterTable function really doesn't work too well
     // with adding a new column which is also to be primary key
     // so add the column first
     if (!query.exec("ALTER TABLE kmmReportConfig ADD COLUMN " +
                 MyMoneyDbColumn("id", "varchar(32)").generateDDL(m_driver) + ';')) {
       buildError(query, Q_FUNC_INFO, "adding id to report table");
       return(1);
     }
     QMap<QString, MyMoneyReport> reportList = q->fetchReports();
     // the V5 database allowed lots of duplicate reports with no
     // way to distinguish between them. The fetchReports call
     // will have effectively removed all duplicates
     // so we now delete from the db and re-write them
     if (!query.exec("DELETE FROM kmmReportConfig;")) {
       buildError(query, Q_FUNC_INFO, "Error deleting reports");
       return (1);
     }
     // add unique id to reports table
     if (!alterTable(m_db.m_tables["kmmReportConfig"], m_dbVersion))
       return(1);
 
     QMap<QString, MyMoneyReport>::const_iterator it_r;
     for (it_r = reportList.constBegin(); it_r != reportList.constEnd(); ++it_r) {
       MyMoneyReport r = *it_r;
       query.prepare(m_db.m_tables["kmmReportConfig"].insertString());
       writeReport(*it_r, query);
     }
 
     q->endCommitUnit(Q_FUNC_INFO);
     return 0;
   }
 
   int upgradeToV7()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
     QSqlQuery query(*q);
 
     // add tags support
     // kmmFileInfo - add tags and hiTagId
     if (!alterTable(m_db.m_tables["kmmFileInfo"], m_dbVersion))
       return (1);
 
     m_tags = 0;
     return 0;
   }
 
   int upgradeToV8()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
 
     // Added onlineJobs and payeeIdentifier
     if (!alterTable(m_db.m_tables["kmmFileInfo"], m_dbVersion))
       return (1);
 
     return 0;
   }
 
   int upgradeToV9()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
 
     QSqlQuery query(*q);
     // kmmSplits - add bankId
     if (!alterTable(m_db.m_tables["kmmSplits"], m_dbVersion))
       return (1);
 
     return 0;
   }
 
   int upgradeToV10()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
 
     QSqlQuery query(*q);
     if (!alterTable(m_db.m_tables["kmmPayeesPayeeIdentifier"], m_dbVersion))
       return (1);
     if (!alterTable(m_db.m_tables["kmmAccountsPayeeIdentifier"], m_dbVersion))
       return (1);
 
     return 0;
   }
 
   int upgradeToV11()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
 
     QSqlQuery query(*q);
 
     // add column roundingMethodCol to kmmSecurities
     if (!alterTable(m_db.m_tables["kmmSecurities"], m_dbVersion))
       return 1;
     // add column pricePrecision to kmmCurrencies
     if (!alterTable(m_db.m_tables["kmmCurrencies"], m_dbVersion))
       return 1;
 
     return 0;
   }
 
   int upgradeToV12()
   {
     Q_Q(MyMoneyStorageSql);
     MyMoneyDbTransaction dbtrans(*q, Q_FUNC_INFO);
 
     switch(haveColumnInTable(QLatin1String("kmmSchedules"), QLatin1String("lastDayInMonth"))) {
       case -1:
         return 1;
       case 1:         // column exists, nothing to do
         break;
       case 0:         // need update of kmmSchedules
         // add column lastDayInMonth. Simply redo the update for 10 .. 11
         if (!alterTable(m_db.m_tables["kmmSchedules"], m_dbVersion-1))
           return 1;
         break;
     }
 
     switch(haveColumnInTable(QLatin1String("kmmSecurities"), QLatin1String("roundingMethod"))) {
       case -1:
         return 1;
       case 1:         // column exists, nothing to do
         break;
       case 0:         // need update of kmmSecurities and kmmCurrencies
         // add column roundingMethodCol to kmmSecurities. Simply redo the update for 10 .. 11
         if (!alterTable(m_db.m_tables["kmmSecurities"], m_dbVersion-1))
           return 1;
         // add column pricePrecision to kmmCurrencies. Simply redo the update for 10 .. 11
         if (!alterTable(m_db.m_tables["kmmCurrencies"], m_dbVersion-1))
           return 1;
         break;
     }
     return 0;
   }
 
   int createTables()
   {
     Q_Q(MyMoneyStorageSql);
     // check tables, create if required
     // convert everything to lower case, since SQL standard is case insensitive
     // table and column names (when not delimited), but some DBMSs disagree.
     QStringList lowerTables = tables(QSql::AllTables);
     for (QStringList::iterator i = lowerTables.begin(); i != lowerTables.end(); ++i) {
       (*i) = (*i).toLower();
     }
 
     for (QMap<QString, MyMoneyDbTable>::ConstIterator tt = m_db.tableBegin(); tt != m_db.tableEnd(); ++tt) {
       if (!lowerTables.contains(tt.key().toLower())) {
         createTable(tt.value());
       }
     }
 
     QSqlQuery query(*q);
     for (QMap<QString, MyMoneyDbView>::ConstIterator tt = m_db.viewBegin(); tt != m_db.viewEnd(); ++tt) {
       if (!lowerTables.contains(tt.key().toLower())) {
-        if (!query.exec(tt.value().createString())) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("creating view %1").arg(tt.key())));
+        if (!query.exec(tt.value().createString())) throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("creating view %1").arg(tt.key()));
       }
     }
 
     // The columns to store version info changed with version 6. Prior versions are not supported here but an error is prevented and
     // an old behaviour is used: call upgradeDb().
     m_dbVersion = m_db.currentVersion();
     if (m_dbVersion >= 6) {
       query.prepare(QLatin1String("INSERT INTO kmmFileInfo (version, fixLevel) VALUES(?,?);"));
       query.bindValue(0, m_dbVersion);
       query.bindValue(1, m_storage->fileFixVersion());
       if (!query.exec())
-        throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("Saving database version")));
+        throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("Saving database version"));
     }
 
     return upgradeDb();
   }
 
   void createTable(const MyMoneyDbTable& t, int version = std::numeric_limits<int>::max())
   {
     Q_Q(MyMoneyStorageSql);
   // create the tables
     QStringList ql = t.generateCreateSQL(m_driver, version).split('\n', QString::SkipEmptyParts);
     QSqlQuery query(*q);
     foreach (const QString& i, ql) {
-      if (!query.exec(i)) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("creating table/index %1").arg(t.name())));
+      if (!query.exec(i)) throw MYMONEYEXCEPTIONSQL(QString::fromLatin1("creating table/index %1").arg(t.name()));
     }
   }
 
   bool alterTable(const MyMoneyDbTable& t, int fromVersion)
   {
     Q_Q(MyMoneyStorageSql);
     const int toVersion = fromVersion + 1;
 
     QString tempTableName = t.name();
     tempTableName.replace("kmm", "kmmtmp");
     QSqlQuery query(*q);
     // drop primary key if it has one (and driver supports it)
     if (t.hasPrimaryKey(fromVersion)) {
       QString dropString = m_driver->dropPrimaryKeyString(t.name());
       if (!dropString.isEmpty()) {
         if (!query.exec(dropString)) {
           buildError(query, Q_FUNC_INFO, QString("Error dropping old primary key from %1").arg(t.name()));
           return false;
         }
       }
     }
     for (MyMoneyDbTable::index_iterator i = t.indexBegin(); i != t.indexEnd(); ++i) {
       QString indexName = t.name() + '_' + i->name() + "_idx";
       if (!query.exec(m_driver->dropIndexString(t.name(), indexName))) {
         buildError(query, Q_FUNC_INFO, QString("Error dropping index from %1").arg(t.name()));
         return false;
       }
     }
     if (!query.exec(QString("ALTER TABLE " + t.name() + " RENAME TO " + tempTableName + ';'))) {
       buildError(query, Q_FUNC_INFO, QString("Error renaming table %1").arg(t.name()));
       return false;
     }
     createTable(t, toVersion);
     if (q->getRecCount(tempTableName) > 0) {
       query.prepare(QString("INSERT INTO " + t.name() + " (" + t.columnList(fromVersion) +
                           ") SELECT " + t.columnList(fromVersion) + " FROM " + tempTableName + ';'));
       if (!query.exec()) { // krazy:exclude=crashy
           buildError(query, Q_FUNC_INFO, QString("Error inserting into new table %1").arg(t.name()));
           return false;
       }
     }
     if (!query.exec(QString("DROP TABLE " + tempTableName + ';'))) {
       buildError(query, Q_FUNC_INFO, QString("Error dropping old table %1").arg(t.name()));
       return false;
     }
     return true;
   }
 
   void clean()
   {
     Q_Q(MyMoneyStorageSql);
   // delete all existing records
     QMap<QString, MyMoneyDbTable>::ConstIterator it = m_db.tableBegin();
     QSqlQuery query(*q);
     while (it != m_db.tableEnd()) {
       query.prepare(QString("DELETE from %1;").arg(it.key()));
-      if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, QString("cleaning database"))); // krazy:exclude=crashy
+      if (!query.exec()) throw MYMONEYEXCEPTIONSQL("cleaning database"); // krazy:exclude=crashy
       ++it;
     }
   }
 
   int isEmpty()
   {
     Q_Q(MyMoneyStorageSql);
     // check all tables are empty
     QMap<QString, MyMoneyDbTable>::ConstIterator tt = m_db.tableBegin();
     int recordCount = 0;
     QSqlQuery query(*q);
     while ((tt != m_db.tableEnd()) && (recordCount == 0)) {
       query.prepare(QString("select count(*) from %1;").arg((*tt).name()));
-      if (!query.exec()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "getting record count")); // krazy:exclude=crashy
-      if (!query.next()) throw MYMONEYEXCEPTION(buildError(query, Q_FUNC_INFO, "retrieving record count"));
+      if (!query.exec()) throw MYMONEYEXCEPTIONSQL("getting record count"); // krazy:exclude=crashy
+      if (!query.next()) throw MYMONEYEXCEPTIONSQL("retrieving record count");
       recordCount += query.value(0).toInt();
       ++tt;
     }
 
     if (recordCount != 0) {
       return (-1); // not empty
     } else {
       return (0);
     }
   }
 
   // for bug 252841
   QStringList tables(QSql::TableType tt)
   {
     Q_Q(MyMoneyStorageSql);
     return (m_driver->tables(tt, static_cast<const QSqlDatabase&>(*q)));
   }
 
   //! Returns 1 in case the @a column exists in @a table, 0 if not. In case of error, -1 is returned.
   int haveColumnInTable(const QString& table, const QString& column)
   {
     Q_Q(MyMoneyStorageSql);
     QSqlQuery query(*q);
     QString cmd = QString("SELECT * FROM %1 LIMIT 1").arg(table);
     if(!query.exec(cmd)) {
       buildError(query, Q_FUNC_INFO, QString("Error detecting if %1 exists in %2").arg(column).arg(table));
       return -1;
     }
     QSqlRecord rec = query.record();
     return (rec.indexOf(column) != -1) ? 1 : 0;
   }
 
   /**
    * @brief Ensure the storagePlugin with iid was setup
    *
    * @throws MyMoneyException in case of an error which makes the use
    * of the plugin unavailable.
    */
   bool setupStoragePlugin(QString iid)
   {
     Q_UNUSED(iid)
     Q_Q(MyMoneyStorageSql);
     // setupDatabase has to be called every time because this simple technique to check if was updated already
     // does not work if a user opens another file
     // also the setup is removed if the current database transaction is rolled back
     if (iid.isEmpty() /*|| m_loadedStoragePlugins.contains(iid)*/)
       return false;
 
     QString errorMsg;
     KMyMoneyPlugin::storagePlugin* plugin = KServiceTypeTrader::createInstanceFromQuery<KMyMoneyPlugin::storagePlugin>(
       QLatin1String("KMyMoney/sqlStoragePlugin"),
       QString("'%1' ~in [X-KMyMoney-PluginIid]").arg(iid.replace(QLatin1Char('\''), QLatin1String("\\'"))),
       0,
       QVariantList(),
       &errorMsg
     );
 
     if (plugin == 0)
-      throw MYMONEYEXCEPTION(QString("Could not load sqlStoragePlugin '%1', (error: %2)").arg(iid, errorMsg));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Could not load sqlStoragePlugin '%1', (error: %2)").arg(iid, errorMsg));
 
     MyMoneyDbTransaction t(*q, Q_FUNC_INFO);
     if (plugin->setupDatabase(*q)) {
       m_loadedStoragePlugins.insert(iid);
       return true;
     }
 
-    throw MYMONEYEXCEPTION(QString("Could not install sqlStoragePlugin '%1' in database.").arg(iid));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Could not install sqlStoragePlugin '%1' in database.").arg(iid));
   }
 
   void insertStorableObject(const databaseStoreableObject& obj, const QString& id)
   {
     Q_Q(MyMoneyStorageSql);
     setupStoragePlugin(obj.storagePluginIid());
     if (!obj.sqlSave(*q, id))
-      throw MYMONEYEXCEPTION(QString("Could not save object with id '%1' in database (plugin failed).").arg(id));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Could not save object with id '%1' in database (plugin failed).").arg(id));
   }
 
   void updateStorableObject(const databaseStoreableObject& obj, const QString& id)
   {
     Q_Q(MyMoneyStorageSql);
     setupStoragePlugin(obj.storagePluginIid());
     if (!obj.sqlModify(*q, id))
-      throw MYMONEYEXCEPTION(QString("Could not modify object with id '%1' in database (plugin failed).").arg(id));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Could not modify object with id '%1' in database (plugin failed).").arg(id));
   }
 
   void deleteStorableObject(const databaseStoreableObject& obj, const QString& id)
   {
     Q_Q(MyMoneyStorageSql);
     setupStoragePlugin(obj.storagePluginIid());
     if (!obj.sqlRemove(*q, id))
-      throw MYMONEYEXCEPTION(QString("Could not remove object with id '%1' from database (plugin failed).").arg(id));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Could not remove object with id '%1' from database (plugin failed).").arg(id));
   }
 
   void alert(QString s) const // FIXME: remove...
   {
     qDebug() << s;
   }
 
   void signalProgress(int current, int total, const QString& msg) const
   {
     if (m_progressCallback != 0)
       (*m_progressCallback)(current, total, msg);
   }
 
   void signalProgress(int current, int total) const
   {
     signalProgress(current, total, QString());
   }
 
   template<ulong MyMoneyStorageSqlPrivate::* cache>
   ulong getNextId(const QString& table, const QString& id, const int prefixLength) const
   {
     Q_CHECK_PTR(cache);
     if (this->*cache == 0) {
       MyMoneyStorageSqlPrivate* nonConstThis = const_cast<MyMoneyStorageSqlPrivate*>(this);
       nonConstThis->*cache = 1 + nonConstThis->highestNumberFromIdString(table, id, prefixLength);
     }
     Q_ASSERT(this->*cache > 0); // everything else is never a valid id
     return this->*cache;
   }
 
   //void startCommitUnit (const QString& callingFunction);
   //void endCommitUnit (const QString& callingFunction);
   //void cancelCommitUnit (const QString& callingFunction);
 
   MyMoneyStorageSql *q_ptr;
 
   // data
   QExplicitlySharedDataPointer<MyMoneyDbDriver> m_driver;
 
   MyMoneyDbDef m_db;
   uint m_dbVersion;
   MyMoneyStorageMgr *m_storage;
   // input options
   bool m_loadAll; // preload all data
   bool m_override; // override open if already in use
   // error message
   QString m_error;
   // record counts
   ulong m_institutions;
   ulong m_accounts;
   ulong m_payees;
   ulong m_tags;
   ulong m_transactions;
   ulong m_splits;
   ulong m_securities;
   ulong m_prices;
   ulong m_currencies;
   ulong m_schedules;
   ulong m_reports;
   ulong m_kvps;
   ulong m_budgets;
   ulong m_onlineJobs;
   ulong m_payeeIdentifier;
 
   // Cache for next id to use
   // value 0 means data is not available and has to be loaded from the database
   ulong m_hiIdInstitutions;
   ulong m_hiIdPayees;
   ulong m_hiIdTags;
   ulong m_hiIdAccounts;
   ulong m_hiIdTransactions;
   ulong m_hiIdSchedules;
   ulong m_hiIdSecurities;
   ulong m_hiIdReports;
   ulong m_hiIdBudgets;
   ulong m_hiIdOnlineJobs;
   ulong m_hiIdPayeeIdentifier;
   ulong m_hiIdCostCenter;
 
   // encrypt option - usage TBD
   QString m_encryptData;
 
   /**
     * This variable is used to suppress status messages except during
    * initial data load and final write
 
   */
   bool m_displayStatus;
 
   /** The following keeps track of commitment units (known as transactions in SQL
     * though it would be confusing to use that term within KMM). It is implemented
     * as a stack for debug purposes. Long term, probably a count would suffice
     */
   QStack<QString> m_commitUnitStack;
   /**
     * This member variable is used to preload transactions for preferred accounts
     */
   MyMoneyTransactionFilter m_preferred;
   /**
     * This member variable is used because reading prices from a file uses the 'add...' function rather than a
     * 'load...' function which other objects use. Having this variable allows us to avoid needing to check the
     * database to see if this really is a new or modified price
     */
   bool m_readingPrices;
   /**
     * This member variable holds a map of transaction counts per account, indexed by
     * the account id. It is used
     * to avoid having to scan all transactions whenever a count is needed. It should
     * probably be moved into the MyMoneyAccount object; maybe we will do that once
     * the database code has been properly checked out
     */
   QHash<QString, ulong> m_transactionCountMap;
   /**
     * These member variables hold the user name and date/time of logon
     */
   QString m_logonUser;
   QDateTime m_logonAt;
   QDate m_txPostDate; // FIXME: remove when Tom puts date into split object
 
   bool m_newDatabase;
 
   /**
     * This member keeps the current precision to be used fro prices.
     * @sa setPrecision()
     */
   static int m_precision;
 
   /**
     * This member keeps the current start date used for transaction retrieval.
     * @sa setStartDate()
     */
   static QDate m_startDate;
 
   /**
     *
     */
   QSet<QString> m_loadedStoragePlugins;
 
   void (*m_progressCallback)(int, int, const QString&);
 };
 #endif
diff --git a/kmymoney/plugins/sql/sqlstorage.cpp b/kmymoney/plugins/sql/sqlstorage.cpp
index 0a4618f73..bd99fc624 100644
--- a/kmymoney/plugins/sql/sqlstorage.cpp
+++ b/kmymoney/plugins/sql/sqlstorage.cpp
@@ -1,314 +1,314 @@
 /***************************************************************************
                             sqlstorage.cpp
                              -------------------
 
     copyright            : (C) 2018 by Łukasz Wojniłowicz
     email                : lukasz.wojnilowicz@gmail.com
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "sqlstorage.h"
 
 #include <memory>
 #include <config-kmymoney.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QUrlQuery>
 #include <QTimer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KPluginFactory>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "appinterface.h"
 #include "viewinterface.h"
 #include "kselectdatabasedlg.h"
 #include "kgeneratesqldlg.h"
 #include "mymoneyfile.h"
 #include "mymoneystoragesql.h"
 #include "mymoneyexception.h"
 //#include "mymoneystoragemgr.h"
 #include "icons.h"
 #include "kmymoneysettings.h"
 
 using namespace Icons;
 
 SQLStorage::SQLStorage(QObject *parent, const QVariantList &args) :
   KMyMoneyPlugin::Plugin(parent, "sqlstorage"/*must be the same as X-KDE-PluginInfo-Name*/)
 {
   Q_UNUSED(args)
   setComponentName("sqlstorage", i18n("SQL storage"));
   setXMLFile("sqlstorage.rc");
   createActions();
   // For information, announce that we have been loaded.
   qDebug("Plugins: sqlstorage loaded");
 }
 
 SQLStorage::~SQLStorage()
 {
   qDebug("Plugins: sqlstorage unloaded");
 }
 
 bool SQLStorage::open(MyMoneyStorageMgr *storage, const QUrl &url)
 {
   auto reader = std::make_unique<MyMoneyStorageSql>(storage, url);
 
   QUrl dbURL(url);
   bool retry = true;
   while (retry) {
     switch (reader->open(dbURL, QIODevice::ReadWrite)) {
       case 0: // opened okay
         retry = false;
         break;
       case 1: // permanent error
         KMessageBox::detailedError(nullptr,
                                    i18n("Cannot open database %1\n", dbURL.toDisplayString()),
                                    reader->lastError());
         return false;
       case -1: // retryable error
         if (KMessageBox::warningYesNo(nullptr, reader->lastError(), PACKAGE) == KMessageBox::No) {
           return false;
         } else {
           QUrlQuery query(dbURL);
           const QString optionKey = QLatin1String("options");
           QString options = query.queryItemValue(optionKey);
           if(!options.isEmpty()) {
             options += QLatin1Char(',');
           }
           options += QLatin1String("override");
           query.removeQueryItem(QLatin1String("mode"));
           query.removeQueryItem(optionKey);
           query.addQueryItem(optionKey, options);
           dbURL.setQuery(query);
         }
     }
   }
   // single user mode; read some of the data into memory
   // FIXME - readFile no longer relevant?
   // tried removing it but then got no indication that loading was complete
   // also, didn't show home page
 //  reader->setProgressCallback(&KMyMoneyView::progressCallback);
   if (!reader->readFile()) {
     KMessageBox::detailedError(nullptr,
                                i18n("An unrecoverable error occurred while reading the database"),
                                reader->lastError().toLatin1(),
                                i18n("Database malfunction"));
     return false;
   }
 //  reader->setProgressCallback(0);
   return true;
 }
 
 bool SQLStorage::save(const QUrl &url)
 {
   return saveDatabase(url);
 }
 
 QString SQLStorage::formatName() const
 {
   return QStringLiteral("SQL");
 }
 
 QString SQLStorage::fileExtension() const
 {
   return QString();
 }
 
 void SQLStorage::createActions()
 {
   m_openDBaction = actionCollection()->addAction("open_database");
   m_openDBaction->setText(i18n("Open database..."));
   m_openDBaction->setIcon(Icons::get(Icon::SVNUpdate));
   connect(m_openDBaction, &QAction::triggered, this, &SQLStorage::slotOpenDatabase);
 
   m_saveAsDBaction = actionCollection()->addAction("saveas_database");
   m_saveAsDBaction->setText(i18n("Save as database..."));
   m_saveAsDBaction->setIcon(Icons::get(Icon::FileArchiver));
   connect(m_saveAsDBaction, &QAction::triggered, this, &SQLStorage::slotSaveAsDatabase);
 
   m_generateDB = actionCollection()->addAction("tools_generate_sql");
   m_generateDB->setText(i18n("Generate Database SQL"));
   connect(m_generateDB, &QAction::triggered, this, &SQLStorage::slotGenerateSql);
 }
 
 void SQLStorage::slotOpenDatabase()
 {
   QPointer<KSelectDatabaseDlg> dialog = new KSelectDatabaseDlg(QIODevice::ReadWrite);
   if (!dialog->checkDrivers()) {
     delete dialog;
     return;
   }
 
   if (dialog->exec() == QDialog::Accepted && dialog != 0) {
     auto url = dialog->selectedURL();
     QUrl newurl = url;
     if ((newurl.scheme() == QLatin1String("sql"))) {
       const QString key = QLatin1String("driver");
       // take care and convert some old url to their new counterpart
       QUrlQuery query(newurl);
       if (query.queryItemValue(key) == QLatin1String("QMYSQL3")) { // fix any old urls
         query.removeQueryItem(key);
         query.addQueryItem(key, QLatin1String("QMYSQL"));
       }
       if (query.queryItemValue(key) == QLatin1String("QSQLITE3")) {
         query.removeQueryItem(key);
         query.addQueryItem(key, QLatin1String("QSQLITE"));
       }
       newurl.setQuery(query);
 
       // check if a password is needed. it may be if the URL came from the last/recent file list
       dialog = new KSelectDatabaseDlg(QIODevice::ReadWrite, newurl);
       if (!dialog->checkDrivers()) {
         delete dialog;
         return;
       }
       // if we need to supply a password, then show the dialog
       // otherwise it isn't needed
       if ((query.queryItemValue("secure").toLower() == QLatin1String("yes")) && newurl.password().isEmpty()) {
         if (dialog->exec() == QDialog::Accepted && dialog != nullptr) {
           newurl = dialog->selectedURL();
         } else {
           delete dialog;
           return;
         }
       }
       delete dialog;
     }
 
     appInterface()->slotFileOpenRecent(newurl);
   }
   delete dialog;
 }
 
 void SQLStorage::slotSaveAsDatabase()
 {
   bool rc = false;
   QUrl oldUrl;
   // in event of it being a database, ensure that all data is read into storage for saveas
   if (appInterface()->isDatabase())
     oldUrl = appInterface()->filenameURL().isEmpty() ? appInterface()->lastOpenedURL() : appInterface()->filenameURL();
 
   QPointer<KSelectDatabaseDlg> dialog = new KSelectDatabaseDlg(QIODevice::WriteOnly);
   QUrl url = oldUrl;
   if (!dialog->checkDrivers()) {
     delete dialog;
     return;
   }
 
   while (oldUrl == url && dialog->exec() == QDialog::Accepted && dialog != 0) {
     url = dialog->selectedURL();
     // If the protocol is SQL for the old and new, and the hostname and database names match
     // Let the user know that the current database cannot be saved on top of itself.
     if (url.scheme() == "sql" && oldUrl.scheme() == "sql"
         && oldUrl.host() == url.host()
         && QUrlQuery(oldUrl).queryItemValue("driver") == QUrlQuery(url).queryItemValue("driver")
         && oldUrl.path().right(oldUrl.path().length() - 1) == url.path().right(url.path().length() - 1)) {
       KMessageBox::sorry(nullptr, i18n("Cannot save to current database."));
     } else {
       try {
         rc = saveAsDatabase(url);
       } catch (const MyMoneyException &e) {
-        KMessageBox::sorry(nullptr, i18n("Cannot save to current database: %1", e.what()));
+        KMessageBox::sorry(nullptr, i18n("Cannot save to current database: %1", QString::fromLatin1(e.what())));
       }
     }
   }
   delete dialog;
 
   if (rc) {
     //KRecentFilesAction *p = dynamic_cast<KRecentFilesAction*>(action("file_open_recent"));
     //if(p)
     appInterface()->addToRecentFiles(url);
     appInterface()->writeLastUsedFile(url.toDisplayString(QUrl::PreferLocalFile));
   }
   appInterface()->autosaveTimer()->stop();
   appInterface()->updateCaption();
   return;
 }
 
 void SQLStorage::slotGenerateSql()
 {
   QPointer<KGenerateSqlDlg> editor = new KGenerateSqlDlg(nullptr);
   editor->setObjectName("Generate Database SQL");
   editor->exec();
   delete editor;
 }
 
 bool SQLStorage::saveAsDatabase(const QUrl &url)
 {
   auto writer = new MyMoneyStorageSql(MyMoneyFile::instance()->storage(), url);
   auto canWrite = false;
   switch (writer->open(url, QIODevice::WriteOnly)) {
     case 0:
       canWrite = true;
       break;
     case -1: // dbase already has data, see if he wants to clear it out
       if (KMessageBox::warningContinueCancel(nullptr,
                                              i18n("Database contains data which must be removed before using Save As.\n"
                                                   "Do you wish to continue?"), "Database not empty") == KMessageBox::Continue) {
         if (writer->open(url, QIODevice::WriteOnly, true) == 0)
           canWrite = true;
       } else {
         delete writer;
         return false;
       }
       break;
   }
   if (canWrite) {
     delete writer;
     saveDatabase(url);
     return true;
   } else {
     KMessageBox::detailedError(nullptr,
                                i18n("Cannot open or create database %1.\n"
                                     "Retry Save As Database and click Help"
                                     " for further info.", url.toDisplayString()), writer->lastError());
     delete writer;
     return false;
   }
 }
 
 bool SQLStorage::saveDatabase(const QUrl &url)
 {
   auto rc = false;
   if (!appInterface()->fileOpen()) {
     KMessageBox::error(nullptr, i18n("Tried to access a file when it has not been opened"));
     return (rc);
   }
   auto writer = new MyMoneyStorageSql(MyMoneyFile::instance()->storage(), url);
   writer->open(url, QIODevice::WriteOnly);
 //  writer->setProgressCallback(&KMyMoneyView::progressCallback);
   if (!writer->writeFile()) {
     KMessageBox::detailedError(nullptr,
                                i18n("An unrecoverable error occurred while writing to the database.\n"
                                     "It may well be corrupt."),
                                writer->lastError().toLatin1(),
                                i18n("Database malfunction"));
     rc =  false;
   } else {
     rc = true;
   }
   writer->setProgressCallback(0);
   delete writer;
   return rc;
 }
 
 K_PLUGIN_FACTORY_WITH_JSON(SQLStorageFactory, "sqlstorage.json", registerPlugin<SQLStorage>();)
 
 #include "sqlstorage.moc"
diff --git a/kmymoney/plugins/views/budget/kbudgetview.cpp b/kmymoney/plugins/views/budget/kbudgetview.cpp
index 95293e587..709bc7365 100644
--- a/kmymoney/plugins/views/budget/kbudgetview.cpp
+++ b/kmymoney/plugins/views/budget/kbudgetview.cpp
@@ -1,542 +1,539 @@
 /***************************************************************************
                           kbudgetview.cpp
                           ---------------
     begin                : Thu Jan 10 2006
     copyright            : (C) 2006 by Darren Gould
     email                : darren_gould@gmx.de
                            Alvaro Soliverez <asoliverez@gmail.com>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kbudgetview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 
 using namespace Icons;
 
 KBudgetView::KBudgetView(QWidget *parent) :
     KMyMoneyAccountsViewBase(*new KBudgetViewPrivate(this), parent)
 {
   Q_D(KBudgetView);
   d->m_inSelection = false;
 }
 
 KBudgetView::KBudgetView(KBudgetViewPrivate &dd, QWidget *parent)
     : KMyMoneyAccountsViewBase(dd, parent)
 {
 }
 
 KBudgetView::~KBudgetView()
 {
 }
 
 void KBudgetView::showEvent(QShowEvent * event)
 {
   Q_D(KBudgetView);
   if (!d->m_proxyModel)
     d->init();
 
   emit customActionRequested(View::Budget, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KBudgetView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KBudgetView);
         QTimer::singleShot(0, d->ui->m_budgetList, SLOT(setFocus()));
       }
       break;
 
     default:
       break;
   }
 }
 
 void KBudgetView::refresh()
 {
   Q_D(KBudgetView);
   if (isVisible()) {
     if (d->m_inSelection)
       QTimer::singleShot(0, this, SLOT(refresh()));
     else {
       d->loadBudgets();
       d->m_needsRefresh = false;
     }
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KBudgetView::slotNewBudget()
 {
   Q_D(KBudgetView);
   d->askSave();
   auto date = QDate::currentDate();
   date.setDate(date.year(), KMyMoneySettings::firstFiscalMonth(), KMyMoneySettings::firstFiscalDay());
   auto newname = i18n("Budget %1", date.year());
 
   MyMoneyBudget budget;
 
   // make sure we have a unique name
   try {
     int i = 1;
     // Exception thrown when the name is not found
     while (1) {
       MyMoneyFile::instance()->budgetByName(newname);
       newname = i18n("Budget %1 %2", date.year(), i++);
     }
   } catch (const MyMoneyException &) {
     // all ok, the name is unique
   }
 
   MyMoneyFileTransaction ft;
   try {
     budget.setName(newname);
     budget.setBudgetStart(date);
 
     MyMoneyFile::instance()->addBudget(budget);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to add budget: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to add budget"), QString::fromLatin1(e.what()));
   }
 }
 
 void KBudgetView::slotDeleteBudget()
 {
   Q_D(KBudgetView);
   if (d->m_budgetList.isEmpty())
     return; // shouldn't happen
 
   auto file = MyMoneyFile::instance();
 
   // get confirmation from user
   QString prompt;
   if (d->m_budgetList.size() == 1)
     prompt = i18n("<p>Do you really want to remove the budget <b>%1</b>?</p>", d->m_budgetList.front().name());
   else
     prompt = i18n("Do you really want to remove all selected budgets?");
 
   if (KMessageBox::questionYesNo(this, prompt, i18n("Remove Budget")) == KMessageBox::No)
     return;
 
   try {
     MyMoneyFileTransaction ft;
     // now loop over all selected d->m_budgetList and remove them
     for (const auto& budget : d->m_budgetList)
       file->removeBudget(budget);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to remove budget: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to remove budget."), QString::fromLatin1(e.what()));
   }
 }
 
 void KBudgetView::slotCopyBudget()
 {
   Q_D(KBudgetView);
   if (d->m_budgetList.size() == 1) {
     MyMoneyFileTransaction ft;
     try {
       MyMoneyBudget budget = d->m_budgetList.first();
       budget.clearId();
       budget.setName(i18n("Copy of %1", budget.name()));
 
       MyMoneyFile::instance()->addBudget(budget);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to add budget: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to add budget"), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KBudgetView::slotChangeBudgetYear()
 {
   Q_D(KBudgetView);
   if (d->m_budgetList.size() == 1) {
     QStringList years;
     int current = 0;
     bool haveCurrent = false;
     MyMoneyBudget budget = *(d->m_budgetList.begin());
     for (int i = (QDate::currentDate().year() - 3); i < (QDate::currentDate().year() + 5); ++i) {
       years << QString::fromLatin1("%1").arg(i);
       if (i == budget.budgetStart().year()) {
         haveCurrent = true;
       }
       if (!haveCurrent)
         ++current;
     }
     if (!haveCurrent)
       current = 0;
     bool ok = false;
 
     auto yearString = QInputDialog::getItem(this, i18n("Select year"), i18n("Budget year"), years, current, false, &ok);
 
     if (ok) {
       int year = yearString.toInt(0, 0);
       QDate newYear = QDate(year, budget.budgetStart().month(), budget.budgetStart().day());
       if (newYear != budget.budgetStart()) {
         MyMoneyFileTransaction ft;
         try {
           budget.setBudgetStart(newYear);
           MyMoneyFile::instance()->modifyBudget(budget);
           ft.commit();
         } catch (const MyMoneyException &e) {
-          KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to modify budget: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+          KMessageBox::detailedSorry(this, i18n("Unable to modify budget."), QString::fromLatin1(e.what()));
         }
       }
     }
   }
 }
 
 void KBudgetView::slotBudgetForecast()
 {
   Q_D(KBudgetView);
   if (d->m_budgetList.size() == 1) {
     MyMoneyFileTransaction ft;
     try {
       MyMoneyBudget budget = d->m_budgetList.first();
       bool calcBudget = budget.getaccounts().count() == 0;
       if (!calcBudget) {
         if (KMessageBox::warningContinueCancel(0, i18n("The current budget already contains data. Continuing will replace all current values of this budget."), i18nc("Warning message box", "Warning")) == KMessageBox::Continue)
           calcBudget = true;
       }
 
       if (calcBudget) {
         QDate historyStart;
         QDate historyEnd;
         QDate budgetStart;
         QDate budgetEnd;
 
         budgetStart = budget.budgetStart();
         budgetEnd = budgetStart.addYears(1).addDays(-1);
         historyStart = budgetStart.addYears(-1);
         historyEnd = budgetEnd.addYears(-1);
 
         MyMoneyForecast forecast = KMyMoneyUtils::forecast();
         forecast.createBudget(budget, historyStart, historyEnd, budgetStart, budgetEnd, true);
 
         MyMoneyFile::instance()->modifyBudget(budget);
         ft.commit();
       }
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to modify budget: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify budget."), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KBudgetView::slotResetBudget()
 {
   Q_D(KBudgetView);
   try {
     d->m_budget = MyMoneyFile::instance()->budget(d->m_budget.id());
     d->loadAccounts();
     const auto index = d->ui->m_accountTree->currentIndex();
     if (index.isValid()) {
       const auto acc = d->ui->m_accountTree->model()->data(index, (int)eAccountsModel::Role::Account).value<MyMoneyAccount>();
       slotSelectAccount(acc, eView::Intent::None);
     } else {
       d->ui->m_budgetValue->clear();
     }
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Unable to reset budget"),
-                               i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to reset budget"), QString::fromLatin1(e.what()));
   }
 }
 
 void KBudgetView::slotUpdateBudget()
 {
   Q_D(KBudgetView);
   MyMoneyFileTransaction ft;
   try {
     MyMoneyFile::instance()->modifyBudget(d->m_budget);
     ft.commit();
     d->refreshHideUnusedButton();
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Unable to modify budget"),
-                               i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to modify budget"), QString::fromLatin1(e.what()));
   }
 }
 
 void KBudgetView::slotStartRename()
 {
   Q_D(KBudgetView);
   QTreeWidgetItemIterator it_l(d->ui->m_budgetList, QTreeWidgetItemIterator::Selected);
   QTreeWidgetItem* it_v;
   if ((it_v = *it_l) != 0) {
     d->ui->m_budgetList->editItem(it_v, 0);
   }
 }
 
 void KBudgetView::slotOpenContextMenu(const QPoint&)
 {
   Q_D(KBudgetView);
 
   typedef void(KBudgetView::*KBudgetViewFunc)();
   struct actionInfo {
     KBudgetViewFunc callback;
     QString         text;
     Icon            icon;
     bool            enabled;
   };
   const auto actionStates = d->actionStates();
 
   const QVector<actionInfo> actionInfos {
     {&KBudgetView::slotNewBudget,        i18n("New budget"),               Icon::BudgetNew,    actionStates[eMenu::Action::NewBudget]},
     {&KBudgetView::slotStartRename,      i18n("Rename budget"),            Icon::BudgetRename, actionStates[eMenu::Action::RenameBudget]},
     {&KBudgetView::slotDeleteBudget,     i18n("Delete budget"),            Icon::BudgetDelete, actionStates[eMenu::Action::DeleteBudget]},
     {&KBudgetView::slotCopyBudget,       i18n("Copy budget"),              Icon::BudgetCopy,   actionStates[eMenu::Action::CopyBudget]},
     {&KBudgetView::slotChangeBudgetYear, i18n("Change budget year"),       Icon::ViewCalendar, actionStates[eMenu::Action::ChangeBudgetYear]},
     {&KBudgetView::slotBudgetForecast,   i18n("Budget based on forecast"), Icon::ViewForecast, actionStates[eMenu::Action::BudgetForecast]}
   };
   auto menu = new QMenu(i18nc("Menu header", "Budget options"));
   for (const auto& info : actionInfos) {
     auto a = menu->addAction(Icons::get(info.icon), info.text, this, info.callback);
     a->setEnabled(info.enabled);
   }
   menu->exec(QCursor::pos());
 }
 
 void KBudgetView::slotItemChanged(QTreeWidgetItem* p, int col)
 {
   // if we don't have an item we actually don't care about it
   if (!p)
     return;
 
   auto pBudget = dynamic_cast<KBudgetListItem*>(p);
   if (!pBudget)
     return;
   if (col == 1) {
     pBudget->setText(1, QString().setNum(pBudget->budget().budgetStart().year()));
     return;
   }
 
   // create a copy of the new name without leading and trailing whitespaces
   QString new_name = p->text(0).trimmed();
 
   if (pBudget->budget().name() != new_name) {
     MyMoneyFileTransaction ft;
     try {
       // check if we already have a budget with the new name
       try {
         // this function call will throw an exception, if the budget
         // hasn't been found.
         MyMoneyFile::instance()->budgetByName(new_name);
         // the name already exists, ask the user whether he's sure to keep the name
         if (KMessageBox::questionYesNo(this,
                                        i18n("A budget with the name '%1' already exists. It is not advisable to have "
                                             "multiple budgets with the same identification name. Are you sure you would like "
                                             "to rename the budget?", new_name)) != KMessageBox::Yes) {
           p->setText(0, pBudget->budget().name());
           return;
         }
       } catch (const MyMoneyException &) {
         // all ok, the name is unique
       }
 
       MyMoneyBudget b = pBudget->budget();
       b.setName(new_name);
       // don't use pBudget beyond this point as it will change due to call to modifyBudget
       pBudget = 0;
 
       MyMoneyFile::instance()->modifyBudget(b);
 
       // the above call to modifyBudget will reload the view so
       // all references and pointers to the view have to be
       // re-established. You cannot use pBudget beyond this point!!!
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to modify budget"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify budget"), QString::fromLatin1(e.what()));
     }
   } else {
     pBudget->setText(0, new_name);
   }
 }
 
 void KBudgetView::slotSelectAccount(const MyMoneyObject &obj, eView::Intent intent)
 {
   Q_UNUSED(intent)
   Q_D(KBudgetView);
   d->ui->m_assignmentBox->setEnabled(false);
   if (typeid(obj) != typeid(MyMoneyAccount))
     return;
 
   const MyMoneyAccount& acc = dynamic_cast<const MyMoneyAccount&>(obj);
   d->ui->m_assignmentBox->setEnabled(true);
 
   if (d->m_budget.id().isEmpty())
     return;
 
   QString id = acc.id();
   d->ui->m_leAccounts->setText(MyMoneyFile::instance()->accountToCategory(id));
   d->ui->m_cbBudgetSubaccounts->setChecked(d->m_budget.account(id).budgetSubaccounts());
   d->ui->m_accountTotal->setValue(d->m_budget.account(id).totalBalance());
   MyMoneyBudget::AccountGroup budgetAccount = d->m_budget.account(id);
   if (id != budgetAccount.id()) {
     budgetAccount.setBudgetLevel(MyMoneyBudget::AccountGroup::eMonthly);
   }
   d->ui->m_budgetValue->setBudgetValues(d->m_budget, budgetAccount);
 }
 
 void KBudgetView::slotBudgetedAmountChanged()
 {
   Q_D(KBudgetView);
   if (d->m_budget.id().isEmpty())
     return;
 
   const auto indexes = d->ui->m_accountTree->selectionModel()->selectedIndexes();
   if (indexes.empty())
     return;
   QString accountID = indexes.front().data((int)eAccountsModel::Role::ID).toString();
 
   MyMoneyBudget::AccountGroup accountGroup = d->m_budget.account(accountID);
   accountGroup.setId(accountID);
   d->ui->m_budgetValue->budgetValues(d->m_budget, accountGroup);
   d->m_budget.setAccount(accountGroup, accountID);
 
   d->m_budgetProxyModel->setBudget(d->m_budget);
   d->ui->m_accountTotal->setValue(accountGroup.totalBalance());
 
   d->ui->m_updateButton->setEnabled(!(d->selectedBudget() == d->m_budget));
   d->ui->m_resetButton->setEnabled(!(d->selectedBudget() == d->m_budget));
 }
 
 void KBudgetView::cb_includesSubaccounts_clicked()
 {
   Q_D(KBudgetView);
   if (d->m_budget.id().isEmpty())
     return;
 
   QModelIndexList indexes = d->ui->m_accountTree->selectionModel()->selectedIndexes();
   if (!indexes.empty()) {
     QString accountID = indexes.front().data((int)eAccountsModel::Role::ID).toString();
     // now, we get a reference to the accountgroup, to modify its attribute,
     // and then put the resulting account group instead of the original
     MyMoneyBudget::AccountGroup auxAccount = d->m_budget.account(accountID);
     auxAccount.setBudgetSubaccounts(d->ui->m_cbBudgetSubaccounts->isChecked());
 
     // in case we turn the option on, we check that no subordinate account
     // has a budget. If we find some, we ask the user if he wants to move it
     // to the current account or leave things as they are
     if (d->ui->m_cbBudgetSubaccounts->isChecked()) {
       // TODO: asking the user needs to be added. So long, we assume yes
       if (1) {
         MyMoneyBudget::AccountGroup subAccount;
         if (d->collectSubBudgets(subAccount, indexes.front())) {
           // we found a sub-budget somewhere
           // so we add those figures found and
           // clear the subaccounts
           auxAccount += subAccount;
           d->clearSubBudgets(indexes.front());
         }
 
         if (auxAccount.budgetLevel() == MyMoneyBudget::AccountGroup::eNone) {
           MyMoneyBudget::PeriodGroup period;
           auxAccount.addPeriod(d->m_budget.budgetStart(), period);
           auxAccount.setBudgetLevel(MyMoneyBudget::AccountGroup::eMonthly);
         }
       }
     }
 
     d->m_budget.setAccount(auxAccount, accountID);
     d->m_budgetProxyModel->setBudget(d->m_budget);
     d->ui->m_budgetValue->setBudgetValues(d->m_budget, auxAccount);
 
     d->loadAccounts();
   }
 }
 
 void KBudgetView::slotBudgetBalanceChanged(const MyMoneyMoney &balance)
 {
   Q_D(KBudgetView);
   d->netBalProChanged(balance, d->ui->m_balanceLabel, View::Budget);
 }
 
 void KBudgetView::slotSelectBudget()
 {
   Q_D(KBudgetView);
   d->askSave();
   KBudgetListItem* item;
 
   QTreeWidgetItemIterator widgetIt = QTreeWidgetItemIterator(d->ui->m_budgetList);
   if (d->m_budget.id().isEmpty()) {
     item = dynamic_cast<KBudgetListItem*>(*widgetIt);
     if (item) {
       d->ui->m_budgetList->blockSignals(true);
       d->ui->m_budgetList->setCurrentItem(item, QItemSelectionModel::ClearAndSelect);
       d->ui->m_budgetList->blockSignals(false);
     }
   }
 
   d->ui->m_accountTree->setEnabled(false);
   d->ui->m_assignmentBox->setEnabled(false);
   d->m_budget = MyMoneyBudget();
 
   QTreeWidgetItemIterator it_l(d->ui->m_budgetList, QTreeWidgetItemIterator::Selected);
   item = dynamic_cast<KBudgetListItem*>(*it_l);
   if (item) {
     d->m_budget = item->budget();
     d->ui->m_accountTree->setEnabled(true);
   }
 
   d->refreshHideUnusedButton();
   d->loadAccounts();
   const auto index = d->ui->m_accountTree->currentIndex();
   if (index.isValid()) {
     const auto acc = d->ui->m_accountTree->model()->data(index, (int)eAccountsModel::Role::Account).value<MyMoneyAccount>();
     slotSelectAccount(acc, eView::Intent::None);
   } else {
     d->ui->m_budgetValue->clear();
   }
 
   d->m_budgetList.clear();
   if (!d->m_budget.id().isEmpty())
     d->m_budgetList << d->m_budget;
   d->actionStates();
   d->updateButtonStates();
 }
 
 void KBudgetView::slotHideUnused(bool toggled)
 {
   Q_D(KBudgetView);
   // make sure we show all items for an empty budget
   const auto prevState = !toggled;
   d->refreshHideUnusedButton();
   if (prevState != d->ui->m_hideUnusedButton->isChecked())
     d->m_budgetProxyModel->setHideUnusedIncomeExpenseAccounts(d->ui->m_hideUnusedButton->isChecked());
 }
diff --git a/kmymoney/plugins/views/onlinejoboutbox/konlinejoboutboxview.cpp b/kmymoney/plugins/views/onlinejoboutbox/konlinejoboutboxview.cpp
index 4a8d32d1c..78d2a0af1 100644
--- a/kmymoney/plugins/views/onlinejoboutbox/konlinejoboutboxview.cpp
+++ b/kmymoney/plugins/views/onlinejoboutbox/konlinejoboutboxview.cpp
@@ -1,536 +1,536 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2013-2014 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "konlinejoboutboxview.h"
 
 #include <memory>
 
 #include "ui_konlinejoboutboxview.h"
 #include "kmymoneyviewbase_p.h"
 #include "konlinetransferform.h"
 #include "kmymoneyplugin.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <QAction>
 #include <QMenu>
 #include <QTimer>
 #include <QModelIndex>
 #include <QModelIndexList>
 #include <KMessageBox>
 #include <KActionCollection>
 
 #include "models.h"
 #include "onlinejobmodel.h"
 #include "onlinejobadministration.h"
 #include "onlinejobtyped.h"
 #include "onlinejobmessagesview.h"
 #include "onlinejobmessagesmodel.h"
 #include "onlinepluginextended.h"
 
 #include "mymoneyaccount.h"
 #include "mymoneyfile.h"
 #include "menuenums.h"
 #include "mymoneyenums.h"
 
 #include <QDebug>
 
 class KOnlineJobOutboxViewPrivate : public KMyMoneyViewBasePrivate
 {
   Q_DECLARE_PUBLIC(KOnlineJobOutboxView)
 
 public:
   explicit KOnlineJobOutboxViewPrivate(KOnlineJobOutboxView *qq) :
     KMyMoneyViewBasePrivate(),
     q_ptr(qq),
     ui(new Ui::KOnlineJobOutboxView),
     m_needLoad(true),
     m_onlinePlugins(nullptr),
     m_onlineJobModel(nullptr)
   {
   }
 
   ~KOnlineJobOutboxViewPrivate()
   {
     if (!m_needLoad) {
       // Save column state
       KConfigGroup configGroup = KSharedConfig::openConfig()->group("KOnlineJobOutboxView");
       configGroup.writeEntry("HeaderState", ui->m_onlineJobView->header()->saveState());
     }
   }
 
   void init()
   {
     Q_Q(KOnlineJobOutboxView);
     m_needLoad = false;
     ui->setupUi(q);
 
     // Restore column state
     KConfigGroup configGroup = KSharedConfig::openConfig()->group("KOnlineJobOutboxView");
     QByteArray columns;
     columns = configGroup.readEntry("HeaderState", columns);
     ui->m_onlineJobView->header()->restoreState(columns);
 
     ui->m_onlineJobView->setModel(this->onlineJobsModel());
     q->connect(ui->m_buttonSend, &QAbstractButton::clicked, q, &KOnlineJobOutboxView::slotSendJobs);
     q->connect(ui->m_buttonRemove, &QAbstractButton::clicked, q, &KOnlineJobOutboxView::slotRemoveJob);
     q->connect(ui->m_buttonEdit, &QAbstractButton::clicked, q, static_cast<void (KOnlineJobOutboxView::*)()>(&KOnlineJobOutboxView::slotEditJob));
     q->connect(ui->m_onlineJobView, &QAbstractItemView::doubleClicked, q, static_cast<void (KOnlineJobOutboxView::*)(const QModelIndex &)>(&KOnlineJobOutboxView::slotEditJob));
     q->connect(ui->m_onlineJobView->selectionModel(), &QItemSelectionModel::selectionChanged, q, &KOnlineJobOutboxView::updateButtonState);
 
     // Set new credit transfer button
     q->connect(pActions[eMenu::Action::AccountCreditTransfer], &QAction::changed, q, &KOnlineJobOutboxView::updateNewCreditTransferButton);
     q->connect(ui->m_buttonNewCreditTransfer, &QAbstractButton::clicked, q, &KOnlineJobOutboxView::slotNewCreditTransfer);
     q->updateNewCreditTransferButton();
   }
 
   onlineJobModel* onlineJobsModel()
   {
     Q_Q(KOnlineJobOutboxView);
     if (!m_onlineJobModel) {
       m_onlineJobModel = new onlineJobModel(q);
   #ifdef KMM_MODELTEST
       /// @todo using the ModelTest feature on the onlineJobModel crashes. Need to fix.
       // new ModelTest(m_onlineJobModel, Models::instance());
   #endif
     }
     return m_onlineJobModel;
   }
 
 
   void editJob(const QString jobId)
   {
     try {
       const onlineJob constJob = MyMoneyFile::instance()->getOnlineJob(jobId);
       editJob(constJob);
-    } catch (MyMoneyException&) {
+    } catch (const MyMoneyException &) {
       // Prevent a crash in very rare cases
     }
   }
 
   void editJob(onlineJob job)
   {
     try {
       editJob(onlineJobTyped<creditTransfer>(job));
-    } catch (MyMoneyException&) {
+    } catch (const MyMoneyException &) {
     }
   }
 
   void editJob(const onlineJobTyped<creditTransfer> job)
   {
     Q_Q(KOnlineJobOutboxView);
     auto transferForm = new kOnlineTransferForm(q);
     transferForm->setOnlineJob(job);
     q->connect(transferForm, &QDialog::rejected, transferForm, &QObject::deleteLater);
     q->connect(transferForm, &kOnlineTransferForm::acceptedForSave, q, &KOnlineJobOutboxView::slotOnlineJobSave);
     q->connect(transferForm, &kOnlineTransferForm::acceptedForSend, q, static_cast<void (KOnlineJobOutboxView::*)(onlineJob)>(&KOnlineJobOutboxView::slotOnlineJobSend));
     q->connect(transferForm, &QDialog::accepted, transferForm, &QObject::deleteLater);
     transferForm->show();
   }
 
   KOnlineJobOutboxView     *q_ptr;
   std::unique_ptr<Ui::KOnlineJobOutboxView> ui;
 
   /**
     * This member holds the load state of page
     */
   bool m_needLoad;
   QMap<QString, KMyMoneyPlugin::OnlinePlugin*>* m_onlinePlugins;
   onlineJobModel *m_onlineJobModel;
   MyMoneyAccount m_currentAccount;
 };
 
 KOnlineJobOutboxView::KOnlineJobOutboxView(QWidget *parent) :
   KMyMoneyViewBase(*new KOnlineJobOutboxViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::LogOnlineJob], &QAction::triggered, this, static_cast<void (KOnlineJobOutboxView::*)()>(&KOnlineJobOutboxView::slotOnlineJobLog));
   connect(pActions[eMenu::Action::AccountCreditTransfer], &QAction::triggered, this, &KOnlineJobOutboxView::slotNewCreditTransfer);
 }
 
 KOnlineJobOutboxView::~KOnlineJobOutboxView()
 {
 }
 
 void KOnlineJobOutboxView::updateButtonState() const
 {
   Q_D(const KOnlineJobOutboxView);
   const QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedRows();
   const int selectedItems = indexes.count();
 
   // Send button
   //! @todo Enable button if it is useful
   //ui->m_buttonSend->setEnabled(selectedItems > 0);
 
   // Edit button/action
   bool editable = true;
   QString tooltip;
 
   if (selectedItems == 1) {
     const onlineJob job = d->ui->m_onlineJobView->model()->data(indexes.first(), onlineJobModel::OnlineJobRole).value<onlineJob>();
 
     if (!job.isEditable()) {
       editable = false;
       if (job.sendDate().isValid())
         tooltip = i18n("This job cannot be edited anymore because it was sent already.");
       else if (job.isLocked())
         tooltip = i18n("Job is being processed at the moment.");
       else
         Q_ASSERT(false);
     } else if (!onlineJobAdministration::instance()->canEditOnlineJob(job)) {
       editable = false;
       tooltip = i18n("The plugin to edit this job is not available.");
     }
   } else {
     editable = false;
     tooltip = i18n("You need to select a single job for editing.");
   }
 
   QAction *const onlinejob_edit = pActions[eMenu::Action::EditOnlineJob];
   Q_CHECK_PTR(onlinejob_edit);
   onlinejob_edit->setEnabled(editable);
   onlinejob_edit->setToolTip(tooltip);
 
   d->ui->m_buttonEdit->setEnabled(editable);
   d->ui->m_buttonEdit->setToolTip(tooltip);
 
   // Delete button/action
   QAction *const onlinejob_delete = pActions[eMenu::Action::DeleteOnlineJob];
   Q_CHECK_PTR(onlinejob_delete);
   onlinejob_delete->setEnabled(selectedItems > 0);
   d->ui->m_buttonRemove->setEnabled(onlinejob_delete->isEnabled());
 }
 
 void KOnlineJobOutboxView::updateNewCreditTransferButton()
 {
   Q_D(KOnlineJobOutboxView);
   auto action = pActions[eMenu::Action::AccountCreditTransfer];
   Q_CHECK_PTR(action);
   d->ui->m_buttonNewCreditTransfer->setEnabled(action->isEnabled());
 }
 
 void KOnlineJobOutboxView::slotRemoveJob()
 {
   Q_D(KOnlineJobOutboxView);
   QAbstractItemModel* model = d->ui->m_onlineJobView->model();
   QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedRows();
 
   while (!indexes.isEmpty()) {
     model->removeRow(indexes.at(0).row());
     indexes = d->ui->m_onlineJobView->selectionModel()->selectedRows();
   }
 }
 
 QStringList KOnlineJobOutboxView::selectedOnlineJobs() const
 {
   Q_D(const KOnlineJobOutboxView);
   QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedRows();
 
   if (indexes.isEmpty())
     return QStringList();
 
   QStringList list;
   list.reserve(indexes.count());
 
   const QAbstractItemModel *const model = d->ui->m_onlineJobView->model();
   Q_FOREACH(const QModelIndex& index, indexes) {
     list.append(model->data(index, onlineJobModel::OnlineJobId).toString());
   }
   return list;
 }
 
 void KOnlineJobOutboxView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     default:
       break;
   }
 }
 
 void KOnlineJobOutboxView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   Q_D(KOnlineJobOutboxView);
   switch(intent) {
     case eView::Intent::SetOnlinePlugins:
       if (variant.count() == 1)
         d->m_onlinePlugins = static_cast<QMap<QString, KMyMoneyPlugin::OnlinePlugin*>*>(variant.first().value<void*>());
       break;
     default:
       break;
   }
 }
 
 void KOnlineJobOutboxView::slotSendJobs()
 {
   Q_D(KOnlineJobOutboxView);
   if (d->ui->m_onlineJobView->selectionModel()->hasSelection())
     slotSendSelectedJobs();
   else
     slotSendAllSendableJobs();
 }
 
 void KOnlineJobOutboxView::slotSendAllSendableJobs()
 {
   QList<onlineJob> validJobs;
   foreach (const onlineJob& job, MyMoneyFile::instance()->onlineJobList()) {
     if (job.isValid() && job.isEditable())
       validJobs.append(job);
   }
   qDebug() << "I shall send " << validJobs.count() << "/" << MyMoneyFile::instance()->onlineJobList().count() << " onlineJobs";
   if (!validJobs.isEmpty())
     slotOnlineJobSend(validJobs);
 //    emit sendJobs(validJobs);
 }
 
 void KOnlineJobOutboxView::slotSendSelectedJobs()
 {
   Q_D(KOnlineJobOutboxView);
   QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedRows();
   if (indexes.isEmpty())
     return;
 
   // Valid jobs to send
   QList<onlineJob> validJobs;
   validJobs.reserve(indexes.count());
 
   // Get valid jobs
   const QAbstractItemModel *const model = d->ui->m_onlineJobView->model();
   foreach (const QModelIndex& index, indexes) {
     onlineJob job = model->data(index, onlineJobModel::OnlineJobRole).value<onlineJob>();
     if (job.isValid() && job.isEditable())
       validJobs.append(job);
   }
 
   // Abort if not all jobs can be sent
   if (validJobs.count() != indexes.count()) {
     KMessageBox::information(this, i18nc("The user selected credit transfers to send. But they cannot be sent.",
                                          "Cannot send selection"),
                              i18n("Not all selected credit transfers can be sent because some of them are invalid or were already sent."));
     return;
   }
 
   slotOnlineJobSend(validJobs);
 //  emit sendJobs(validJobs);
 }
 
 void KOnlineJobOutboxView::slotEditJob()
 {
   Q_D(KOnlineJobOutboxView);
   QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedIndexes();
   if (!indexes.isEmpty()) {
     QString jobId = d->ui->m_onlineJobView->model()->data(indexes.first(), onlineJobModel::OnlineJobId).toString();
     Q_ASSERT(!jobId.isEmpty());
     d->editJob(jobId);
 //    emit editJob(jobId);
   }
 }
 
 void KOnlineJobOutboxView::slotEditJob(const QModelIndex &index)
 {
   if (!pActions[eMenu::Action::EditOnlineJob]->isEnabled())
     return;
 
   Q_D(KOnlineJobOutboxView);
   auto jobId = d->ui->m_onlineJobView->model()->data(index, onlineJobModel::OnlineJobId).toString();
   d->editJob(jobId);
 //  emit editJob(jobId);
 }
 
 void KOnlineJobOutboxView::contextMenuEvent(QContextMenuEvent*)
 {
   if (!pActions[eMenu::Action::EditOnlineJob]->isEnabled())
     return;
 
   Q_D(KOnlineJobOutboxView);
   QModelIndexList indexes = d->ui->m_onlineJobView->selectionModel()->selectedIndexes();
   if (!indexes.isEmpty()) {
 //    onlineJob job = d->ui->m_onlineJobView->model()->data(indexes.first(), onlineJobModel::OnlineJobRole).value<onlineJob>();
     pMenus[eMenu::Menu::OnlineJob]->exec(QCursor::pos());
   }
 }
 
 /**
  * Do not know why this is needed, but all other views in KMyMoney have it.
  */
 void KOnlineJobOutboxView::showEvent(QShowEvent* event)
 {
   Q_D(KOnlineJobOutboxView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::OnlineJobOutbox, eView::Action::AboutToShow);
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KOnlineJobOutboxView::executeCustomAction(eView::Action action)
 {
   Q_D(KOnlineJobOutboxView);
   switch(action) {
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KOnlineJobOutboxView);
         QTimer::singleShot(0, d->ui->m_onlineJobView, SLOT(setFocus()));
       }
       break;
 
     case eView::Action::InitializeAfterFileOpen:
       d->onlineJobsModel()->load();
       break;
 
     case eView::Action::CleanupBeforeFileClose:
       d->onlineJobsModel()->unload();
       break;
 
     default:
       break;
   }
 }
 
 void KOnlineJobOutboxView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KOnlineJobOutboxView);
   if (typeid(obj) != typeid(MyMoneyAccount) &&
       (obj.id().isEmpty() && d->m_currentAccount.id().isEmpty())) // do not disable actions that were already disabled)))
     return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
   d->m_currentAccount = acc;
 }
 
 void KOnlineJobOutboxView::slotOnlineJobSave(onlineJob job)
 {
   MyMoneyFileTransaction fileTransaction;
   if (job.id().isEmpty())
     MyMoneyFile::instance()->addOnlineJob(job);
   else
     MyMoneyFile::instance()->modifyOnlineJob(job);
   fileTransaction.commit();
 }
 
 /** @todo when onlineJob queue is used, continue here */
 void KOnlineJobOutboxView::slotOnlineJobSend(onlineJob job)
 {
   MyMoneyFileTransaction fileTransaction;
   if (job.id().isEmpty())
     MyMoneyFile::instance()->addOnlineJob(job);
   else
     MyMoneyFile::instance()->modifyOnlineJob(job);
   fileTransaction.commit();
 
   QList<onlineJob> jobList;
   jobList.append(job);
   slotOnlineJobSend(jobList);
 }
 
 void KOnlineJobOutboxView::slotOnlineJobSend(QList<onlineJob> jobs)
 {
   Q_D(KOnlineJobOutboxView);
   MyMoneyFile *const kmmFile = MyMoneyFile::instance();
   QMultiMap<QString, onlineJob> jobsByPlugin;
 
   // Sort jobs by online plugin & lock them
   foreach (onlineJob job, jobs) {
     Q_ASSERT(!job.id().isEmpty());
     // find the provider
     const MyMoneyAccount originAcc = job.responsibleMyMoneyAccount();
     job.setLock();
     job.addJobMessage(onlineJobMessage(eMyMoney::OnlineJob::MessageType::Debug, "KMyMoneyApp::slotOnlineJobSend", "Added to queue for plugin '" + originAcc.onlineBankingSettings().value("provider").toLower() + '\''));
     MyMoneyFileTransaction fileTransaction;
     kmmFile->modifyOnlineJob(job);
     fileTransaction.commit();
     jobsByPlugin.insert(originAcc.onlineBankingSettings().value("provider").toLower(), job);
   }
 
   // Send onlineJobs to plugins
   QList<QString> usedPlugins = jobsByPlugin.keys();
   std::sort(usedPlugins.begin(), usedPlugins.end());
   const QList<QString>::iterator newEnd = std::unique(usedPlugins.begin(), usedPlugins.end());
   usedPlugins.erase(newEnd, usedPlugins.end());
 
   foreach (const QString& pluginKey, usedPlugins) {
     QMap<QString, KMyMoneyPlugin::OnlinePlugin*>::const_iterator it_p = d->m_onlinePlugins->constFind(pluginKey);
 
     if (it_p != d->m_onlinePlugins->constEnd()) {
       // plugin found, call it
       KMyMoneyPlugin::OnlinePluginExtended *pluginExt = dynamic_cast< KMyMoneyPlugin::OnlinePluginExtended* >(*it_p);
       if (pluginExt == 0) {
         qWarning("Job given for plugin which is not an extended plugin");
         continue;
       }
       //! @fixme remove debug message
       qDebug() << "Sending " << jobsByPlugin.count(pluginKey) << " job(s) to online plugin " << pluginKey;
       QList<onlineJob> jobsToExecute = jobsByPlugin.values(pluginKey);
       QList<onlineJob> executedJobs = jobsToExecute;
       pluginExt->sendOnlineJob(executedJobs);
 
       // Save possible changes of the online job and remove lock
       MyMoneyFileTransaction fileTransaction;
       foreach (onlineJob job, executedJobs) {
         fileTransaction.restart();
         job.setLock(false);
         kmmFile->modifyOnlineJob(job);
         fileTransaction.commit();
       }
 
       if (Q_UNLIKELY(executedJobs.size() != jobsToExecute.size())) {
         // OnlinePlugin did not return all jobs
         qWarning() << "Error saving send online tasks. After restart you should see at minimum all successfully executed jobs marked send. Imperfect plugin: " << pluginExt->objectName();
       }
 
     } else {
       qWarning() << "Error, got onlineJob for an account without online plugin.";
       /** @FIXME can this actually happen? */
     }
   }
 }
 
 void KOnlineJobOutboxView::slotOnlineJobLog()
 {
   QStringList jobIds = this->selectedOnlineJobs();
   slotOnlineJobLog(jobIds);
 }
 
 void KOnlineJobOutboxView::slotOnlineJobLog(const QStringList& onlineJobIds)
 {
   onlineJobMessagesView *const dialog = new onlineJobMessagesView();
   onlineJobMessagesModel *const model = new onlineJobMessagesModel(dialog);
   model->setOnlineJob(MyMoneyFile::instance()->getOnlineJob(onlineJobIds.first()));
   dialog->setModel(model);
   dialog->setAttribute(Qt::WA_DeleteOnClose);
   dialog->show();
   // Note: Objects are not deleted here, Qt's parent-child system has to do that.
 }
 
 void KOnlineJobOutboxView::slotNewCreditTransfer()
 {
   Q_D(KOnlineJobOutboxView);
   auto *transferForm = new kOnlineTransferForm(this);
   if (!d->m_currentAccount.id().isEmpty()) {
     transferForm->setCurrentAccount(d->m_currentAccount.id());
   }
   connect(transferForm, &QDialog::rejected, transferForm, &QObject::deleteLater);
   connect(transferForm, &kOnlineTransferForm::acceptedForSave, this, &KOnlineJobOutboxView::slotOnlineJobSave);
   connect(transferForm, &kOnlineTransferForm::acceptedForSend, this, static_cast<void (KOnlineJobOutboxView::*)(onlineJob)>(&KOnlineJobOutboxView::slotOnlineJobSend));
   connect(transferForm, &QDialog::accepted, transferForm, &QObject::deleteLater);
   transferForm->show();
 }
diff --git a/kmymoney/plugins/views/onlinejoboutbox/konlinetransferform.cpp b/kmymoney/plugins/views/onlinejoboutbox/konlinetransferform.cpp
index 20fa06d1e..19acf0508 100644
--- a/kmymoney/plugins/views/onlinejoboutbox/konlinetransferform.cpp
+++ b/kmymoney/plugins/views/onlinejoboutbox/konlinetransferform.cpp
@@ -1,332 +1,332 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2014 Christian Dávid <christian-david@web.de>
  * (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "konlinetransferform.h"
 #include "ui_konlinetransferform.h"
 
 #include <memory>
 
 #include <QList>
 #include <QDebug>
 #include <QPluginLoader>
 #include <QDateTime>
 
 #include <KStandardAction>
 #include <KLocalizedString>
 #include <KPluginFactory>
 
 #include "kguiutils.h"
 #include "onlinetasks/interfaces/ui/ionlinejobedit.h"
 
 #include "mymoneyfile.h"
 #include "mymoney/onlinejobadministration.h"
 #include "onlinejob.h"
 #include "tasks/onlinetask.h"
 #include "accountsmodel.h"
 
 #include "models/models.h"
 #include "icons/icons.h"
 using namespace Icons;
 
 kOnlineTransferForm::kOnlineTransferForm(QWidget *parent)
   : QDialog(parent),
     ui(new Ui::kOnlineTransferForm),
     m_onlineJobEditWidgets(QList<IonlineJobEdit*>()),
     m_requiredFields(new KMandatoryFieldGroup(this))
 {
   ui->setupUi(this);
   ui->unsupportedIcon->setPixmap(Icons::get(Icon::DialogInformation).pixmap(style()->pixelMetric(QStyle::PM_MessageBoxIconSize)));
   // The ui designer fills the QScrollArea with a QWidget. Remove it so we can simply check for .widget() == nullptr
   // if it contains a valid widget
   delete ui->creditTransferEdit->takeWidget();
 
   OnlineBankingAccountNamesFilterProxyModel* accountsModel = new OnlineBankingAccountNamesFilterProxyModel(this);
   auto const model = Models::instance()->accountsModel();
   accountsModel->setSourceModel(model);
   ui->originAccount->setModel(accountsModel);
 
   ui->convertMessage->hide();
   ui->convertMessage->setWordWrap(true);
 
   auto edits = onlineJobAdministration::instance()->onlineJobEdits();
   std::for_each(edits.constBegin(), edits.constEnd(), [this](onlineJobAdministration::onlineJobEditOffer in) {this->loadOnlineJobEditPlugin(in);});
 
   // Message Widget for read only jobs
   m_duplicateJob = KStandardAction::copy(this);
   connect(m_duplicateJob, &QAction::triggered, this, &kOnlineTransferForm::duplicateCurrentJob);
 
   ui->headMessage->hide();
   ui->headMessage->setWordWrap(true);
   ui->headMessage->setCloseButtonVisible(false);
   ui->headMessage->addAction(m_duplicateJob);
 
   connect(ui->transferTypeSelection, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &kOnlineTransferForm::convertCurrentJob);
 
   connect(ui->buttonAbort, &QAbstractButton::clicked, this, &kOnlineTransferForm::reject);
   connect(ui->buttonSend, &QAbstractButton::clicked, this, &kOnlineTransferForm::sendJob);
   connect(ui->buttonEnque, &QAbstractButton::clicked, this, &kOnlineTransferForm::accept);
   connect(m_requiredFields, static_cast<void (KMandatoryFieldGroup::*)(bool)>(&KMandatoryFieldGroup::stateChanged), ui->buttonEnque, &QPushButton::setEnabled);
 
   connect(ui->originAccount, &KMyMoneyAccountCombo::accountSelected, this, &kOnlineTransferForm::accountChanged);
 
   accountChanged();
   setJobReadOnly(false);
   m_requiredFields->add(ui->originAccount);
   m_requiredFields->setOkButton(ui->buttonSend);
 }
 
 void kOnlineTransferForm::loadOnlineJobEditPlugin(const onlineJobAdministration::onlineJobEditOffer& pluginDesc)
 {
   try {
     std::unique_ptr<QPluginLoader> loader{new QPluginLoader(pluginDesc.fileName, this)};
     QObject* plugin = loader->instance();
     if (!plugin) {
       qWarning() << "Could not load plugin for online job editor from file \"" << pluginDesc.fileName << "\".";
       return;
     }
 
     // Cast to KPluginFactory
     KPluginFactory* pluginFactory = qobject_cast< KPluginFactory* >(plugin);
     if (!pluginFactory) {
       qWarning() << "Could not create plugin factory for online job editor in file \"" << pluginDesc.fileName << "\".";
       return;
     }
 
     IonlineJobEdit* widget = pluginFactory->create<IonlineJobEdit>(pluginDesc.pluginKeyword, this);
     if (!widget) {
       qWarning() << "Could not create online job editor in file \"" << pluginDesc.fileName << "\".";
       return;
     }
 
     // directly load the first widget into QScrollArea
     bool showWidget = true;
     if (!m_onlineJobEditWidgets.isEmpty()) {
       widget->setEnabled(false);
       showWidget = false;
     }
 
     m_onlineJobEditWidgets.append(widget);
     ui->transferTypeSelection->addItem(pluginDesc.name);
     m_requiredFields->add(widget);
 
     if (showWidget)
       showEditWidget(widget);
-  } catch (MyMoneyException&) {
+  } catch (const MyMoneyException &) {
     qWarning("Error while loading a plugin (IonlineJobEdit).");
   }
 }
 
 void kOnlineTransferForm::convertCurrentJob(const int& index)
 {
   Q_ASSERT(index < m_onlineJobEditWidgets.count());
 
   IonlineJobEdit* widget = m_onlineJobEditWidgets.at(index);
 
   // Vars set by onlineJobAdministration::convertBest
   onlineTaskConverter::convertType convertType;
   QString userMessage;
 
   widget->setOnlineJob(onlineJobAdministration::instance()->convertBest(activeOnlineJob(), widget->supportedOnlineTasks(), convertType, userMessage));
 
   if (convertType == onlineTaskConverter::convertImpossible && userMessage.isEmpty())
     userMessage = i18n("During the change of the order your previous entries could not be converted.");
 
   if (!userMessage.isEmpty()) {
     switch (convertType) {
       case onlineTaskConverter::convertionLossyMajor:
         ui->convertMessage->setMessageType(KMessageWidget::Warning);
         break;
       case onlineTaskConverter::convertImpossible:
       case onlineTaskConverter::convertionLossyMinor:
         ui->convertMessage->setMessageType(KMessageWidget::Information);
         break;
       case onlineTaskConverter::convertionLoseless: break;
     }
 
     ui->convertMessage->setText(userMessage);
     ui->convertMessage->animatedShow();
   }
 
   showEditWidget(widget);
 }
 
 void kOnlineTransferForm::duplicateCurrentJob()
 {
   IonlineJobEdit* widget = qobject_cast< IonlineJobEdit* >(ui->creditTransferEdit->widget());
   if (widget == 0)
     return;
 
   onlineJob duplicate(QString(), activeOnlineJob());
   widget->setOnlineJob(duplicate);
 }
 
 void kOnlineTransferForm::accept()
 {
   emit acceptedForSave(activeOnlineJob());
   QDialog::accept();
 }
 
 void kOnlineTransferForm::sendJob()
 {
   emit acceptedForSend(activeOnlineJob());
     QDialog::accept();
 }
 
 void kOnlineTransferForm::reject()
 {
   QDialog::reject();
 }
 
 bool kOnlineTransferForm::setOnlineJob(const onlineJob job)
 {
   QString name;
   try {
     name = job.task()->taskName();
   } catch (const onlineJob::emptyTask&) {
     return false;
   }
 
   setCurrentAccount(job.responsibleAccount());
   if (showEditWidget(name)) {
     IonlineJobEdit* widget = qobject_cast<IonlineJobEdit*>(ui->creditTransferEdit->widget());
     if (widget != 0) { // This can happen if there are no widgets
       const bool ret = widget->setOnlineJob(job);
       setJobReadOnly(!job.isEditable());
       return ret;
     }
   }
   return false;
 }
 
 void kOnlineTransferForm::accountChanged()
 {
   const QString accountId = ui->originAccount->getSelected();
   try {
     ui->orderAccountBalance->setValue(MyMoneyFile::instance()->balance(accountId));
-  } catch (const MyMoneyException&) {
+  } catch (const MyMoneyException &) {
     // @todo this can happen until the selection allows to select correct accounts only
     ui->orderAccountBalance->setText("");
   }
 
   foreach (IonlineJobEdit* widget, m_onlineJobEditWidgets)
   widget->setOriginAccount(accountId);
 
   checkNotSupportedWidget();
 }
 
 bool kOnlineTransferForm::checkEditWidget()
 {
   return checkEditWidget(qobject_cast<IonlineJobEdit*>(ui->creditTransferEdit->widget()));
 }
 
 bool kOnlineTransferForm::checkEditWidget(IonlineJobEdit* widget)
 {
   if (widget != 0 && onlineJobAdministration::instance()->isJobSupported(ui->originAccount->getSelected(), widget->supportedOnlineTasks())) {
     return true;
   }
   return false;
 }
 
 /** @todo auto set another widget if a loseless convert is possible */
 void kOnlineTransferForm::checkNotSupportedWidget()
 {
   if (!checkEditWidget()) {
     ui->displayStack->setCurrentIndex(0);
   } else {
     ui->displayStack->setCurrentIndex(1);
   }
 }
 
 void kOnlineTransferForm::setCurrentAccount(const QString& accountId)
 {
   ui->originAccount->setSelected(accountId);
 }
 
 onlineJob kOnlineTransferForm::activeOnlineJob() const
 {
   IonlineJobEdit* widget = qobject_cast<IonlineJobEdit*>(ui->creditTransferEdit->widget());
   if (widget == 0)
     return onlineJob();
 
   return widget->getOnlineJob();
 }
 
 void kOnlineTransferForm::setJobReadOnly(const bool& readOnly)
 {
   ui->originAccount->setDisabled(readOnly);
   ui->transferTypeSelection->setDisabled(readOnly);
 
   if (readOnly) {
     ui->headMessage->setMessageType(KMessageWidget::Information);
     if (activeOnlineJob().sendDate().isValid())
       ui->headMessage->setText(i18n("This credit-transfer was sent to your bank at %1 therefore cannot be edited anymore. You may create a copy for editing.", activeOnlineJob().sendDate().toString(Qt::DefaultLocaleShortDate)));
     else
       ui->headMessage->setText(i18n("This credit-transfer is not editable. You may create a copy for editing."));
 
     if (this->isHidden())
       ui->headMessage->show();
     else
       ui->headMessage->animatedShow();
   } else {
     ui->headMessage->animatedHide();
   }
 }
 
 bool kOnlineTransferForm::showEditWidget(const QString& onlineTaskName)
 {
   int index = 0;
   foreach (IonlineJobEdit* widget, m_onlineJobEditWidgets) {
     if (widget->supportedOnlineTasks().contains(onlineTaskName)) {
       ui->transferTypeSelection->setCurrentIndex(index);
       showEditWidget(widget);
       return true;
     }
     ++index;
   }
   return false;
 }
 
 void kOnlineTransferForm::showEditWidget(IonlineJobEdit* widget)
 {
   Q_CHECK_PTR(widget);
 
   QWidget* oldWidget = ui->creditTransferEdit->takeWidget();
   if (oldWidget != 0) { // This is true at the first call of showEditWidget() and if there are no widgets.
     oldWidget->setEnabled(false);
     disconnect(qobject_cast<IonlineJobEdit*>(oldWidget), &IonlineJobEdit::readOnlyChanged, this, &kOnlineTransferForm::setJobReadOnly);
   }
 
   widget->setEnabled(true);
   ui->creditTransferEdit->setWidget(widget);
   setJobReadOnly(widget->isReadOnly());
   widget->show();
 
   connect(widget, &IonlineJobEdit::readOnlyChanged, this, &kOnlineTransferForm::setJobReadOnly);
   checkNotSupportedWidget();
   m_requiredFields->changed();
 }
 
 kOnlineTransferForm::~kOnlineTransferForm()
 {
   ui->creditTransferEdit->takeWidget();
   qDeleteAll(m_onlineJobEditWidgets);
 
   delete ui;
   delete m_duplicateJob;
 }
diff --git a/kmymoney/plugins/views/onlinejoboutbox/onlinejobmodel.cpp b/kmymoney/plugins/views/onlinejoboutbox/onlinejobmodel.cpp
index 50d2b15ea..255d3f8a0 100644
--- a/kmymoney/plugins/views/onlinejoboutbox/onlinejobmodel.cpp
+++ b/kmymoney/plugins/views/onlinejoboutbox/onlinejobmodel.cpp
@@ -1,279 +1,278 @@
 /*
  * This file is part of KMyMoney, A Personal Finance Manager by KDE
  * Copyright (C) 2013-2015 Christian Dávid <christian-david@web.de>
  *
  * 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.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include "onlinejobmodel.h"
 
 #include <QIcon>
 #include <QDateTime>
 
 #include <KLocalizedString>
 
 #include "mymoneyobject.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyutils.h"
 #include "onlinetasks/interfaces/tasks/onlinetask.h"
 #include "onlinetasks/interfaces/tasks/credittransfer.h"
 #include "mymoney/onlinejobtyped.h"
 #include "payeeidentifier.h"
 #include "payeeidentifiertyped.h"
 #include "ibanbic.h"
 #include "icons/icons.h"
 #include "mymoneyenums.h"
 
 using namespace Icons;
 
 onlineJobModel::onlineJobModel(QObject *parent) :
     QAbstractTableModel(parent),
     m_jobIdList(QStringList())
 {
   MyMoneyFile *const file = MyMoneyFile::instance();
   connect(file, &MyMoneyFile::objectAdded,
           this, &onlineJobModel::slotObjectAdded);
   connect(file, &MyMoneyFile::objectModified,
           this, &onlineJobModel::slotObjectModified);
   connect(file, &MyMoneyFile::objectRemoved,
           this, &onlineJobModel::slotObjectRemoved);
 }
 
 void onlineJobModel::load()
 {
   unload();
   beginInsertRows(QModelIndex(), 0, 0);
   foreach (const onlineJob job, MyMoneyFile::instance()->onlineJobList()) {
     m_jobIdList.append(job.id());
   }
   endInsertRows();
 }
 
 void onlineJobModel::unload()
 {
   if (!m_jobIdList.isEmpty()) {
     beginResetModel();
     m_jobIdList.clear();
     endResetModel();
   }
 }
 
 int onlineJobModel::rowCount(const QModelIndex & parent) const
 {
   if (parent.isValid())
     return 0;
   return m_jobIdList.count();
 }
 
 int onlineJobModel::columnCount(const QModelIndex & parent) const
 {
   if (parent.isValid())
     return 0;
   return 4;
 }
 
 QVariant onlineJobModel::headerData(int section, Qt::Orientation orientation, int role) const
 {
   if (role != Qt::DisplayRole)
     return QVariant();
   if (orientation == Qt::Horizontal) {
     switch (section) {
       case columns::ColAccount: return i18n("Account");
       case columns::ColAction: return i18n("Action");
       case columns::ColDestination: return i18n("Destination");
       case columns::ColValue: return i18n("Value");
     }
   }
   return QVariant();
 }
 
 /**
  * @todo LOW improve speed
  * @todo use now onlineJob system
  */
 QVariant onlineJobModel::data(const QModelIndex & index, int role) const
 {
   if (index.parent().isValid())
     return QVariant();
 
   Q_ASSERT(m_jobIdList.length() > index.row());
   onlineJob job;
 
   try {
     job = MyMoneyFile::instance()->getOnlineJob(m_jobIdList[index.row()]);
-  } catch (const MyMoneyException&) {
+  } catch (const MyMoneyException &) {
     return QVariant();
   }
 
   // id of MyMoneyObject
   if (role == roles::OnlineJobId)
     return QVariant::fromValue(job.id());
   else if (role == roles::OnlineJobRole)
     return QVariant::fromValue(job);
 
   // If job is null, display an error message and exit
   if (job.isNull()) {
     if (index.column() == columns::ColAction) {
       switch (role) {
         case Qt::DisplayRole: return i18n("Not able to display this job.");
         case Qt::ToolTipRole: return i18n("Could not find a plugin to display this job or it does not contain any data.");
       }
     }
     return QVariant();
   }
 
   // Show general information
   if (index.column() == columns::ColAccount) {
     // Account column
     if (role == Qt::DisplayRole) {
       return QVariant::fromValue(job.responsibleMyMoneyAccount().name());
     } else if (role == Qt::DecorationRole) {
       if (job.isLocked())
         return Icons::get(Icon::TaskOngoing);
 
       switch (job.bankAnswerState()) {
         case onlineJob::acceptedByBank: return Icons::get(Icon::TaskComplete);
         case onlineJob::sendingError:
         case onlineJob::abortedByUser:
         case onlineJob::rejectedByBank: return Icons::get(Icon::TaskReject);
         case onlineJob::noBankAnswer: break;
       }
       if (job.sendDate().isValid()) {
         return Icons::get(Icon::TaskAccepted);
       } else if (!job.isValid()) {
         return Icons::get(Icon::TaskAttention);
       }
     } else if (role == Qt::ToolTipRole) {
       if (job.isLocked())
         return i18n("Job is being processed at the moment.");
 
       switch (job.bankAnswerState()) {
         case onlineJob::acceptedByBank: return i18nc("Arg 1 is a date/time", "This job was accepted by the bank on %1.", job.bankAnswerDate().toString(Qt::DefaultLocaleShortDate));
         case onlineJob::sendingError: return i18nc("Arg 1 is a date/time", "Sending this job failed (tried on %1).", job.sendDate().toString(Qt::DefaultLocaleShortDate));
         case onlineJob::abortedByUser: return i18n("Sending this job was manually aborted.");
         case onlineJob::rejectedByBank: return i18nc("Arg 1 is a date/time", "The bank rejected this job on %1.", job.bankAnswerDate().toString(Qt::DefaultLocaleShortDate));
         case onlineJob::noBankAnswer:
           if (job.sendDate().isValid())
             return i18nc("Arg 1 is a date/time", "The bank accepted this job on %1.", job.sendDate().toString(Qt::DefaultLocaleShortDate));
           else if (!job.isValid())
             return i18n("This job needs further editing and cannot be sent therefore.");
           else
             return i18n("This job is ready for sending.");
       }
     }
 
     return QVariant();
   } else if (index.column() == columns::ColAction) {
     if (role == Qt::DisplayRole)
       return QVariant::fromValue(job.task()->jobTypeName());
     return QVariant();
   }
 
   // Show credit transfer data
   try {
     onlineJobTyped<creditTransfer> transfer(job);
 
     if (index.column() == columns::ColValue) {
       if (role == Qt::DisplayRole)
         return QVariant::fromValue(MyMoneyUtils::formatMoney(transfer.task()->value(), transfer.task()->currency()));
       if (role == Qt::TextAlignmentRole)
         return int (Qt::AlignVCenter | Qt::AlignRight);
     } else if (index.column() == columns::ColDestination) {
       if (role == Qt::DisplayRole) {
         const payeeIdentifierTyped<payeeIdentifiers::ibanBic> ibanBic(transfer.constTask()->beneficiary());
         return QVariant(ibanBic->ownerName());
       }
     }
-  } catch (MyMoneyException&) {
-  } catch (payeeIdentifier::exception&) {
+  } catch (const MyMoneyException &) {
   }
 
   return QVariant();
 }
 
 void onlineJobModel::reloadAll()
 {
   emit dataChanged(index(rowCount() - 1, 0), index(rowCount() - 1, columnCount() - 1));
 }
 
 /**
  * This method removes the rows from MyMoneyFile.
  */
 bool onlineJobModel::removeRow(int row, const QModelIndex& parent)
 {
   if (parent.isValid())
     return false;
 
   Q_ASSERT(m_jobIdList.count() < row);
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyFileTransaction transaction;
   const onlineJob job = file->getOnlineJob(m_jobIdList[row]);
   file->removeOnlineJob(job);
   transaction.commit();
   return true;
 }
 
 /**
  * This method removes the rows from MyMoneyFile.
  */
 bool onlineJobModel::removeRows(int row, int count, const QModelIndex & parent)
 {
   if (parent.isValid())
     return false;
 
   Q_ASSERT(m_jobIdList.count() > row);
   Q_ASSERT(m_jobIdList.count() >= (row + count));
 
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyFileTransaction transaction;
   for (int i = 0; i < count; ++i) {
     const onlineJob job = file->getOnlineJob(m_jobIdList[row+i]);
     file->removeOnlineJob(job);
   }
   transaction.commit();
   return true;
 }
 
 void onlineJobModel::slotObjectAdded(eMyMoney::File::Object objType, const QString& id)
 {
   if (Q_LIKELY(objType != eMyMoney::File::Object::OnlineJob))
     return;
   beginInsertRows(QModelIndex(), rowCount(), rowCount());
   m_jobIdList.append(id);
   endInsertRows();
 }
 
 void onlineJobModel::slotObjectModified(eMyMoney::File::Object objType, const QString& id)
 {
   if (Q_LIKELY(objType != eMyMoney::File::Object::OnlineJob))
     return;
 
   int row = m_jobIdList.indexOf(id);
   if (row != -1)
     emit dataChanged(index(row, 0), index(row, columnCount() - 1));
 }
 
 void onlineJobModel::slotObjectRemoved(eMyMoney::File::Object objType, const QString& id)
 {
   if (Q_LIKELY(objType != eMyMoney::File::Object::OnlineJob))
     return;
 
   int row = m_jobIdList.indexOf(id);
   if (row != -1) {
     m_jobIdList.removeAll(id);
     beginRemoveRows(QModelIndex(), row, row);
     endRemoveRows();
   }
 }
diff --git a/kmymoney/plugins/views/reports/kreportconfigurationfilterdlg.cpp b/kmymoney/plugins/views/reports/kreportconfigurationfilterdlg.cpp
index b1feed73e..a67d86086 100644
--- a/kmymoney/plugins/views/reports/kreportconfigurationfilterdlg.cpp
+++ b/kmymoney/plugins/views/reports/kreportconfigurationfilterdlg.cpp
@@ -1,660 +1,660 @@
 /***************************************************************************
                           kreportconfigurationdlg.cpp  -  description
                              -------------------
     begin                : Mon Jun 21 2004
     copyright            : (C) 2000-2004 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 <ace.j@hotpop.com>
                            (C) 2017, 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kreportconfigurationfilterdlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPushButton>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KHelpClient>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ktransactionfilter.h"
 #include "kmymoneyaccountselector.h"
 #include "mymoneyfile.h"
 #include "mymoneyexception.h"
 #include "mymoneybudget.h"
 #include "mymoneyreport.h"
 #include "daterangedlg.h"
 #include "reporttabimpl.h"
 #include "mymoneyenums.h"
 
 #include <ui_kreportconfigurationfilterdlg.h>
 #include <ui_reporttabgeneral.h>
 #include <ui_reporttabrowcolpivot.h>
 #include <ui_reporttabrowcolquery.h>
 #include <ui_reporttabchart.h>
 #include <ui_reporttabrange.h>
 #include <ui_reporttabcapitalgain.h>
 #include <ui_reporttabperformance.h>
 
 class KReportConfigurationFilterDlgPrivate
 {
   Q_DISABLE_COPY(KReportConfigurationFilterDlgPrivate)
 
 public:
   KReportConfigurationFilterDlgPrivate(KReportConfigurationFilterDlg *qq) :
     q_ptr(qq),
     ui(new Ui::KReportConfigurationFilterDlg),
     m_tabRowColPivot(nullptr),
     m_tabRowColQuery(nullptr),
     m_tabChart(nullptr),
     m_tabRange(nullptr),
     m_dateRange(nullptr)
   {
   }
 
   ~KReportConfigurationFilterDlgPrivate()
   {
     delete ui;
   }
 
   KReportConfigurationFilterDlg      *q_ptr;
   Ui::KReportConfigurationFilterDlg  *ui;
 
   QPointer<ReportTabGeneral>     m_tabGeneral;
   QPointer<ReportTabRowColPivot> m_tabRowColPivot;
   QPointer<ReportTabRowColQuery> m_tabRowColQuery;
   QPointer<ReportTabChart>       m_tabChart;
   QPointer<ReportTabRange>       m_tabRange;
   QPointer<ReportTabCapitalGain> m_tabCapitalGain;
   QPointer<ReportTabPerformance> m_tabPerformance;
   QPointer<KTransactionFilter>           m_tabFilters;
 
   MyMoneyReport m_initialState;
   MyMoneyReport m_currentState;
   QVector<MyMoneyBudget> m_budgets;
   DateRangeDlg                    *m_dateRange;
 };
 
 KReportConfigurationFilterDlg::KReportConfigurationFilterDlg(MyMoneyReport report, QWidget *parent) :
   QDialog(parent),
   d_ptr(new KReportConfigurationFilterDlgPrivate(this))
 {
   Q_D(KReportConfigurationFilterDlg);
 
   d->ui->setupUi(this);
   d->m_initialState = report;
   d->m_currentState = report;
 
   //
   // Rework labeling
   //
 
   setWindowTitle(i18n("Report Configuration"));
   //
   // Rework the buttons
   //
 
   // the Apply button is always enabled
   d->ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
   d->ui->buttonBox->button(QDialogButtonBox::Apply)->setToolTip(i18nc("@info:tooltip for report configuration apply button", "Apply the configuration changes to the report"));
 
 
   connect(d->ui->buttonBox->button(QDialogButtonBox::Apply), &QAbstractButton::clicked, this, &KReportConfigurationFilterDlg::slotSearch);
   connect(d->ui->buttonBox->button(QDialogButtonBox::Close), &QAbstractButton::clicked, this, &QDialog::close);
   connect(d->ui->buttonBox->button(QDialogButtonBox::Reset), &QAbstractButton::clicked, this, &KReportConfigurationFilterDlg::slotReset);
   connect(d->ui->buttonBox->button(QDialogButtonBox::Help), &QAbstractButton::clicked, this, &KReportConfigurationFilterDlg::slotShowHelp);
 
   //
   // Add new tabs
   //
   if (d->m_initialState.reportType() == MyMoneyReport::ePivotTable) {
     // we will use date range together with data range
     d->m_tabFilters = new KTransactionFilter(this, (report.rowType() == MyMoneyReport::eAccount), false);
   } else {
     d->m_tabFilters = new KTransactionFilter(this, (report.rowType() == MyMoneyReport::eAccount));
     d->m_dateRange = d->m_tabFilters->dateRange();
   }
 
   d->ui->m_tabWidget->addTab(d->m_tabFilters, i18nc("Filters tab", "Filters"));
 
   d->m_tabGeneral = new ReportTabGeneral(d->ui->m_criteriaTab);
   d->ui->m_criteriaTab->insertTab(0, d->m_tabGeneral, i18nc("General tab", "General"));
 
   if (d->m_initialState.reportType() == MyMoneyReport::ePivotTable) {
     int tabNr = 1;
     if (!(d->m_initialState.isIncludingPrice() || d->m_initialState.isIncludingAveragePrice())) {
       d->m_tabRowColPivot = new ReportTabRowColPivot(d->ui->m_criteriaTab);
       d->ui->m_criteriaTab->insertTab(tabNr++, d->m_tabRowColPivot, i18n("Rows/Columns"));
       connect(d->m_tabRowColPivot->ui->m_comboRows, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, static_cast<void (KReportConfigurationFilterDlg::*)(int)>(&KReportConfigurationFilterDlg::slotRowTypeChanged));
       connect(d->m_tabRowColPivot->ui->m_comboRows, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, static_cast<void (KReportConfigurationFilterDlg::*)(int)>(&KReportConfigurationFilterDlg::slotUpdateColumnsCombo));
       //control the state of the includeTransfer check
       connect(d->m_tabFilters->categoriesView(), &KMyMoneySelector::stateChanged, this, &KReportConfigurationFilterDlg::slotUpdateCheckTransfers);
     }
 
     d->m_tabChart = new ReportTabChart(d->ui->m_criteriaTab);
     d->ui->m_criteriaTab->insertTab(tabNr++, d->m_tabChart, i18n("Chart"));
 
     d->m_tabRange = new ReportTabRange(d->ui->m_criteriaTab);
     d->ui->m_criteriaTab->insertTab(tabNr++, d->m_tabRange, i18n("Range"));
 
     d->m_dateRange = d->m_tabRange->m_dateRange;
 
     if (!(d->m_initialState.isIncludingPrice() || d->m_initialState.isIncludingAveragePrice())) {
       connect(d->m_tabRange->ui->m_comboColumns, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, &KReportConfigurationFilterDlg::slotColumnTypeChanged);
       connect(d->m_tabRange->ui->m_comboColumns, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, static_cast<void (KReportConfigurationFilterDlg::*)(int)>(&KReportConfigurationFilterDlg::slotUpdateColumnsCombo));
     }
     connect(d->m_tabChart->ui->m_logYaxis, &QCheckBox::stateChanged, this, &KReportConfigurationFilterDlg::slotLogAxisChanged);
   } else if (d->m_initialState.reportType() == MyMoneyReport::eQueryTable) {
     // eInvestmentHoldings is a special-case report, and you cannot configure the
     // rows & columns of that report.
     if (d->m_initialState.rowType() < MyMoneyReport::eAccountByTopAccount) {
       d->m_tabRowColQuery = new ReportTabRowColQuery(d->ui->m_criteriaTab);
       d->ui->m_criteriaTab->insertTab(1, d->m_tabRowColQuery, i18n("Rows/Columns"));
     }
     if (d->m_initialState.queryColumns() & MyMoneyReport::eQCcapitalgain) {
       d->m_tabCapitalGain = new ReportTabCapitalGain(d->ui->m_criteriaTab);
       d->ui->m_criteriaTab->insertTab(1, d->m_tabCapitalGain, i18n("Report"));
     }
     if (d->m_initialState.queryColumns() & MyMoneyReport::eQCperformance) {
       d->m_tabPerformance = new ReportTabPerformance(d->ui->m_criteriaTab);
       d->ui->m_criteriaTab->insertTab(1, d->m_tabPerformance, i18n("Report"));
     }
   }
 
   d->ui->m_criteriaTab->setCurrentIndex(d->ui->m_criteriaTab->indexOf(d->m_tabGeneral));
   d->ui->m_criteriaTab->setMinimumSize(500, 200);
 
   QList<MyMoneyBudget> list = MyMoneyFile::instance()->budgetList();
   QList<MyMoneyBudget>::const_iterator it_b;
   for (it_b = list.constBegin(); it_b != list.constEnd(); ++it_b) {
     d->m_budgets.push_back(*it_b);
   }
 
   //
   // Now set up the widgets with proper values
   //
   slotReset();
 }
 
 KReportConfigurationFilterDlg::~KReportConfigurationFilterDlg()
 {
 }
 
 MyMoneyReport KReportConfigurationFilterDlg::getConfig() const
 {
   Q_D(const KReportConfigurationFilterDlg);
   return d->m_currentState;
 }
 
 void KReportConfigurationFilterDlg::slotSearch()
 {
   Q_D(KReportConfigurationFilterDlg);
   // setup the filter from the dialog widgets
   auto filter = d->m_tabFilters->setupFilter();
 
   // Copy the m_filter over to the filter part of m_currentConfig.
   d->m_currentState.assignFilter(filter);
 
   // Then extract the report properties
   d->m_currentState.setName(d->m_tabGeneral->ui->m_editName->text());
   d->m_currentState.setComment(d->m_tabGeneral->ui->m_editComment->text());
   d->m_currentState.setConvertCurrency(d->m_tabGeneral->ui->m_checkCurrency->isChecked());
   d->m_currentState.setFavorite(d->m_tabGeneral->ui->m_checkFavorite->isChecked());
   d->m_currentState.setSkipZero(d->m_tabGeneral->ui->m_skipZero->isChecked());
 
   if (d->m_tabRowColPivot) {
     MyMoneyReport::EDetailLevel dl[4] = { MyMoneyReport::eDetailAll, MyMoneyReport::eDetailTop, MyMoneyReport::eDetailGroup, MyMoneyReport::eDetailTotal };
 
     d->m_currentState.setDetailLevel(dl[d->m_tabRowColPivot->ui->m_comboDetail->currentIndex()]);
 
     // modify the rowtype only if the widget is enabled
     if (d->m_tabRowColPivot->ui->m_comboRows->isEnabled()) {
       MyMoneyReport::ERowType rt[2] = { MyMoneyReport::eExpenseIncome, MyMoneyReport::eAssetLiability };
       d->m_currentState.setRowType(rt[d->m_tabRowColPivot->ui->m_comboRows->currentIndex()]);
     }
 
     d->m_currentState.setShowingRowTotals(false);
     if (d->m_tabRowColPivot->ui->m_comboRows->currentIndex() == 0)
       d->m_currentState.setShowingRowTotals(d->m_tabRowColPivot->ui->m_checkTotalColumn->isChecked());
 
     d->m_currentState.setShowingColumnTotals(d->m_tabRowColPivot->ui->m_checkTotalRow->isChecked());
     d->m_currentState.setIncludingSchedules(d->m_tabRowColPivot->ui->m_checkScheduled->isChecked());
 
     d->m_currentState.setIncludingTransfers(d->m_tabRowColPivot->ui->m_checkTransfers->isChecked());
 
     d->m_currentState.setIncludingUnusedAccounts(d->m_tabRowColPivot->ui->m_checkUnused->isChecked());
 
     if (d->m_tabRowColPivot->ui->m_comboBudget->isEnabled()) {
       d->m_currentState.setBudget(d->m_budgets[d->m_tabRowColPivot->ui->m_comboBudget->currentItem()].id(), d->m_initialState.rowType() == MyMoneyReport::eBudgetActual);
     } else {
       d->m_currentState.setBudget(QString(), false);
     }
 
     //set moving average days
     if (d->m_tabRowColPivot->ui->m_movingAverageDays->isEnabled()) {
       d->m_currentState.setMovingAverageDays(d->m_tabRowColPivot->ui->m_movingAverageDays->value());
     }
   } else if (d->m_tabRowColQuery) {
     MyMoneyReport::ERowType rtq[8] = { MyMoneyReport::eCategory, MyMoneyReport::eTopCategory, MyMoneyReport::eTag, MyMoneyReport::ePayee, MyMoneyReport::eAccount, MyMoneyReport::eTopAccount, MyMoneyReport::eMonth, MyMoneyReport::eWeek };
     d->m_currentState.setRowType(rtq[d->m_tabRowColQuery->ui->m_comboOrganizeBy->currentIndex()]);
 
     unsigned qc = MyMoneyReport::eQCnone;
 
     if (d->m_currentState.queryColumns() & MyMoneyReport::eQCloan)
       // once a loan report, always a loan report
       qc = MyMoneyReport::eQCloan;
 
     if (d->m_tabRowColQuery->ui->m_checkNumber->isChecked())
       qc |= MyMoneyReport::eQCnumber;
     if (d->m_tabRowColQuery->ui->m_checkPayee->isChecked())
       qc |= MyMoneyReport::eQCpayee;
     if (d->m_tabRowColQuery->ui->m_checkTag->isChecked())
       qc |= MyMoneyReport::eQCtag;
     if (d->m_tabRowColQuery->ui->m_checkCategory->isChecked())
       qc |= MyMoneyReport::eQCcategory;
     if (d->m_tabRowColQuery->ui->m_checkMemo->isChecked())
       qc |= MyMoneyReport::eQCmemo;
     if (d->m_tabRowColQuery->ui->m_checkAccount->isChecked())
       qc |= MyMoneyReport::eQCaccount;
     if (d->m_tabRowColQuery->ui->m_checkReconciled->isChecked())
       qc |= MyMoneyReport::eQCreconciled;
     if (d->m_tabRowColQuery->ui->m_checkAction->isChecked())
       qc |= MyMoneyReport::eQCaction;
     if (d->m_tabRowColQuery->ui->m_checkShares->isChecked())
       qc |= MyMoneyReport::eQCshares;
     if (d->m_tabRowColQuery->ui->m_checkPrice->isChecked())
       qc |= MyMoneyReport::eQCprice;
     if (d->m_tabRowColQuery->ui->m_checkBalance->isChecked())
       qc |= MyMoneyReport::eQCbalance;
 
     d->m_currentState.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(qc));
 
     d->m_currentState.setTax(d->m_tabRowColQuery->ui->m_checkTax->isChecked());
     d->m_currentState.setInvestmentsOnly(d->m_tabRowColQuery->ui->m_checkInvestments->isChecked());
     d->m_currentState.setLoansOnly(d->m_tabRowColQuery->ui->m_checkLoans->isChecked());
 
     d->m_currentState.setDetailLevel(d->m_tabRowColQuery->ui->m_checkHideSplitDetails->isChecked() ?
                                   MyMoneyReport::eDetailNone : MyMoneyReport::eDetailAll);
     d->m_currentState.setHideTransactions(d->m_tabRowColQuery->ui->m_checkHideTransactions->isChecked());
     d->m_currentState.setShowingColumnTotals(!d->m_tabRowColQuery->ui->m_checkHideTotals->isChecked());
   }
 
   if (d->m_tabChart) {
     MyMoneyReport::EChartType ct[5] = { MyMoneyReport::eChartLine, MyMoneyReport::eChartBar, MyMoneyReport::eChartStackedBar, MyMoneyReport::eChartPie, MyMoneyReport::eChartRing };
     d->m_currentState.setChartType(ct[d->m_tabChart->ui->m_comboType->currentIndex()]);
 
     d->m_currentState.setChartCHGridLines(d->m_tabChart->ui->m_checkCHGridLines->isChecked());
     d->m_currentState.setChartSVGridLines(d->m_tabChart->ui->m_checkSVGridLines->isChecked());
     d->m_currentState.setChartDataLabels(d->m_tabChart->ui->m_checkValues->isChecked());
     d->m_currentState.setChartByDefault(d->m_tabChart->ui->m_checkShowChart->isChecked());
     d->m_currentState.setChartLineWidth(d->m_tabChart->ui->m_lineWidth->value());
     d->m_currentState.setLogYAxis(d->m_tabChart->ui->m_logYaxis->isChecked());
   }
 
   if (d->m_tabRange) {
     d->m_currentState.setDataRangeStart(d->m_tabRange->ui->m_dataRangeStart->text());
     d->m_currentState.setDataRangeEnd(d->m_tabRange->ui->m_dataRangeEnd->text());
     d->m_currentState.setDataMajorTick(d->m_tabRange->ui->m_dataMajorTick->text());
     d->m_currentState.setDataMinorTick(d->m_tabRange->ui->m_dataMinorTick->text());
     d->m_currentState.setYLabelsPrecision(d->m_tabRange->ui->m_yLabelsPrecision->value());
     d->m_currentState.setDataFilter((MyMoneyReport::dataOptionE)d->m_tabRange->ui->m_dataLock->currentIndex());
 
     MyMoneyReport::EColumnType ct[6] = { MyMoneyReport::eDays, MyMoneyReport::eWeeks, MyMoneyReport::eMonths, MyMoneyReport::eBiMonths, MyMoneyReport::eQuarters, MyMoneyReport::eYears };
     bool dy[6] = { true, true, false, false, false, false };
     d->m_currentState.setColumnType(ct[d->m_tabRange->ui->m_comboColumns->currentIndex()]);
 
     //TODO (Ace) This should be implicit in the call above.  MMReport needs fixin'
     d->m_currentState.setColumnsAreDays(dy[d->m_tabRange->ui->m_comboColumns->currentIndex()]);
     d->m_currentState.setDateFilter(d->m_dateRange->fromDate(), d->m_dateRange->toDate());
   }
 
   // setup the date lock
   eMyMoney::TransactionFilter::Date range = d->m_dateRange->dateRange();
   d->m_currentState.setDateFilter(range);
 
   if (d->m_tabCapitalGain) {
     d->m_currentState.setTermSeparator(d->m_tabCapitalGain->ui->m_termSeparator->date());
     d->m_currentState.setShowSTLTCapitalGains(d->m_tabCapitalGain->ui->m_showSTLTCapitalGains->isChecked());
     d->m_currentState.setSettlementPeriod(d->m_tabCapitalGain->ui->m_settlementPeriod->value());
     d->m_currentState.setShowingColumnTotals(!d->m_tabCapitalGain->ui->m_checkHideTotals->isChecked());
     d->m_currentState.setInvestmentSum(static_cast<MyMoneyReport::EInvestmentSum>(d->m_tabCapitalGain->ui->m_investmentSum->currentData().toInt()));
   }
 
   if (d->m_tabPerformance) {
     d->m_currentState.setShowingColumnTotals(!d->m_tabPerformance->ui->m_checkHideTotals->isChecked());
     d->m_currentState.setInvestmentSum(static_cast<MyMoneyReport::EInvestmentSum>(d->m_tabPerformance->ui->m_investmentSum->currentData().toInt()));
   }
 
   done(true);
 }
 
 void KReportConfigurationFilterDlg::slotRowTypeChanged(int row)
 {
   Q_D(KReportConfigurationFilterDlg);
   d->m_tabRowColPivot->ui->m_checkTotalColumn->setEnabled(row == 0);
 }
 
 void KReportConfigurationFilterDlg::slotColumnTypeChanged(int row)
 {
   Q_D(KReportConfigurationFilterDlg);
   if ((d->m_tabRowColPivot->ui->m_comboBudget->isEnabled() && row < 2)) {
     d->m_tabRange->ui->m_comboColumns->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
   }
 }
 
 void KReportConfigurationFilterDlg::slotUpdateColumnsCombo()
 {
   Q_D(KReportConfigurationFilterDlg);
   const int monthlyIndex = 2;
   const int incomeExpenseIndex = 0;
   const bool isIncomeExpenseForecast = d->m_currentState.isIncludingForecast() && d->m_tabRowColPivot->ui->m_comboRows->currentIndex() == incomeExpenseIndex;
   if (isIncomeExpenseForecast && d->m_tabRange->ui->m_comboColumns->currentIndex() != monthlyIndex) {
     d->m_tabRange->ui->m_comboColumns->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
   }
 }
 
 void KReportConfigurationFilterDlg::slotUpdateColumnsCombo(int)
 {
   slotUpdateColumnsCombo();
 }
 
 void KReportConfigurationFilterDlg::slotLogAxisChanged(int state)
 {
   Q_D(KReportConfigurationFilterDlg);
   if (state == Qt::Checked)
     d->m_tabRange->setRangeLogarythmic(true);
   else
     d->m_tabRange->setRangeLogarythmic(false);
 }
 
 void KReportConfigurationFilterDlg::slotReset()
 {
   Q_D(KReportConfigurationFilterDlg);
   //
   // Set up the widget from the initial filter
   //
   d->m_currentState = d->m_initialState;
 
   //
   // Report Properties
   //
 
   d->m_tabGeneral->ui->m_editName->setText(d->m_initialState.name());
   d->m_tabGeneral->ui->m_editComment->setText(d->m_initialState.comment());
   d->m_tabGeneral->ui->m_checkCurrency->setChecked(d->m_initialState.isConvertCurrency());
   d->m_tabGeneral->ui->m_checkFavorite->setChecked(d->m_initialState.isFavorite());
 
   if (d->m_initialState.isIncludingPrice() || d->m_initialState.isSkippingZero()) {
     d->m_tabGeneral->ui->m_skipZero->setChecked(d->m_initialState.isSkippingZero());
   } else {
     d->m_tabGeneral->ui->m_skipZero->setEnabled(false);
   }
 
   if (d->m_tabRowColPivot) {
     KComboBox *combo = d->m_tabRowColPivot->ui->m_comboDetail;
     switch (d->m_initialState.detailLevel()) {
       case MyMoneyReport::eDetailNone:
       case MyMoneyReport::eDetailEnd:
       case MyMoneyReport::eDetailAll:
         combo->setCurrentItem(i18nc("All accounts", "All"), false);
         break;
       case MyMoneyReport::eDetailTop:
         combo->setCurrentItem(i18n("Top-Level"), false);
         break;
       case MyMoneyReport::eDetailGroup:
         combo->setCurrentItem(i18n("Groups"), false);
         break;
       case MyMoneyReport::eDetailTotal:
         combo->setCurrentItem(i18n("Totals"), false);
         break;
     }
 
     combo = d->m_tabRowColPivot->ui->m_comboRows;
     switch (d->m_initialState.rowType()) {
       case MyMoneyReport::eExpenseIncome:
       case MyMoneyReport::eBudget:
       case MyMoneyReport::eBudgetActual:
         combo->setCurrentItem(i18n("Income & Expenses"), false); // income / expense
         break;
       default:
         combo->setCurrentItem(i18n("Assets & Liabilities"), false); // asset / liability
         break;
     }
     d->m_tabRowColPivot->ui->m_checkTotalColumn->setChecked(d->m_initialState.isShowingRowTotals());
     d->m_tabRowColPivot->ui->m_checkTotalRow->setChecked(d->m_initialState.isShowingColumnTotals());
 
     slotRowTypeChanged(combo->currentIndex());
 
     //load budgets combo
     if (d->m_initialState.rowType() == MyMoneyReport::eBudget
         || d->m_initialState.rowType() == MyMoneyReport::eBudgetActual) {
       d->m_tabRowColPivot->ui->m_comboRows->setEnabled(false);
       d->m_tabRowColPivot->ui->m_budgetFrame->setEnabled(!d->m_budgets.empty());
       auto i = 0;
       for (QVector<MyMoneyBudget>::const_iterator it_b = d->m_budgets.constBegin(); it_b != d->m_budgets.constEnd(); ++it_b) {
         d->m_tabRowColPivot->ui->m_comboBudget->insertItem((*it_b).name(), i);
         //set the current selected item
         if ((d->m_initialState.budget() == "Any" && (*it_b).budgetStart().year() == QDate::currentDate().year())
             || d->m_initialState.budget() == (*it_b).id())
           d->m_tabRowColPivot->ui->m_comboBudget->setCurrentItem(i);
         i++;
       }
     }
 
     //set moving average days spinbox
     QSpinBox *spinbox = d->m_tabRowColPivot->ui->m_movingAverageDays;
     spinbox->setEnabled(d->m_initialState.isIncludingMovingAverage());
     if (d->m_initialState.isIncludingMovingAverage()) {
       spinbox->setValue(d->m_initialState.movingAverageDays());
     }
 
     d->m_tabRowColPivot->ui->m_checkScheduled->setChecked(d->m_initialState.isIncludingSchedules());
     d->m_tabRowColPivot->ui->m_checkTransfers->setChecked(d->m_initialState.isIncludingTransfers());
     d->m_tabRowColPivot->ui->m_checkUnused->setChecked(d->m_initialState.isIncludingUnusedAccounts());
   } else if (d->m_tabRowColQuery) {
     KComboBox *combo = d->m_tabRowColQuery->ui->m_comboOrganizeBy;
     switch (d->m_initialState.rowType()) {
       case MyMoneyReport::eNoRows:
       case MyMoneyReport::eCategory:
         combo->setCurrentItem(i18n("Categories"), false);
         break;
       case MyMoneyReport::eTopCategory:
         combo->setCurrentItem(i18n("Top Categories"), false);
         break;
       case MyMoneyReport::eTag:
         combo->setCurrentItem(i18n("Tags"), false);
         break;
       case MyMoneyReport::ePayee:
         combo->setCurrentItem(i18n("Payees"), false);
         break;
       case MyMoneyReport::eAccount:
         combo->setCurrentItem(i18n("Accounts"), false);
         break;
       case MyMoneyReport::eTopAccount:
         combo->setCurrentItem(i18n("Top Accounts"), false);
         break;
       case MyMoneyReport::eMonth:
         combo->setCurrentItem(i18n("Month"), false);
         break;
       case MyMoneyReport::eWeek:
         combo->setCurrentItem(i18n("Week"), false);
         break;
       default:
-        throw MYMONEYEXCEPTION("KReportConfigurationFilterDlg::slotReset(): QueryTable report has invalid rowtype");
+        throw MYMONEYEXCEPTION_CSTRING("KReportConfigurationFilterDlg::slotReset(): QueryTable report has invalid rowtype");
     }
 
     unsigned qc = d->m_initialState.queryColumns();
     d->m_tabRowColQuery->ui->m_checkNumber->setChecked(qc & MyMoneyReport::eQCnumber);
     d->m_tabRowColQuery->ui->m_checkPayee->setChecked(qc & MyMoneyReport::eQCpayee);
     d->m_tabRowColQuery->ui->m_checkTag->setChecked(qc & MyMoneyReport::eQCtag);
     d->m_tabRowColQuery->ui->m_checkCategory->setChecked(qc & MyMoneyReport::eQCcategory);
     d->m_tabRowColQuery->ui->m_checkMemo->setChecked(qc & MyMoneyReport::eQCmemo);
     d->m_tabRowColQuery->ui->m_checkAccount->setChecked(qc & MyMoneyReport::eQCaccount);
     d->m_tabRowColQuery->ui->m_checkReconciled->setChecked(qc & MyMoneyReport::eQCreconciled);
     d->m_tabRowColQuery->ui->m_checkAction->setChecked(qc & MyMoneyReport::eQCaction);
     d->m_tabRowColQuery->ui->m_checkShares->setChecked(qc & MyMoneyReport::eQCshares);
     d->m_tabRowColQuery->ui->m_checkPrice->setChecked(qc & MyMoneyReport::eQCprice);
     d->m_tabRowColQuery->ui->m_checkBalance->setChecked(qc & MyMoneyReport::eQCbalance);
 
     d->m_tabRowColQuery->ui->m_checkTax->setChecked(d->m_initialState.isTax());
     d->m_tabRowColQuery->ui->m_checkInvestments->setChecked(d->m_initialState.isInvestmentsOnly());
     d->m_tabRowColQuery->ui->m_checkLoans->setChecked(d->m_initialState.isLoansOnly());
 
     d->m_tabRowColQuery->ui->m_checkHideTransactions->setChecked(d->m_initialState.isHideTransactions());
     d->m_tabRowColQuery->ui->m_checkHideTotals->setChecked(!d->m_initialState.isShowingColumnTotals());
     d->m_tabRowColQuery->ui->m_checkHideSplitDetails->setEnabled(!d->m_initialState.isHideTransactions());
 
     d->m_tabRowColQuery->ui->m_checkHideSplitDetails->setChecked
     (d->m_initialState.detailLevel() == MyMoneyReport::eDetailNone || d->m_initialState.isHideTransactions());
   }
 
   if (d->m_tabChart) {
     KMyMoneyGeneralCombo* combo = d->m_tabChart->ui->m_comboType;
     switch (d->m_initialState.chartType()) {
       case MyMoneyReport::eChartNone:
         combo->setCurrentItem(MyMoneyReport::eChartLine);
         break;
       case MyMoneyReport::eChartLine:
       case MyMoneyReport::eChartBar:
       case MyMoneyReport::eChartStackedBar:
       case MyMoneyReport::eChartPie:
       case MyMoneyReport::eChartRing:
         combo->setCurrentItem(d->m_initialState.chartType());
         break;
       default:
-        throw MYMONEYEXCEPTION("KReportConfigurationFilterDlg::slotReset(): Report has invalid charttype");
+        throw MYMONEYEXCEPTION_CSTRING("KReportConfigurationFilterDlg::slotReset(): Report has invalid charttype");
     }
     d->m_tabChart->ui->m_checkCHGridLines->setChecked(d->m_initialState.isChartCHGridLines());
     d->m_tabChart->ui->m_checkSVGridLines->setChecked(d->m_initialState.isChartSVGridLines());
     d->m_tabChart->ui->m_checkValues->setChecked(d->m_initialState.isChartDataLabels());
     d->m_tabChart->ui->m_checkShowChart->setChecked(d->m_initialState.isChartByDefault());
     d->m_tabChart->ui->m_lineWidth->setValue(d->m_initialState.chartLineWidth());
     d->m_tabChart->ui->m_logYaxis->setChecked(d->m_initialState.isLogYAxis());
   }
 
   if (d->m_tabRange) {
     d->m_tabRange->ui->m_dataRangeStart->setText(d->m_initialState.dataRangeStart());
     d->m_tabRange->ui->m_dataRangeEnd->setText(d->m_initialState.dataRangeEnd());
     d->m_tabRange->ui->m_dataMajorTick->setText(d->m_initialState.dataMajorTick());
     d->m_tabRange->ui->m_dataMinorTick->setText(d->m_initialState.dataMinorTick());
     d->m_tabRange->ui->m_yLabelsPrecision->setValue(d->m_initialState.yLabelsPrecision());
     d->m_tabRange->ui->m_dataLock->setCurrentIndex((int)d->m_initialState.dataFilter());
 
     KComboBox *combo = d->m_tabRange->ui->m_comboColumns;
     if (d->m_initialState.isColumnsAreDays()) {
       switch (d->m_initialState.columnType()) {
         case MyMoneyReport::eNoColumns:
         case MyMoneyReport::eDays:
           combo->setCurrentItem(i18nc("@item the columns will display daily data", "Daily"), false);
           break;
         case MyMoneyReport::eWeeks:
           combo->setCurrentItem(i18nc("@item the columns will display weekly data", "Weekly"), false);
           break;
         default:
           break;
       }
     } else {
       switch (d->m_initialState.columnType()) {
         case MyMoneyReport::eNoColumns:
         case MyMoneyReport::eMonths:
           combo->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
           break;
         case MyMoneyReport::eBiMonths:
           combo->setCurrentItem(i18nc("@item the columns will display bi-monthly data", "Bi-Monthly"), false);
           break;
         case MyMoneyReport::eQuarters:
           combo->setCurrentItem(i18nc("@item the columns will display quarterly data", "Quarterly"), false);
           break;
         case MyMoneyReport::eYears:
           combo->setCurrentItem(i18nc("@item the columns will display yearly data", "Yearly"), false);
           break;
         default:
           break;
       }
     }
   }
 
   if (d->m_tabCapitalGain) {
     d->m_tabCapitalGain->ui->m_termSeparator->setDate(d->m_initialState.termSeparator());
     d->m_tabCapitalGain->ui->m_showSTLTCapitalGains->setChecked(d->m_initialState.isShowingSTLTCapitalGains());
     d->m_tabCapitalGain->ui->m_settlementPeriod->setValue(d->m_initialState.settlementPeriod());
     d->m_tabCapitalGain->ui->m_checkHideTotals->setChecked(!d->m_initialState.isShowingColumnTotals());
     d->m_tabCapitalGain->ui->m_investmentSum->blockSignals(true);
     d->m_tabCapitalGain->ui->m_investmentSum->clear();
     d->m_tabCapitalGain->ui->m_investmentSum->addItem(i18n("Only owned"), MyMoneyReport::eSumOwned);
     d->m_tabCapitalGain->ui->m_investmentSum->addItem(i18n("Only sold"), MyMoneyReport::eSumSold);
     d->m_tabCapitalGain->ui->m_investmentSum->blockSignals(false);
     d->m_tabCapitalGain->ui->m_investmentSum->setCurrentIndex(d->m_tabCapitalGain->ui->m_investmentSum->findData(d->m_initialState.investmentSum()));
   }
 
   if (d->m_tabPerformance) {
     d->m_tabPerformance->ui->m_checkHideTotals->setChecked(!d->m_initialState.isShowingColumnTotals());
     d->m_tabPerformance->ui->m_investmentSum->blockSignals(true);
     d->m_tabPerformance->ui->m_investmentSum->clear();
     d->m_tabPerformance->ui->m_investmentSum->addItem(i18n("From period"), MyMoneyReport::eSumPeriod);
     d->m_tabPerformance->ui->m_investmentSum->addItem(i18n("Owned and sold"), MyMoneyReport::eSumOwnedAndSold);
     d->m_tabPerformance->ui->m_investmentSum->addItem(i18n("Only owned"), MyMoneyReport::eSumOwned);
     d->m_tabPerformance->ui->m_investmentSum->addItem(i18n("Only sold"), MyMoneyReport::eSumSold);
     d->m_tabPerformance->ui->m_investmentSum->blockSignals(false);
     d->m_tabPerformance->ui->m_investmentSum->setCurrentIndex(d->m_tabPerformance->ui->m_investmentSum->findData(d->m_initialState.investmentSum()));
   }
 
   d->m_tabFilters->resetFilter(d->m_initialState);
 
   if (d->m_dateRange) {
     d->m_initialState.updateDateFilter();
     QDate dateFrom, dateTo;
     if (d->m_initialState.dateFilter(dateFrom, dateTo)) {
       if (d->m_initialState.isDateUserDefined()) {
         d->m_dateRange->setDateRange(dateFrom, dateTo);
       } else {
         d->m_dateRange->setDateRange(d->m_initialState.dateRange());
       }
     } else {
       d->m_dateRange->setDateRange(eMyMoney::TransactionFilter::Date::All);
     }
   }
 }
 
 void KReportConfigurationFilterDlg::slotShowHelp()
 {
   Q_D(KReportConfigurationFilterDlg);
   if (d->ui->m_tabWidget->currentIndex() == 1)
     d->m_tabFilters->slotShowHelp();
   else
     KHelpClient::invokeHelp("details.reports.config");
 }
 
 //TODO Fix the reports and engine to include transfers even if categories are filtered - bug #1523508
 void KReportConfigurationFilterDlg::slotUpdateCheckTransfers()
 {
   Q_D(KReportConfigurationFilterDlg);
   auto cb = d->m_tabRowColPivot->ui->m_checkTransfers;
   if (!d->m_tabFilters->categoriesView()->allItemsSelected()) {
     cb->setChecked(false);
     cb->setDisabled(true);
   } else {
     cb->setEnabled(true);
   }
 }
diff --git a/kmymoney/plugins/views/reports/kreportsview.cpp b/kmymoney/plugins/views/reports/kreportsview.cpp
index 4c23f3360..27d71a7ee 100644
--- a/kmymoney/plugins/views/reports/kreportsview.cpp
+++ b/kmymoney/plugins/views/reports/kreportsview.cpp
@@ -1,710 +1,710 @@
 /***************************************************************************
                           kreportsview.cpp  -  description
                              -------------------
     begin                : Sat Mar 27 2004
     copyright            : (C) 2000-2004 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 <ace.j@hotpop.com>
                            (C) 2017 Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kreportsview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTreeWidget>
 #include <QTreeWidgetItem>
 #include <QFile>
 #include <QTimer>
 #include <QClipboard>
 #include <QList>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QIcon>
 #include <QUrlQuery>
 #include <QFileInfo>
 #include <QFileDialog>
 #include <QLocale>
 #include <QTextCodec>
 #include <QPrintDialog>
 #include <QMenu>
 #ifdef ENABLE_WEBENGINE
 #include <QWebEngineView>
 #else
 #include <KWebView>
 #endif
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KRecentDirs>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_reportcontrol.h"
 
 #include "mymoneyfile.h"
 #include "mymoneyreport.h"
 #include "mymoneyexception.h"
 #include "kmymoneysettings.h"
 #include "querytable.h"
 #include "objectinfotable.h"
 #include "kreportconfigurationfilterdlg.h"
 #include "icons/icons.h"
 #include <kmymoneywebpage.h>
 #include "tocitem.h"
 #include "tocitemgroup.h"
 #include "tocitemreport.h"
 #include "kreportchartview.h"
 #include "pivottable.h"
 #include "reporttable.h"
 #include "reportcontrolimpl.h"
 #include "mymoneyenums.h"
 #include "menuenums.h"
 
 using namespace reports;
 using namespace eMyMoney;
 using namespace Icons;
 
 #define VIEW_LEDGER         "ledger"
 #define VIEW_SCHEDULE       "schedule"
 #define VIEW_WELCOME        "welcome"
 #define VIEW_HOME           "home"
 #define VIEW_REPORTS        "reports"
 
 /**
   * KReportsView Implementation
   */
 
 KReportsView::KReportsView(QWidget *parent) :
   KMyMoneyViewBase(*new KReportsViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::ReportAccountTransactions], &QAction::triggered, this, &KReportsView::slotReportAccountTransactions);
 }
 
 KReportsView::~KReportsView()
 {
 }
 
 void KReportsView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KReportsView);
         QTimer::singleShot(0, d->m_tocTreeWidget, SLOT(setFocus()));
       }
       break;
 
     case eView::Action::Print:
       slotPrintView();
       break;
 
     case eView::Action::CleanupBeforeFileClose:
       slotCloseAll();
       break;
 
     default:
       break;
   }
 }
 
 void KReportsView::refresh()
 {
   Q_D(KReportsView);
   if (isVisible()) {
     d->loadView();
     d->m_needsRefresh = false;
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KReportsView::showEvent(QShowEvent * event)
 {
   Q_D(KReportsView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Reports, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget()))
     emit reportSelected(tab->report());
   else
     emit reportSelected(MyMoneyReport());
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KReportsView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KReportsView);
   if (typeid(obj) != typeid(MyMoneyAccount) &&
       (obj.id().isEmpty() && d->m_currentAccount.id().isEmpty())) // do not disable actions that were already disabled)))
     return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
 
   bool b;
   if (MyMoneyFile::instance()->isStandardAccount(acc.id())) {
     b = false;
   } else {
     switch (acc.accountType()) {
       case eMyMoney::Account::Type::Asset:
       case eMyMoney::Account::Type::Liability:
       case eMyMoney::Account::Type::Equity:
       case eMyMoney::Account::Type::Checkings:
         b = true;
         break;
       default:
         b = false;
         break;
     }
   }
   pActions[eMenu::Action::ReportAccountTransactions]->setEnabled(b);
 
   d->m_currentAccount = acc;
 }
 
 void KReportsView::slotOpenUrl(const QUrl &url)
 {
   QString view = url.fileName();
   if (view.isEmpty())
     return;
   QString command = QUrlQuery(url).queryItemValue("command");
   QString id = QUrlQuery(url).queryItemValue("id");
   QString tid = QUrlQuery(url).queryItemValue("tid");
 
   if (view == VIEW_REPORTS) {
 
     if (command.isEmpty()) {
       // slotRefreshView();
     } else if (command == QLatin1String("print"))
       slotPrintView();
     else if (command == QLatin1String("copy"))
       slotCopyView();
     else if (command == QLatin1String("save"))
       slotSaveView();
     else if (command == QLatin1String("configure"))
       slotConfigure();
     else if (command == QLatin1String("duplicate"))
       slotDuplicate();
     else if (command == QLatin1String("close"))
       slotCloseCurrent();
     else if (command == QLatin1String("delete"))
       slotDelete();
     else
       qWarning() << i18n("Unknown command '%1' in KReportsView::slotOpenUrl()", qPrintable(command));
 
   } else if (view == VIEW_LEDGER) {
     emit selectByVariant(QVariantList {QVariant(id), QVariant(tid)}, eView::Intent::ShowTransaction);
   } else {
     qWarning() << i18n("Unknown view '%1' in KReportsView::slotOpenUrl()", qPrintable(view));
   }
 }
 
 void KReportsView::slotPrintView()
 {
   Q_D(KReportsView);
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget()))
     tab->print();
 }
 
 void KReportsView::slotCopyView()
 {
   Q_D(KReportsView);
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget()))
     tab->copyToClipboard();
 }
 
 void KReportsView::slotSaveView()
 {
   Q_D(KReportsView);
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget())) {
     QString filterList = i18nc("CSV (Filefilter)", "CSV files") + QLatin1String(" (*.csv);;") + i18nc("HTML (Filefilter)", "HTML files") + QLatin1String(" (*.html)");
     QUrl newURL = QFileDialog::getSaveFileUrl(this, i18n("Export as"), QUrl::fromLocalFile(KRecentDirs::dir(":kmymoney-export")), filterList, &d->m_selectedExportFilter);
     if (!newURL.isEmpty()) {
       KRecentDirs::add(":kmymoney-export", newURL.adjusted(QUrl::RemoveFilename | QUrl::StripTrailingSlash).path());
       QString newName = newURL.toDisplayString(QUrl::PreferLocalFile);
 
       try {
         tab->saveAs(newName, true);
       } catch (const MyMoneyException &e) {
-        KMessageBox::error(this, i18n("Failed to save: %1", e.what()));
+        KMessageBox::error(this, i18n("Failed to save: %1", QString::fromLatin1(e.what())));
       }
     }
   }
 }
 
 void KReportsView::slotConfigure()
 {
   Q_D(KReportsView);
   QString cm = "KReportsView::slotConfigure";
 
   auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget());
 
   if (!tab) // nothing to do
     return;
   int tabNr = d->m_reportTabWidget->currentIndex();
 
   tab->updateDataRange(); // range will be needed during configuration, but cannot be obtained earlier
 
   MyMoneyReport report = tab->report();
   if (report.comment() == i18n("Default Report") || report.comment() == i18n("Generated Report")) {
     report.setComment(i18n("Custom Report"));
     report.setName(i18n("%1 (Customized)", report.name()));
   }
 
   QPointer<KReportConfigurationFilterDlg> dlg = new KReportConfigurationFilterDlg(report);
 
   if (dlg->exec()) {
     MyMoneyReport newreport = dlg->getConfig();
 
     // If this report has an ID, then MODIFY it, otherwise ADD it
     MyMoneyFileTransaction ft;
     try {
       if (! newreport.id().isEmpty()) {
         MyMoneyFile::instance()->modifyReport(newreport);
         ft.commit();
         tab->modifyReport(newreport);
 
         d->m_reportTabWidget->setTabText(tabNr, newreport.name());
         d->m_reportTabWidget->setCurrentIndex(tabNr) ;
       } else {
         MyMoneyFile::instance()->addReport(newreport);
         ft.commit();
 
         QString reportGroupName = newreport.group();
 
         // find report group
         TocItemGroup* tocItemGroup = d->m_allTocItemGroups[reportGroupName];
         if (!tocItemGroup) {
           QString error = i18n("Could not find reportgroup \"%1\" for report \"%2\".\nPlease report this error to the developer's list: kmymoney-devel@kde.org", reportGroupName, newreport.name());
 
           // write to messagehandler
           qWarning() << cm << error;
 
           // also inform user
           KMessageBox::error(d->m_reportTabWidget, error, i18n("Critical Error"));
 
           // cleanup
           delete dlg;
 
           return;
         }
 
         // do not add TocItemReport to TocItemGroup here,
         // this is done in loadView
 
         d->addReportTab(newreport);
       }
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(this, i18n("Failed to configure report: %1", e.what()));
+      KMessageBox::error(this, i18n("Failed to configure report: %1", QString::fromLatin1(e.what())));
     }
   }
   delete dlg;
 }
 
 void KReportsView::slotDuplicate()
 {
   Q_D(KReportsView);
   QString cm = "KReportsView::slotDuplicate";
 
   auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget());
 
   if (!tab) {
     // nothing to do
     return;
   }
 
   MyMoneyReport dupe = tab->report();
   dupe.setName(i18n("Copy of %1", dupe.name()));
   if (dupe.comment() == i18n("Default Report"))
     dupe.setComment(i18n("Custom Report"));
   dupe.clearId();
 
   QPointer<KReportConfigurationFilterDlg> dlg = new KReportConfigurationFilterDlg(dupe);
   if (dlg->exec()) {
     MyMoneyReport newReport = dlg->getConfig();
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->addReport(newReport);
       ft.commit();
 
       QString reportGroupName = newReport.group();
 
       // find report group
       TocItemGroup* tocItemGroup = d->m_allTocItemGroups[reportGroupName];
       if (!tocItemGroup) {
         QString error = i18n("Could not find reportgroup \"%1\" for report \"%2\".\nPlease report this error to the developer's list: kmymoney-devel@kde.org", reportGroupName, newReport.name());
 
         // write to messagehandler
         qWarning() << cm << error;
 
         // also inform user
         KMessageBox::error(d->m_reportTabWidget, error, i18n("Critical Error"));
 
         // cleanup
         delete dlg;
 
         return;
       }
 
       // do not add TocItemReport to TocItemGroup here,
       // this is done in loadView
 
       d->addReportTab(newReport);
     } catch (const MyMoneyException &e) {
       QString error = i18n("Cannot add report, reason: \"%1\"", e.what());
 
       // write to messagehandler
       qWarning() << cm << error;
 
       // also inform user
       KMessageBox::error(d->m_reportTabWidget, error, i18n("Critical Error"));
     }
   }
   delete dlg;
 }
 
 void KReportsView::slotDelete()
 {
   Q_D(KReportsView);
   auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget());
   if (!tab) {
     // nothing to do
     return;
   }
 
   MyMoneyReport report = tab->report();
   if (! report.id().isEmpty()) {
     if (KMessageBox::Continue == d->deleteReportDialog(report.name())) {
       // close the tab and then remove the report so that it is not
       // generated again during the following loadView() call
       slotClose(d->m_reportTabWidget->currentIndex());
 
       MyMoneyFileTransaction ft;
       MyMoneyFile::instance()->removeReport(report);
       ft.commit();
     }
   } else {
     KMessageBox::information(this,
                              QString("<qt>") +
                              i18n("<b>%1</b> is a default report, so it cannot be deleted.",
                                   report.name()) + QString("</qt>"), i18n("Delete Report?"));
   }
 }
 
 void KReportsView::slotOpenReport(const QString& id)
 {
   Q_D(KReportsView);
   if (id.isEmpty()) {
     // nothing to  do
     return;
   }
 
   KReportTab* page = 0;
 
   // Find the tab which contains the report
   int index = 1;
   while (index < d->m_reportTabWidget->count()) {
     auto current = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(index));
 
     if (current && current->report().id() == id) {
       page = current;
       break;
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     d->m_reportTabWidget->setCurrentIndex(index);
   else
     d->addReportTab(MyMoneyFile::instance()->report(id));
 }
 
 void KReportsView::slotOpenReport(const MyMoneyReport& report)
 {
   Q_D(KReportsView);
   if (d->m_needLoad)
     d->init();
   qDebug() << Q_FUNC_INFO << " " << report.name();
   KReportTab* page = 0;
 
   // Find the tab which contains the report indicated by this list item
   int index = 1;
   while (index < d->m_reportTabWidget->count()) {
     auto current = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(index));
 
     if (current && current->report().name() == report.name()) {
       page = current;
       break;
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     d->m_reportTabWidget->setCurrentIndex(index);
   else
     d->addReportTab(report);
 
   if (!isVisible())
     emit switchViewRequested(View::Reports);
 }
 
 void KReportsView::slotItemDoubleClicked(QTreeWidgetItem* item, int)
 {
   Q_D(KReportsView);
   auto tocItem = dynamic_cast<TocItem*>(item);
   if (tocItem && !tocItem->isReport()) {
     // toggle the expanded-state for reportgroup-items
     item->setExpanded(item->isExpanded() ? false : true);
 
     // nothing else to do for reportgroup-items
     return;
   }
 
   TocItemReport* reportTocItem = dynamic_cast<TocItemReport*>(tocItem);
 
   MyMoneyReport& report = reportTocItem->getReport();
 
   KReportTab* page = 0;
 
   // Find the tab which contains the report indicated by this list item
   int index = 1;
   while (index < d->m_reportTabWidget->count()) {
     auto current = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(index));
     if (current) {
       // If this report has an ID, we'll use the ID to match
       if (! report.id().isEmpty()) {
         if (current->report().id() == report.id()) {
           page = current;
           break;
         }
       }
       // Otherwise, use the name to match.  THIS ASSUMES that no 2 default reports
       // have the same name...but that would be pretty a boneheaded thing to do.
       else {
         if (current->report().name() == report.name()) {
           page = current;
           break;
         }
       }
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     d->m_reportTabWidget->setCurrentIndex(index);
   else
     d->addReportTab(report);
 }
 
 void KReportsView::slotToggleChart()
 {
   Q_D(KReportsView);
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->currentWidget()))
     tab->toggleChart();
 }
 
 void KReportsView::slotCloseCurrent()
 {
   Q_D(KReportsView);
   slotClose(d->m_reportTabWidget->currentIndex());
 }
 
 void KReportsView::slotClose(int index)
 {
   Q_D(KReportsView);
   if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(index))) {
     d->m_reportTabWidget->removeTab(index);
     tab->setReadyToDelete(true);
   }
 }
 
 void KReportsView::slotCloseAll()
 {
   Q_D(KReportsView);
   if(!d->m_needLoad) {
     while (true) {
       if (auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(1))) {
         d->m_reportTabWidget->removeTab(1);
         tab->setReadyToDelete(true);
       } else
         break;
     }
   }
 }
 
 
 void KReportsView::slotListContextMenu(const QPoint & p)
 {
   Q_D(KReportsView);
   QTreeWidgetItem *item = d->m_tocTreeWidget->itemAt(p);
 
   if (!item) {
     return;
   }
 
   auto tocItem = dynamic_cast<TocItem*>(item);
 
   if (tocItem && !tocItem->isReport()) {
     // currently there is no context menu for reportgroup items
     return;
   }
 
   QMenu* contextmenu = new QMenu(this);
 
   contextmenu->addAction(i18nc("To open a new report", "&Open"),
                          this, SLOT(slotOpenFromList()));
 
   contextmenu->addAction(i18nc("Configure a report", "&Configure"),
                          this, SLOT(slotConfigureFromList()));
 
   contextmenu->addAction(i18n("&New report"),
                          this, SLOT(slotNewFromList()));
 
   // Only add this option if it's a custom report. Default reports cannot be deleted
   auto reportTocItem = dynamic_cast<TocItemReport*>(tocItem);
 
   if (reportTocItem) {
     MyMoneyReport& report = reportTocItem->getReport();
     if (! report.id().isEmpty()) {
       contextmenu->addAction(i18n("&Delete"),
                              this, SLOT(slotDeleteFromList()));
     }
   }
 
   contextmenu->popup(d->m_tocTreeWidget->mapToGlobal(p));
 }
 
 void KReportsView::slotOpenFromList()
 {
   Q_D(KReportsView);
   if (auto tocItem = dynamic_cast<TocItem*>(d->m_tocTreeWidget->currentItem()))
     slotItemDoubleClicked(tocItem, 0);
 }
 
 void KReportsView::slotConfigureFromList()
 {
   Q_D(KReportsView);
   if (auto tocItem = dynamic_cast<TocItem*>(d->m_tocTreeWidget->currentItem())) {
     slotItemDoubleClicked(tocItem, 0);
     slotConfigure();
   }
 }
 
 void KReportsView::slotNewFromList()
 {
   Q_D(KReportsView);
   if (auto tocItem = dynamic_cast<TocItem*>(d->m_tocTreeWidget->currentItem())) {
     slotItemDoubleClicked(tocItem, 0);
     slotDuplicate();
   }
 }
 
 void KReportsView::slotDeleteFromList()
 {
   Q_D(KReportsView);
   if (auto tocItem = dynamic_cast<TocItem*>(d->m_tocTreeWidget->currentItem())) {
     if (auto reportTocItem = dynamic_cast<TocItemReport*>(tocItem)) {
       MyMoneyReport& report = reportTocItem->getReport();
 
       // If this report does not have an ID, it's a default report and cannot be deleted
       if (! report.id().isEmpty() &&
           KMessageBox::Continue == d->deleteReportDialog(report.name())) {
         // check if report's tab is open; start from 1 because 0 is toc tab
         for (int i = 1; i < d->m_reportTabWidget->count(); ++i) {
           auto tab = dynamic_cast<KReportTab*>(d->m_reportTabWidget->widget(i));
           if (tab && tab->report().id() == report.id()) {
             slotClose(i); // if open, close it, so no crash when switching to it
             break;
           }
         }
         MyMoneyFileTransaction ft;
         MyMoneyFile::instance()->removeReport(report);
         ft.commit();
       }
     }
   }
 }
 
 void KReportsView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::OpenObject:
       slotOpenReport(static_cast<const MyMoneyReport&>(obj));
     default:
       break;
   }
 }
 
 void KReportsView::slotReportAccountTransactions()
 {
   Q_D(KReportsView);
   // Generate a transaction report that contains transactions for only the
   // currently selected account.
   if (!d->m_currentAccount.id().isEmpty()) {
     MyMoneyReport report(
       MyMoneyReport::eAccount,
       MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory,
       eMyMoney::TransactionFilter::Date::YearToDate,
       MyMoneyReport::eDetailAll,
       i18n("%1 YTD Account Transactions", d->m_currentAccount.name()),
       i18n("Generated Report")
     );
     report.setGroup(i18n("Transactions"));
     report.addAccount(d->m_currentAccount.id());
     emit customActionRequested(View::Reports, eView::Action::SwitchView);
     slotOpenReport(report);
   }
 }
 
 // Make sure, that these definitions are only used within this file
 // this does not seem to be necessary, but when building RPMs the
 // build option 'final' is used and all CPP files are concatenated.
 // So it could well be, that in another CPP file these definitions
 // are also used.
 #undef VIEW_LEDGER
 #undef VIEW_SCHEDULE
 #undef VIEW_WELCOME
 #undef VIEW_HOME
 #undef VIEW_REPORTS
diff --git a/kmymoney/reports/objectinfotable.cpp b/kmymoney/reports/objectinfotable.cpp
index 17eeccd34..8af6b7b99 100644
--- a/kmymoney/reports/objectinfotable.cpp
+++ b/kmymoney/reports/objectinfotable.cpp
@@ -1,373 +1,373 @@
 /***************************************************************************
                           objectinfotable.cpp
                          -------------------
     begin                : Sat 28 jun 2008
     copyright            : (C) 2004-2005 by Ace Jones <acejones@users.sourceforge.net>
                                2008 by Alvaro Soliverez <asoliverez@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "objectinfotable.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneymoney.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyreport.h"
 #include "mymoneyschedule.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "reportaccount.h"
 #include "mymoneyenums.h"
 
 namespace reports
 {
 
 // ****************************************************************************
 //
 // ObjectInfoTable implementation
 //
 // ****************************************************************************
 
 /**
   * TODO
   *
   * - Collapse 2- & 3- groups when they are identical
   * - Way more test cases (especially splits & transfers)
   * - Option to collapse splits
   * - Option to exclude transfers
   *
   */
 
 ObjectInfoTable::ObjectInfoTable(const MyMoneyReport& _report): ListTable(_report)
 {
   // separated into its own method to allow debugging (setting breakpoints
   // directly in ctors somehow does not work for me (ipwizard))
   // TODO: remove the init() method and move the code back to the ctor
   init();
 }
 
 void ObjectInfoTable::init()
 {
   m_columns.clear();
   m_group.clear();
   m_subtotal.clear();
   switch (m_config.rowType()) {
     case MyMoneyReport::eSchedule:
       constructScheduleTable();
       m_columns << ctNextDueDate << ctName;
       break;
     case MyMoneyReport::eAccountInfo:
       constructAccountTable();
       m_columns << ctInstitution << ctType << ctName;
       break;
     case MyMoneyReport::eAccountLoanInfo:
       constructAccountLoanTable();
       m_columns << ctInstitution << ctType << ctName;
       break;
     default:
       break;
   }
 
   // Sort the data to match the report definition
   m_subtotal << ctValue;
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eSchedule:
       m_group << ctType;
       m_subtotal << ctValue;
       break;
     case MyMoneyReport::eAccountInfo:
     case MyMoneyReport::eAccountLoanInfo:
       m_group << ctTopCategory << ctInstitution;
       m_subtotal << ctCurrentBalance;
       break;
     default:
-      throw MYMONEYEXCEPTION("ObjectInfoTable::ObjectInfoTable(): unhandled row type");
+      throw MYMONEYEXCEPTION_CSTRING("ObjectInfoTable::ObjectInfoTable(): unhandled row type");
   }
 
   QVector<cellTypeE> sort = QVector<cellTypeE>::fromList(m_group) << QVector<cellTypeE>::fromList(m_columns) << ctID << ctRank;
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eSchedule:
       if (m_config.detailLevel() == MyMoneyReport::eDetailAll) {
         m_columns << ctName << ctPayee << ctPaymentType << ctOccurrence
                   << ctNextDueDate << ctCategory;
       } else {
         m_columns << ctName << ctPayee << ctPaymentType << ctOccurrence
                   << ctNextDueDate;
       }
       break;
     case MyMoneyReport::eAccountInfo:
       m_columns << ctType << ctName << ctNumber << ctDescription
                 << ctOpeningDate << ctCurrencyName << ctBalanceWarning
                 << ctCreditWarning << ctMaxCreditLimit
                 << ctTax << ctFavorite;
       break;
     case MyMoneyReport::eAccountLoanInfo:
       m_columns << ctType << ctName << ctNumber << ctDescription
                 << ctOpeningDate << ctCurrencyName << ctPayee
                 << ctLoanAmount << ctInterestRate << ctNextInterestChange
                 << ctPeriodicPayment << ctFinalPayment << ctFavorite;
       break;
     default:
       m_columns.clear();
   }
 
   TableRow::setSortCriteria(sort);
   qSort(m_rows);
 }
 
 void ObjectInfoTable::constructScheduleTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneySchedule> schedules;
 
   schedules = file->scheduleList(QString(), eMyMoney::Schedule::Type::Any, eMyMoney::Schedule::Occurrence::Any, eMyMoney::Schedule::PaymentType::Any, m_config.fromDate(), m_config.toDate(), false);
 
   QList<MyMoneySchedule>::const_iterator it_schedule = schedules.constBegin();
   while (it_schedule != schedules.constEnd()) {
     MyMoneySchedule schedule = *it_schedule;
 
     ReportAccount account(schedule.account());
 
     if (m_config.includes(account))  {
       //get fraction for account
       int fraction = account.fraction();
 
       //use base currency fraction if not initialized
       if (fraction == -1)
         fraction = MyMoneyFile::instance()->baseCurrency().smallestAccountFraction();
 
       TableRow scheduleRow;
 
       //convert to base currency if needed
       MyMoneyMoney xr = MyMoneyMoney::ONE;
       if (m_config.isConvertCurrency() && account.isForeignCurrency()) {
         xr = account.baseCurrencyPrice(QDate::currentDate()).reduce();
       }
 
       // help for sort and render functions
       scheduleRow[ctRank] = QLatin1Char('0');
 
       //schedule data
       scheduleRow[ctID] = schedule.id();
       scheduleRow[ctName] = schedule.name();
       scheduleRow[ctNextDueDate] = schedule.nextDueDate().toString(Qt::ISODate);
       scheduleRow[ctType] = KMyMoneyUtils::scheduleTypeToString(schedule.type());
       scheduleRow[ctOccurrence] = i18nc("Frequency of schedule", schedule.occurrenceToString().toLatin1());
       scheduleRow[ctPaymentType] = KMyMoneyUtils::paymentMethodToString(schedule.paymentType());
 
       //scheduleRow["category"] = account.name();
 
       //to get the payee we must look into the splits of the transaction
       MyMoneyTransaction transaction = schedule.transaction();
       MyMoneySplit split = transaction.splitByAccount(account.id(), true);
       scheduleRow[ctValue] = (split.value() * xr).toString();
       MyMoneyPayee payee = file->payee(split.payeeId());
       scheduleRow[ctPayee] = payee.name();
       m_rows += scheduleRow;
 
       //the text matches the main split
       bool transaction_text = m_config.match(split);
 
       if (m_config.detailLevel() == MyMoneyReport::eDetailAll) {
         //get the information for all splits
         QList<MyMoneySplit> splits = transaction.splits();
         QList<MyMoneySplit>::const_iterator split_it = splits.constBegin();
         for (; split_it != splits.constEnd(); ++split_it) {
           TableRow splitRow;
           ReportAccount splitAcc((*split_it).accountId());
 
           splitRow[ctRank] = QLatin1Char('1');
           splitRow[ctID] = schedule.id();
           splitRow[ctName] = schedule.name();
           splitRow[ctType] = KMyMoneyUtils::scheduleTypeToString(schedule.type());
           splitRow[ctNextDueDate] = schedule.nextDueDate().toString(Qt::ISODate);
 
           if ((*split_it).value() == MyMoneyMoney::autoCalc) {
             splitRow[ctSplit] = MyMoneyMoney::autoCalc.toString();
           } else if (! splitAcc.isIncomeExpense()) {
             splitRow[ctSplit] = (*split_it).value().toString();
           } else {
             splitRow[ctSplit] = (- (*split_it).value()).toString();
           }
 
           //if it is an assett account, mark it as a transfer
           if (! splitAcc.isIncomeExpense()) {
             splitRow[ctCategory] = ((* split_it).value().isNegative())
                                    ? i18n("Transfer from %1" , splitAcc.fullName())
                                    : i18n("Transfer to %1" , splitAcc.fullName());
           } else {
             splitRow [ctCategory] = splitAcc.fullName();
           }
 
           //add the split only if it matches the text or it matches the main split
           if (m_config.match((*split_it))
               || transaction_text)
             m_rows += splitRow;
         }
       }
     }
     ++it_schedule;
   }
 }
 
 void ObjectInfoTable::constructAccountTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
   while (it_account != accounts.constEnd()) {
     TableRow accountRow;
     ReportAccount account(*it_account);
 
     if (m_config.includes(account)
         && account.accountType() != eMyMoney::Account::Type::Stock
         && !account.isClosed()) {
       MyMoneyMoney value;
       accountRow[ctRank] = QLatin1Char('0');
       accountRow[ctTopCategory] = MyMoneyAccount::accountTypeToString(account.accountGroup());
       accountRow[ctInstitution] = (file->institution(account.institutionId())).name();
       accountRow[ctType] = MyMoneyAccount::accountTypeToString(account.accountType());
       accountRow[ctName] = account.name();
       accountRow[ctNumber] = account.number();
       accountRow[ctDescription] = account.description();
       accountRow[ctOpeningDate] = account.openingDate().toString(Qt::ISODate);
       //accountRow["currency"] = (file->currency(account.currencyId())).tradingSymbol();
       accountRow[ctCurrencyName] = (file->currency(account.currencyId())).name();
       accountRow[ctBalanceWarning] = account.value("minBalanceEarly");
       accountRow[ctMaxBalanceLimit] = account.value("minBalanceAbsolute");
       accountRow[ctCreditWarning] = account.value("maxCreditEarly");
       accountRow[ctMaxCreditLimit] = account.value("maxCreditAbsolute");
       accountRow[ctTax] = account.value("Tax") == QLatin1String("Yes") ? i18nc("Is this a tax account?", "Yes") : QString();
       accountRow[ctOpeningBalance] = account.value("OpeningBalanceAccount") == QLatin1String("Yes") ? i18nc("Is this an opening balance account?", "Yes") : QString();
       accountRow[ctFavorite] = account.value("PreferredAccount") == QLatin1String("Yes") ? i18nc("Is this a favorite account?", "Yes") : QString();
 
       //investment accounts show the balances of all its subaccounts
       if (account.accountType() == eMyMoney::Account::Type::Investment) {
         value = investmentBalance(account);
       } else {
         value = file->balance(account.id());
       }
 
       //convert to base currency if needed
       if (m_config.isConvertCurrency() && account.isForeignCurrency()) {
         MyMoneyMoney xr = account.baseCurrencyPrice(QDate::currentDate()).reduce();
         value = value * xr;
       }
       accountRow[ctCurrentBalance] = value.toString();
 
       m_rows += accountRow;
     }
     ++it_account;
   }
 }
 
 void ObjectInfoTable::constructAccountLoanTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
   while (it_account != accounts.constEnd()) {
     TableRow accountRow;
     ReportAccount account(*it_account);
     MyMoneyAccountLoan loan = *it_account;
 
     if (m_config.includes(account) && account.isLoan() && !account.isClosed()) {
       //convert to base currency if needed
       MyMoneyMoney xr = MyMoneyMoney::ONE;
       if (m_config.isConvertCurrency() && account.isForeignCurrency()) {
         xr = account.baseCurrencyPrice(QDate::currentDate()).reduce();
       }
 
       accountRow[ctRank] = QLatin1Char('0');
       accountRow[ctTopCategory] = MyMoneyAccount::accountTypeToString(account.accountGroup());
       accountRow[ctInstitution] = (file->institution(account.institutionId())).name();
       accountRow[ctType] = MyMoneyAccount::accountTypeToString(account.accountType());
       accountRow[ctName] = account.name();
       accountRow[ctNumber] = account.number();
       accountRow[ctDescription] = account.description();
       accountRow[ctOpeningDate] = account.openingDate().toString(Qt::ISODate);
       //accountRow["currency"] = (file->currency(account.currencyId())).tradingSymbol();
       accountRow[ctCurrencyName] = (file->currency(account.currencyId())).name();
       accountRow[ctPayee] = file->payee(loan.payee()).name();
       accountRow[ctLoanAmount] = (loan.loanAmount() * xr).toString();
       accountRow[ctInterestRate] = (loan.interestRate(QDate::currentDate()) / MyMoneyMoney(100, 1) * xr).toString();
       accountRow[ctNextInterestChange] = loan.nextInterestChange().toString(Qt::ISODate);
       accountRow[ctPeriodicPayment] = (loan.periodicPayment() * xr).toString();
       accountRow[ctFinalPayment] = (loan.finalPayment() * xr).toString();
       accountRow[ctFavorite] = account.value("PreferredAccount") == QLatin1String("Yes") ? i18nc("Is this a favorite account?", "Yes") : QString();
 
       MyMoneyMoney value = file->balance(account.id());
       value = value * xr;
       accountRow[ctCurrentBalance] = value.toString();
       m_rows += accountRow;
     }
     ++it_account;
   }
 }
 
 MyMoneyMoney ObjectInfoTable::investmentBalance(const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyMoney value = file->balance(acc.id());
 
   foreach (const auto sAccount, acc.accountList()) {
     auto stock = file->account(sAccount);
     try {
       MyMoneyMoney val;
       MyMoneyMoney balance = file->balance(stock.id());
       MyMoneySecurity security = file->security(stock.currencyId());
       const MyMoneyPrice &price = file->price(stock.currencyId(), security.tradingCurrency());
       val = balance * price.rate(security.tradingCurrency());
       // adjust value of security to the currency of the account
       MyMoneySecurity accountCurrency = file->currency(acc.currencyId());
       val = val * file->price(security.tradingCurrency(), accountCurrency.id()).rate(accountCurrency.id());
       val = val.convert(acc.fraction());
       value += val;
     } catch (const MyMoneyException &e) {
       qWarning("%s", qPrintable(QString("cannot convert stock balance of %1 to base currency: %2").arg(stock.name(), e.what())));
     }
   }
   return value;
 }
 
 }
diff --git a/kmymoney/reports/pivottable.cpp b/kmymoney/reports/pivottable.cpp
index ec6af81c1..082aeb942 100644
--- a/kmymoney/reports/pivottable.cpp
+++ b/kmymoney/reports/pivottable.cpp
@@ -1,2355 +1,2355 @@
 /***************************************************************************
                           pivottable.cpp
                              -------------------
     begin                : Mon May 17 2004
     copyright            : (C) 2004-2005 by Ace Jones
     email                : <ace.j@hotpop.com>
                            Thomas Baumgart <ipwizard@users.sourceforge.net>
                            Alvaro Soliverez <asoliverez@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "pivottable.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QRegExp>
 #include <QFile>
 #include <QTextStream>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include "pivotgrid.h"
 #include "reportdebug.h"
 #include "kreportchartview.h"
 #include "kmymoneysettings.h"
 #include "kmymoneyutils.h"
 #include "mymoneyforecast.h"
 #include "mymoneyprice.h"
 #include "mymoneyfile.h"
 #include "mymoneysecurity.h"
 #include "mymoneybudget.h"
 #include "mymoneyreport.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 namespace KChart { class Widget; }
 
 namespace reports
 {
 
 using KChart::Widget;
 
 QString Debug::m_sTabs;
 bool Debug::m_sEnabled = DEBUG_ENABLED_BY_DEFAULT;
 QString Debug::m_sEnableKey;
 
 Debug::Debug(const QString& _name): m_methodName(_name), m_enabled(m_sEnabled)
 {
   if (!m_enabled && _name == m_sEnableKey)
     m_enabled = true;
 
   if (m_enabled) {
     qDebug("%s%s(): ENTER", qPrintable(m_sTabs), qPrintable(m_methodName));
     m_sTabs.append("--");
   }
 }
 
 Debug::~Debug()
 {
   if (m_enabled) {
     m_sTabs.remove(0, 2);
     qDebug("%s%s(): EXIT", qPrintable(m_sTabs), qPrintable(m_methodName));
 
     if (m_methodName == m_sEnableKey)
       m_enabled = false;
   }
 }
 
 void Debug::output(const QString& _text)
 {
   if (m_enabled)
     qDebug("%s%s(): %s", qPrintable(m_sTabs), qPrintable(m_methodName), qPrintable(_text));
 }
 
 PivotTable::PivotTable(const MyMoneyReport& _report):
     ReportTable(_report),
     m_runningSumsCalculated(false)
 {
   init();
 }
 
 void PivotTable::init()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   //
   // Initialize locals
   //
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //
   // Initialize member variables
   //
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   m_config.validDateRange(m_beginDate, m_endDate);
 
   // If we need to calculate running sums, it does not make sense
   // to show a row total column
   if (m_config.isRunningSum())
     m_config.setShowingRowTotals(false);
 
   if (m_config.isRunningSum() &&
       !m_config.isIncludingPrice() &&
       !m_config.isIncludingAveragePrice() &&
       !m_config.isIncludingMovingAverage())
     m_startColumn = 1;
   else
     m_startColumn = 0;
 
   m_numColumns = columnValue(m_endDate) - columnValue(m_beginDate) + 1 + m_startColumn; // 1 for m_beginDate values and m_startColumn for opening balance values
 
   //Load what types of row the report is going to show
   loadRowTypeList();
 
   //
   // Initialize outer groups of the grid
   //
   if (m_config.rowType() == MyMoneyReport::eAssetLiability) {
     m_grid.insert(MyMoneyAccount::accountTypeToString(eMyMoney::Account::Type::Asset), PivotOuterGroup(m_numColumns));
     m_grid.insert(MyMoneyAccount::accountTypeToString(eMyMoney::Account::Type::Liability), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder, true /* inverted */));
   } else {
     m_grid.insert(MyMoneyAccount::accountTypeToString(eMyMoney::Account::Type::Income), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder - 2));
     m_grid.insert(MyMoneyAccount::accountTypeToString(eMyMoney::Account::Type::Expense), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder - 1, true /* inverted */));
     //
     // Create rows for income/expense reports with all accounts included
     //
     if (m_config.isIncludingUnusedAccounts())
       createAccountRows();
   }
 
   //
   // Initialize grid totals
   //
 
   m_grid.m_total = PivotGridRowSet(m_numColumns);
 
   //
   // Get opening balances
   // Only net worth report qualifies
   if (m_startColumn == 1)
     calculateOpeningBalances();
 
   //
   // Calculate budget mapping
   // (for budget reports only)
   //
   if (m_config.hasBudget())
     calculateBudgetMapping();
 
   // prices report doesn't need transactions, but it needs account stub
   // otherwise fillBasePriceUnit won't do nothing
   if (m_config.isIncludingPrice() ||
       m_config.isIncludingAveragePrice()) {
     QList<MyMoneyAccount> accounts;
     file->accountList(accounts);
     foreach (const auto acc, accounts) {
       if (acc.isInvest()) {
         const ReportAccount repAcc(acc);
         if (m_config.includes(repAcc)) {
           const auto outergroup = acc.accountTypeToString(acc.accountType());
           assignCell(outergroup, repAcc, 0, MyMoneyMoney(), false, false);    // add account stub
         }
       }
     }
   } else {
     //
     // Populate all transactions into the row/column pivot grid
     //
 
     QList<MyMoneyTransaction> transactions;
     m_config.setReportAllSplits(false);
     m_config.setConsiderCategory(true);
     try {
       transactions = file->transactionList(m_config);
     } catch (const MyMoneyException &e) {
-      qDebug("ERR: %s thrown in %s(%ld)", qPrintable(e.what()), qPrintable(e.file()), e.line());
-      throw e;
+      qDebug("ERR: %s", e.what());
+      throw;
     }
     DEBUG_OUTPUT(QString("Found %1 matching transactions").arg(transactions.count()));
 
 
     // Include scheduled transactions if required
     if (m_config.isIncludingSchedules()) {
       // Create a custom version of the report filter, excluding date
       // We'll use this to compare the transaction against
       MyMoneyTransactionFilter schedulefilter(m_config);
       schedulefilter.setDateFilter(QDate(), QDate());
 
       // Get the real dates from the config filter
       QDate configbegin, configend;
       m_config.validDateRange(configbegin, configend);
 
       QList<MyMoneySchedule> schedules = file->scheduleList();
       QList<MyMoneySchedule>::const_iterator it_schedule = schedules.constBegin();
       while (it_schedule != schedules.constEnd()) {
         // If the transaction meets the filter
         MyMoneyTransaction tx = (*it_schedule).transaction();
         if (!(*it_schedule).isFinished() && schedulefilter.match(tx)) {
           // Keep the id of the schedule with the transaction so that
           // we can do the autocalc later on in case of a loan payment
           tx.setValue("kmm-schedule-id", (*it_schedule).id());
 
           // Get the dates when a payment will be made within the report window
           QDate nextpayment = (*it_schedule).adjustedNextPayment(configbegin);
           if (nextpayment.isValid()) {
             // Add one transaction for each date
             QList<QDate> paymentDates = (*it_schedule).paymentDates(nextpayment, configend);
             QList<QDate>::const_iterator it_date = paymentDates.constBegin();
             while (it_date != paymentDates.constEnd()) {
               //if the payment occurs in the past, enter it tomorrow
               if (QDate::currentDate() >= *it_date) {
                 tx.setPostDate(QDate::currentDate().addDays(1));
               } else {
                 tx.setPostDate(*it_date);
               }
               if (tx.postDate() <= configend
                   && tx.postDate() >= configbegin) {
                 transactions += tx;
               }
 
               DEBUG_OUTPUT(QString("Added transaction for schedule %1 on %2").arg((*it_schedule).id()).arg((*it_date).toString()));
 
               ++it_date;
             }
           }
         }
 
         ++it_schedule;
       }
     }
 
     // whether asset & liability transactions are actually to be considered
     // transfers
     bool al_transfers = (m_config.rowType() == MyMoneyReport::eExpenseIncome) && (m_config.isIncludingTransfers());
 
     //this is to store balance for loan accounts when not included in the report
     QMap<QString, MyMoneyMoney> loanBalances;
 
     QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin();
     int colofs = columnValue(m_beginDate) - m_startColumn;
     while (it_transaction != transactions.constEnd()) {
       MyMoneyTransaction tx = (*it_transaction);
       QDate postdate = tx.postDate();
       if (postdate < m_beginDate) {
         qDebug("MyMoneyFile::transactionList returned a transaction that is outside the date filter, skipping it");
         ++it_transaction;
         continue;
       }
       int column = columnValue(postdate) - colofs;
 
       // check if we need to call the autocalculation routine
       if (tx.isLoanPayment() && tx.hasAutoCalcSplit() && (tx.value("kmm-schedule-id").length() > 0)) {
         // make sure to consider any autocalculation for loan payments
         MyMoneySchedule sched = file->schedule(tx.value("kmm-schedule-id"));
         const MyMoneySplit& split = tx.amortizationSplit();
         if (!split.id().isEmpty()) {
           ReportAccount splitAccount(file->account(split.accountId()));
           eMyMoney::Account::Type type = splitAccount.accountGroup();
           QString outergroup = MyMoneyAccount::accountTypeToString(type);
 
           //if the account is included in the report, calculate the balance from the cells
           if (m_config.includes(splitAccount)) {
             loanBalances[splitAccount.id()] = cellBalance(outergroup, splitAccount, column, false);
           } else {
             //if it is not in the report and also not in loanBalances, get the balance from the file
             if (!loanBalances.contains(splitAccount.id())) {
               QDate dueDate = sched.nextDueDate();
 
               //if the payment is overdue, use current date
               if (dueDate < QDate::currentDate())
                 dueDate = QDate::currentDate();
 
               //get the balance from the file for the date
               loanBalances[splitAccount.id()] = file->balance(splitAccount.id(), dueDate.addDays(-1));
             }
           }
 
           KMyMoneyUtils::calculateAutoLoan(sched, tx, loanBalances);
 
           //if the loan split is not included in the report, update the balance for the next occurrence
           if (!m_config.includes(splitAccount)) {
             foreach (const auto txsplit, tx.splits()) {
               if (txsplit.isAmortizationSplit() && txsplit.accountId() == splitAccount.id())
                 loanBalances[splitAccount.id()] = loanBalances[splitAccount.id()] + txsplit.shares();
             }
           }
         }
       }
 
       QList<MyMoneySplit> splits = tx.splits();
       QList<MyMoneySplit>::const_iterator it_split = splits.constBegin();
       while (it_split != splits.constEnd()) {
         ReportAccount splitAccount((*it_split).accountId());
 
         // Each split must be further filtered, because if even one split matches,
         // the ENTIRE transaction is returned with all splits (even non-matching ones)
         if (m_config.includes(splitAccount) && m_config.match((*it_split))) {
           // reverse sign to match common notation for cash flow direction, only for expense/income splits
           MyMoneyMoney reverse(splitAccount.isIncomeExpense() ? -1 : 1, 1);
 
           MyMoneyMoney value;
           // the outer group is the account class (major account type)
           eMyMoney::Account::Type type = splitAccount.accountGroup();
           QString outergroup = MyMoneyAccount::accountTypeToString(type);
 
           value = (*it_split).shares();
           bool stockSplit = tx.isStockSplit();
           if (!stockSplit) {
             // retrieve the value in the account's underlying currency
             if (value != MyMoneyMoney::autoCalc) {
               value = value * reverse;
             } else {
               qDebug("PivotTable::PivotTable(): This must not happen");
               value = MyMoneyMoney();  // keep it 0 so far
             }
 
             // Except in the case of transfers on an income/expense report
             if (al_transfers && (type == eMyMoney::Account::Type::Asset || type == eMyMoney::Account::Type::Liability)) {
               outergroup = i18n("Transfers");
               value = -value;
             }
           }
           // add the value to its correct position in the pivot table
           assignCell(outergroup, splitAccount, column, value, false, stockSplit);
         }
         ++it_split;
       }
 
       ++it_transaction;
     }
   }
   //
   // Get forecast data
   //
   if (m_config.isIncludingForecast())
     calculateForecast();
 
   //
   //Insert Price data
   //
   if (m_config.isIncludingPrice())
     fillBasePriceUnit(ePrice);
 
   //
   //Insert Average Price data
   //
   if (m_config.isIncludingAveragePrice()) {
     fillBasePriceUnit(eActual);
     calculateMovingAverage();
   }
 
   //
   // Collapse columns to match column type
   //
 
 
   if (m_config.columnPitch() > 1)
     collapseColumns();
 
   //
   // Calculate the running sums
   // (for running sum reports only)
   //
 
   if (m_config.isRunningSum())
     calculateRunningSums();
 
   //
   // Calculate Moving Average
   //
   if (m_config.isIncludingMovingAverage())
     calculateMovingAverage();
 
   //
   // Calculate Budget Difference
   //
 
   if (m_config.isIncludingBudgetActuals())
     calculateBudgetDiff();
 
   //
   // Convert all values to the deep currency
   //
 
   convertToDeepCurrency();
 
   //
   // Convert all values to the base currency
   //
 
   if (m_config.isConvertCurrency())
     convertToBaseCurrency();
 
   //
   // Determine column headings
   //
 
   calculateColumnHeadings();
 
   //
   // Calculate row and column totals
   //
 
   calculateTotals();
 
   //
   // If using mixed time, calculate column for current date
   //
   m_config.setCurrentDateColumn(currentDateColumn());
 }
 
 void PivotTable::collapseColumns()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   int columnpitch = m_config.columnPitch();
   if (columnpitch != 1) {
     int sourcemonth = (m_config.isColumnsAreDays())
                       // use the user's locale to determine the week's start
                       ? (m_beginDate.dayOfWeek() + 8 - QLocale().firstDayOfWeek()) % 7
                       : m_beginDate.month();
     int sourcecolumn = m_startColumn;
     int destcolumn = m_startColumn;
     while (sourcecolumn < m_numColumns) {
       if (sourcecolumn != destcolumn) {
 #if 0
         // TODO: Clean up this rather inefficient kludge. We really should jump by an entire
         // destcolumn at a time on RS reports, and calculate the proper sourcecolumn to use,
         // allowing us to clear and accumulate only ONCE per destcolumn
         if (m_config_f.isRunningSum())
           clearColumn(destcolumn);
 #endif
         accumulateColumn(destcolumn, sourcecolumn);
       }
 
       if (++sourcecolumn < m_numColumns) {
         if ((sourcemonth++ % columnpitch) == 0) {
           if (sourcecolumn != ++destcolumn)
             clearColumn(destcolumn);
         }
       }
     }
     m_numColumns = destcolumn + 1;
   }
 }
 
 void PivotTable::accumulateColumn(int destcolumn, int sourcecolumn)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("From Column %1 to %2").arg(sourcecolumn).arg(destcolumn));
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     // iterate over inner groups
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       // iterator over rows
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         if ((*it_row)[eActual].count() <= sourcecolumn)
-          throw MYMONEYEXCEPTION(QString("Sourcecolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Sourcecolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
         if ((*it_row)[eActual].count() <= destcolumn)
-          throw MYMONEYEXCEPTION(QString("Destcolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Destcolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
 
         (*it_row)[eActual][destcolumn] += (*it_row)[eActual][sourcecolumn];
         ++it_row;
       }
 
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::clearColumn(int column)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("Column %1").arg(column));
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     // iterate over inner groups
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       // iterator over rows
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         if ((*it_row)[eActual].count() <= column)
-          throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(column).arg((*it_row)[eActual].count()));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(column).arg((*it_row)[eActual].count()));
 
         (*it_row++)[eActual][column] = PivotCell();
       }
 
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::calculateColumnHeadings()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // one column for the opening balance
   if (m_startColumn == 1)
     m_columnHeadings.append("Opening");
 
   int columnpitch = m_config.columnPitch();
 
   if (columnpitch == 0) {
     // output the warning but don't crash by dividing with 0
     qWarning("PivotTable::calculateColumnHeadings() Invalid column pitch");
     return;
   }
 
   // if this is a days-based report
   if (m_config.isColumnsAreDays()) {
     if (columnpitch == 1) {
       QDate columnDate = m_beginDate;
       int column = m_startColumn;
       while (column++ < m_numColumns) {
         QString heading = QLocale().monthName(columnDate.month(), QLocale::ShortFormat) + ' ' + QString::number(columnDate.day());
         columnDate = columnDate.addDays(1);
         m_columnHeadings.append(heading);
       }
     } else {
       QDate day = m_beginDate;
       QDate prv = m_beginDate;
 
       // use the user's locale to determine the week's start
       int dow = (day.dayOfWeek() + 8 - QLocale().firstDayOfWeek()) % 7;
 
       while (day <= m_endDate) {
         if (((dow % columnpitch) == 0) || (day == m_endDate)) {
           m_columnHeadings.append(QString("%1&nbsp;%2 - %3&nbsp;%4")
                                   .arg(QLocale().monthName(prv.month(), QLocale::ShortFormat))
                                   .arg(prv.day())
                                   .arg(QLocale().monthName(day.month(), QLocale::ShortFormat))
                                   .arg(day.day()));
           prv = day.addDays(1);
         }
         day = day.addDays(1);
         dow++;
       }
     }
   }
 
   // else it's a months-based report
   else {
     if (columnpitch == 12) {
       int year = m_beginDate.year();
       int column = m_startColumn;
       while (column++ < m_numColumns)
         m_columnHeadings.append(QString::number(year++));
     } else {
       int year = m_beginDate.year();
       bool includeyear = (m_beginDate.year() != m_endDate.year());
       int segment = (m_beginDate.month() - 1) / columnpitch;
       int column = m_startColumn;
       while (column++ < m_numColumns) {
         QString heading = QLocale().monthName(1 + segment * columnpitch, QLocale::ShortFormat);
         if (columnpitch != 1)
           heading += '-' + QLocale().monthName((1 + segment) * columnpitch, QLocale::ShortFormat);
         if (includeyear)
           heading += ' ' + QString::number(year);
         m_columnHeadings.append(heading);
         if (++segment >= 12 / columnpitch) {
           segment -= 12 / columnpitch;
           ++year;
         }
       }
     }
   }
 }
 
 void PivotTable::createAccountRows()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
 
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
 
   while (it_account != accounts.constEnd()) {
     ReportAccount account(*it_account);
 
     // only include this item if its account group is included in this report
     // and if the report includes this account
     if (m_config.includes(*it_account)) {
       DEBUG_OUTPUT(QString("Includes account %1").arg(account.name()));
 
       // the row group is the account class (major account type)
       QString outergroup = MyMoneyAccount::accountTypeToString(account.accountGroup());
       // place into the 'opening' column...
       assignCell(outergroup, account, 0, MyMoneyMoney());
     }
     ++it_account;
   }
 }
 
 void PivotTable::calculateOpeningBalances()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // First, determine the inclusive dates of the report.  Normally, that's just
   // the begin & end dates of m_config_f.  However, if either of those dates are
   // blank, we need to use m_beginDate and/or m_endDate instead.
   QDate from = m_config.fromDate();
   QDate to = m_config.toDate();
   if (! from.isValid())
     from = m_beginDate;
   if (! to.isValid())
     to = m_endDate;
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
 
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
 
   while (it_account != accounts.constEnd()) {
     ReportAccount account(*it_account);
 
     // only include this item if its account group is included in this report
     // and if the report includes this account
     if (m_config.includes(*it_account)) {
 
       //do not include account if it is closed and it has no transactions in the report period
       if (account.isClosed()) {
         //check if the account has transactions for the report timeframe
         MyMoneyTransactionFilter filter;
         filter.addAccount(account.id());
         filter.setDateFilter(m_beginDate, m_endDate);
         filter.setReportAllSplits(false);
         QList<MyMoneyTransaction> transactions = file->transactionList(filter);
         //if a closed account has no transactions in that timeframe, do not include it
         if (transactions.size() == 0) {
           DEBUG_OUTPUT(QString("DOES NOT INCLUDE account %1").arg(account.name()));
           ++it_account;
           continue;
         }
       }
 
       DEBUG_OUTPUT(QString("Includes account %1").arg(account.name()));
       // the row group is the account class (major account type)
       QString outergroup = MyMoneyAccount::accountTypeToString(account.accountGroup());
 
       // extract the balance of the account for the given begin date, which is
       // the opening balance plus the sum of all transactions prior to the begin
       // date
 
       // this is in the underlying currency
       MyMoneyMoney value = file->balance(account.id(), from.addDays(-1));
 
       // place into the 'opening' column...
       assignCell(outergroup, account, 0, value);
     } else {
       DEBUG_OUTPUT(QString("DOES NOT INCLUDE account %1").arg(account.name()));
     }
 
     ++it_account;
   }
 }
 
 void PivotTable::calculateRunningSums(PivotInnerGroup::iterator& it_row)
 {
   MyMoneyMoney runningsum = it_row.value()[eActual][0].calculateRunningSum(MyMoneyMoney());
   int column = m_startColumn;
   while (column < m_numColumns) {
     if (it_row.value()[eActual].count() <= column)
-      throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
 
     runningsum = it_row.value()[eActual][column].calculateRunningSum(runningsum);
 
     ++column;
   }
 }
 
 void PivotTable::calculateRunningSums()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   m_runningSumsCalculated = true;
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
 #if 0
         MyMoneyMoney runningsum = it_row.value()[0];
         int column = m_startColumn;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
-            throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
 
           runningsum = (it_row.value()[eActual][column] += runningsum);
 
           ++column;
         }
 #endif
         calculateRunningSums(it_row);
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 MyMoneyMoney PivotTable::cellBalance(const QString& outergroup, const ReportAccount& _row, int _column, bool budget)
 {
   if (m_runningSumsCalculated) {
     qDebug("You must not call PivotTable::cellBalance() after calling PivotTable::calculateRunningSums()");
-    throw MYMONEYEXCEPTION(QString("You must not call PivotTable::cellBalance() after calling PivotTable::calculateRunningSums()"));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("You must not call PivotTable::cellBalance() after calling PivotTable::calculateRunningSums()"));
   }
 
   // for budget reports, if this is the actual value, map it to the account which
   // holds its budget
   ReportAccount row = _row;
   if (!budget && m_config.hasBudget()) {
     QString newrow = m_budgetMap[row.id()];
 
     // if there was no mapping found, then the budget report is not interested
     // in this account.
     if (newrow.isEmpty())
       return MyMoneyMoney();
 
     row = ReportAccount(newrow);
   }
 
   // ensure the row already exists (and its parental hierarchy)
   createRow(outergroup, row, true);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (m_numColumns <= _column)
-    throw MYMONEYEXCEPTION(QString("Column %1 out of m_numColumns range (%2) in PivotTable::cellBalance").arg(_column).arg(m_numColumns));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of m_numColumns range (%2) in PivotTable::cellBalance").arg(_column).arg(m_numColumns));
   if (m_grid[outergroup][innergroup][row][eActual].count() <= _column)
-    throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(_column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(_column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
 
   MyMoneyMoney balance;
   if (budget)
     balance = m_grid[outergroup][innergroup][row][eBudget][0].cellBalance(MyMoneyMoney());
   else
     balance = m_grid[outergroup][innergroup][row][eActual][0].cellBalance(MyMoneyMoney());
 
   int column = m_startColumn;
   while (column < _column) {
     if (m_grid[outergroup][innergroup][row][eActual].count() <= column)
-      throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
+      throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
 
     balance = m_grid[outergroup][innergroup][row][eActual][column].cellBalance(balance);
 
     ++column;
   }
 
   return balance;
 }
 
 
 void PivotTable::calculateBudgetMapping()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   // Only do this if there is at least one budget in the file
   if (file->countBudgets()) {
     // Select a budget
     //
     // It will choose the first budget in the list for the start year of the report if no budget is selected
     MyMoneyBudget budget = MyMoneyBudget();
     QList<MyMoneyBudget> budgets = file->budgetList();
     bool validBudget = false;
 
     //check that the selected budget is valid
     if (m_config.budget() != "Any") {
       QList<MyMoneyBudget>::const_iterator budgets_it = budgets.constBegin();
       while (budgets_it != budgets.constEnd()) {
         //pick the budget by id
         if ((*budgets_it).id() == m_config.budget()) {
           budget = file->budget((*budgets_it).id());
           validBudget = true;
           break;
         }
         ++budgets_it;
       }
     }
 
     //if no valid budget has been selected
     if (!validBudget) {
       //if the budget list is empty, just return
       if (budgets.count() == 0) {
         return;
       }
 
       QList<MyMoneyBudget>::const_iterator budgets_it = budgets.constBegin();
       while (budgets_it != budgets.constEnd()) {
         //pick the first budget that matches the report start year
         if ((*budgets_it).budgetStart().year() == QDate::currentDate().year()) {
           budget = file->budget((*budgets_it).id());
           break;
         }
         ++budgets_it;
       }
       //if it can't find a matching budget, take the first one on the list
       if (budget.id().isEmpty()) {
         budget = budgets[0];
       }
 
       //assign the budget to the report
       m_config.setBudget(budget.id(), m_config.isIncludingBudgetActuals());
     }
 
     // Dump the budget
     //qDebug() << "Budget " << budget.name() << ": ";
 
     // Go through all accounts in the system to build the mapping
     QList<MyMoneyAccount> accounts;
     file->accountList(accounts);
     QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
     while (it_account != accounts.constEnd()) {
       //include only the accounts selected for the report
       if (m_config.includes(*it_account)) {
         QString id = (*it_account).id();
         QString acid = id;
 
         // If the budget contains this account outright
         if (budget.contains(id)) {
           // Add it to the mapping
           m_budgetMap[acid] = id;
           // qDebug() << ReportAccount(acid).debugName() << " self-maps / type =" << budget.account(id).budgetLevel();
         }
         // Otherwise, search for a parent account which includes sub-accounts
         else {
           //if includeBudgetActuals, include all accounts regardless of whether in budget or not
           if (m_config.isIncludingBudgetActuals()) {
             m_budgetMap[acid] = id;
             // qDebug() << ReportAccount(acid).debugName() << " maps to " << ReportAccount(id).debugName();
           }
           do {
             id = file->account(id).parentAccountId();
             if (budget.contains(id)) {
               if (budget.account(id).budgetSubaccounts()) {
                 m_budgetMap[acid] = id;
                 // qDebug() << ReportAccount(acid).debugName() << " maps to " << ReportAccount(id).debugName();
                 break;
               }
             }
           } while (! id.isEmpty());
         }
       }
       ++it_account;
     } // end while looping through the accounts in the file
 
     // Place the budget values into the budget grid
     QList<MyMoneyBudget::AccountGroup> baccounts = budget.getaccounts();
     QList<MyMoneyBudget::AccountGroup>::const_iterator it_bacc = baccounts.constBegin();
     while (it_bacc != baccounts.constEnd()) {
       ReportAccount splitAccount((*it_bacc).id());
 
       //include the budget account only if it is included in the report
       if (m_config.includes(splitAccount)) {
         eMyMoney::Account::Type type = splitAccount.accountGroup();
         QString outergroup = MyMoneyAccount::accountTypeToString(type);
 
         // reverse sign to match common notation for cash flow direction, only for expense/income splits
         MyMoneyMoney reverse((splitAccount.accountType() == eMyMoney::Account::Type::Expense) ? -1 : 1, 1);
 
         const QMap<QDate, MyMoneyBudget::PeriodGroup>& periods = (*it_bacc).getPeriods();
 
         // skip the account if it has no periods
         if (periods.count() < 1) {
           ++it_bacc;
           continue;
         }
 
         MyMoneyMoney value = (*periods.begin()).amount() * reverse;
         int column = m_startColumn;
 
         // based on the kind of budget it is, deal accordingly
         switch ((*it_bacc).budgetLevel()) {
           case MyMoneyBudget::AccountGroup::eYearly:
             // divide the single yearly value by 12 and place it in each column
             value /= MyMoneyMoney(12, 1);
             // intentional fall through
 
           case MyMoneyBudget::AccountGroup::eNone:
           case MyMoneyBudget::AccountGroup::eMax:
           case MyMoneyBudget::AccountGroup::eMonthly:
             // place the single monthly value in each column of the report
             // only add the value if columns are monthly or longer
             if (m_config.columnType() == MyMoneyReport::eBiMonths
                 || m_config.columnType() == MyMoneyReport::eMonths
                 || m_config.columnType() == MyMoneyReport::eYears
                 || m_config.columnType() == MyMoneyReport::eQuarters) {
               QDate budgetDate = budget.budgetStart();
               while (column < m_numColumns && budget.budgetStart().addYears(1) > budgetDate) {
                 //only show budget values if the budget year and the column date match
                 //no currency conversion is done here because that is done for all columns later
                 if (budgetDate > columnDate(column)) {
                   ++column;
                 } else {
                   if (budgetDate >= m_beginDate.addDays(-m_beginDate.day() + 1)
                       && budgetDate <= m_endDate.addDays(m_endDate.daysInMonth() - m_endDate.day())
                       && budgetDate > (columnDate(column).addMonths(-m_config.columnType()))) {
                     assignCell(outergroup, splitAccount, column, value, true /*budget*/);
                   }
                   budgetDate = budgetDate.addMonths(1);
                 }
               }
             }
             break;
           case MyMoneyBudget::AccountGroup::eMonthByMonth:
             // place each value in the appropriate column
             // budget periods are supposed to come in order just like columns
             {
               QMap<QDate, MyMoneyBudget::PeriodGroup>::const_iterator it_period = periods.begin();
               while (it_period != periods.end() && column < m_numColumns) {
                 if ((*it_period).startDate() > columnDate(column)) {
                   ++column;
                 } else {
                   switch (m_config.columnType()) {
                     case MyMoneyReport::eYears:
                     case MyMoneyReport::eBiMonths:
                     case MyMoneyReport::eQuarters:
                     case MyMoneyReport::eMonths: {
                         if ((*it_period).startDate() >= m_beginDate.addDays(-m_beginDate.day() + 1)
                             && (*it_period).startDate() <= m_endDate.addDays(m_endDate.daysInMonth() - m_endDate.day())
                             && (*it_period).startDate() > (columnDate(column).addMonths(-m_config.columnType()))) {
                           //no currency conversion is done here because that is done for all columns later
                           value = (*it_period).amount() * reverse;
                           assignCell(outergroup, splitAccount, column, value, true /*budget*/);
                         }
                         ++it_period;
                         break;
                       }
                     default:
                       break;
                   }
                 }
               }
               break;
             }
         }
       }
       ++it_bacc;
     }
   } // end if there was a budget
 }
 
 void PivotTable::convertToBaseCurrency()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int fraction = file->baseCurrency().smallestAccountFraction();
   QList<ERowType> rowTypeList = m_rowTypeList;
   rowTypeList.removeOne(eAverage);
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         auto column = 0;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
-            throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::convertToBaseCurrency").arg(column).arg(it_row.value()[eActual].count()));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::convertToBaseCurrency").arg(column).arg(it_row.value()[eActual].count()));
 
           QDate valuedate = columnDate(column);
 
           //get base price for that date
           MyMoneyMoney conversionfactor = it_row.key().baseCurrencyPrice(valuedate, m_config.isSkippingZero());
           int pricePrecision;
           if (it_row.key().isInvest())
             pricePrecision = file->security(it_row.key().currencyId()).pricePrecision();
           else
             pricePrecision = MyMoneyMoney::denomToPrec(fraction);
 
           foreach (const auto rowType, rowTypeList) {
             //calculate base value
             MyMoneyMoney oldval = it_row.value()[rowType][column];
             MyMoneyMoney value = (oldval * conversionfactor).reduce();
 
             //convert to lowest fraction
             if (rowType == ePrice)
               it_row.value()[rowType][column] = PivotCell(MyMoneyMoney(value.convertPrecision(pricePrecision)));
             else
               it_row.value()[rowType][column] = PivotCell(value.convert(fraction));
 
             DEBUG_OUTPUT_IF(conversionfactor != MyMoneyMoney::ONE , QString("Factor of %1, value was %2, now %3").arg(conversionfactor).arg(DEBUG_SENSITIVE(oldval)).arg(DEBUG_SENSITIVE(it_row.value()[rowType][column].toDouble())));
           }
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::convertToDeepCurrency()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   MyMoneyFile* file = MyMoneyFile::instance();
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         auto column = 0;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
-            throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::convertToDeepCurrency").arg(column).arg(it_row.value()[eActual].count()));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::convertToDeepCurrency").arg(column).arg(it_row.value()[eActual].count()));
 
           QDate valuedate = columnDate(column);
 
           //get conversion factor for the account and date
           MyMoneyMoney conversionfactor = it_row.key().deepCurrencyPrice(valuedate, m_config.isSkippingZero());
 
           //use the fraction relevant to the account at hand
           int fraction = it_row.key().currency().smallestAccountFraction();
 
           //use base currency fraction if not initialized
           if (fraction == -1)
             fraction = file->baseCurrency().smallestAccountFraction();
 
           //convert to deep currency
           MyMoneyMoney oldval = it_row.value()[eActual][column];
           MyMoneyMoney value = (oldval * conversionfactor).reduce();
           //reduce to lowest fraction
           it_row.value()[eActual][column] = PivotCell(value.convert(fraction));
 
           //convert price data
           if (m_config.isIncludingPrice()) {
             MyMoneyMoney oldPriceVal = it_row.value()[ePrice][column];
             MyMoneyMoney priceValue = (oldPriceVal * conversionfactor).reduce();
             it_row.value()[ePrice][column] = PivotCell(priceValue.convert(10000));
           }
 
           DEBUG_OUTPUT_IF(conversionfactor != MyMoneyMoney::ONE , QString("Factor of %1, value was %2, now %3").arg(conversionfactor).arg(DEBUG_SENSITIVE(oldval)).arg(DEBUG_SENSITIVE(it_row.value()[eActual][column].toDouble())));
 
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::calculateTotals()
 {
   //insert the row type that is going to be used
   for (int i = 0; i < m_rowTypeList.size(); ++i) {
     for (int k = 0; k < m_numColumns; ++k) {
       m_grid.m_total[ m_rowTypeList[i] ].append(PivotCell());
     }
   }
   //
   // Outer groups
   //
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     for (int i = 0; i < m_rowTypeList.size(); ++i) {
       for (int k = 0; k < m_numColumns; ++k) {
         (*it_outergroup).m_total[ m_rowTypeList[i] ].append(PivotCell());
       }
     }
 
     //
     // Inner Groups
     //
 
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         for (int k = 0; k < m_numColumns; ++k) {
           (*it_innergroup).m_total[ m_rowTypeList[i] ].append(PivotCell());
         }
       }
       //
       // Rows
       //
 
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         //
         // Columns
         //
 
         auto column = 0;
         while (column < m_numColumns) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             if (it_row.value()[ m_rowTypeList[i] ].count() <= column)
-              throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, row columns").arg(column).arg(it_row.value()[ m_rowTypeList[i] ].count()));
+              throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateTotals, row columns").arg(column).arg(it_row.value()[ m_rowTypeList[i] ].count()));
             if ((*it_innergroup).m_total[ m_rowTypeList[i] ].count() <= column)
-              throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
+              throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
             //calculate total
             MyMoneyMoney value = it_row.value()[ m_rowTypeList[i] ][column];
             (*it_innergroup).m_total[ m_rowTypeList[i] ][column] += value;
             (*it_row)[ m_rowTypeList[i] ].m_total += value;
           }
           ++column;
         }
         ++it_row;
       }
 
       //
       // Inner Row Group Totals
       //
 
       auto column = 0;
       while (column < m_numColumns) {
         for (int i = 0; i < m_rowTypeList.size(); ++i) {
           if ((*it_innergroup).m_total[ m_rowTypeList[i] ].count() <= column)
-            throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
           if ((*it_outergroup).m_total[ m_rowTypeList[i] ].count() <= column)
-            throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, outer group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
+            throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateTotals, outer group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
           //calculate totals
           MyMoneyMoney value = (*it_innergroup).m_total[ m_rowTypeList[i] ][column];
           (*it_outergroup).m_total[ m_rowTypeList[i] ][column] += value;
           (*it_innergroup).m_total[ m_rowTypeList[i] ].m_total += value;
         }
         ++column;
       }
 
       ++it_innergroup;
     }
 
     //
     // Outer Row Group Totals
     //
 
     const bool isIncomeExpense = (m_config.rowType() == MyMoneyReport::eExpenseIncome);
     const bool invert_total = (*it_outergroup).m_inverted;
     auto column = 0;
     while (column < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         if (m_grid.m_total[ m_rowTypeList[i] ].count() <= column)
-          throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
         //calculate actual totals
         MyMoneyMoney value = (*it_outergroup).m_total[ m_rowTypeList[i] ][column];
         (*it_outergroup).m_total[ m_rowTypeList[i] ].m_total += value;
 
         //so far the invert only applies to actual and budget
         if (invert_total && m_rowTypeList[i] != eBudgetDiff && m_rowTypeList[i] != eForecast)
           value = -value;
         // forecast income expense reports should be inverted as oposed to asset/liability reports
         if (invert_total && isIncomeExpense && m_rowTypeList[i] == eForecast)
           value = -value;
 
         m_grid.m_total[ m_rowTypeList[i] ][column] += value;
       }
       ++column;
     }
     ++it_outergroup;
   }
 
   //
   // Report Totals
   //
 
   auto totalcolumn = 0;
   while (totalcolumn < m_numColumns) {
     for (int i = 0; i < m_rowTypeList.size(); ++i) {
       if (m_grid.m_total[ m_rowTypeList[i] ].count() <= totalcolumn)
-        throw MYMONEYEXCEPTION(QString("Total column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(totalcolumn).arg(m_grid.m_total[ m_rowTypeList[i] ].count()));
+        throw MYMONEYEXCEPTION(QString::fromLatin1("Total column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(totalcolumn).arg(m_grid.m_total[ m_rowTypeList[i] ].count()));
 
       //calculate actual totals
       MyMoneyMoney value = m_grid.m_total[ m_rowTypeList[i] ][totalcolumn];
       m_grid.m_total[ m_rowTypeList[i] ].m_total += value;
     }
     ++totalcolumn;
   }
 }
 
 void PivotTable::assignCell(const QString& outergroup, const ReportAccount& _row, int column, MyMoneyMoney value, bool budget, bool stockSplit)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("Parameters: %1,%2,%3,%4,%5").arg(outergroup).arg(_row.debugName()).arg(column).arg(DEBUG_SENSITIVE(value.toDouble())).arg(budget));
 
   // for budget reports, if this is the actual value, map it to the account which
   // holds its budget
   ReportAccount row = _row;
   if (!budget && m_config.hasBudget()) {
     QString newrow = m_budgetMap[row.id()];
 
     // if there was no mapping found, then the budget report is not interested
     // in this account.
     if (newrow.isEmpty())
       return;
 
     row = ReportAccount(newrow);
   }
 
   // ensure the row already exists (and its parental hierarchy)
   createRow(outergroup, row, true);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (m_numColumns <= column)
-    throw MYMONEYEXCEPTION(QString("Column %1 out of m_numColumns range (%2) in PivotTable::assignCell").arg(column).arg(m_numColumns));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of m_numColumns range (%2) in PivotTable::assignCell").arg(column).arg(m_numColumns));
   if (m_grid[outergroup][innergroup][row][eActual].count() <= column)
-    throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
   if (m_grid[outergroup][innergroup][row][eBudget].count() <= column)
-    throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eBudget].count()));
+    throw MYMONEYEXCEPTION(QString::fromLatin1("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eBudget].count()));
 
   if (!stockSplit) {
     // Determine whether the value should be inverted before being placed in the row
     if (m_grid[outergroup].m_inverted)
       value = -value;
 
     // Add the value to the grid cell
     if (budget) {
       m_grid[outergroup][innergroup][row][eBudget][column] += value;
     } else {
       // If it is loading an actual value for a budget report
       // check whether it is a subaccount of a budget account (include subaccounts)
       // If so, check if is the same currency and convert otherwise
       if (m_config.hasBudget() &&
           row.id() != _row.id() &&
           row.currencyId() != _row.currencyId()) {
         ReportAccount origAcc = _row;
         MyMoneyMoney rate = origAcc.foreignCurrencyPrice(row.currencyId(), columnDate(column), false);
         m_grid[outergroup][innergroup][row][eActual][column] += (value * rate).reduce();
       } else {
         m_grid[outergroup][innergroup][row][eActual][column] += value;
       }
     }
   } else {
     m_grid[outergroup][innergroup][row][eActual][column] += PivotCell::stockSplit(value);
   }
 
 }
 
 void PivotTable::createRow(const QString& outergroup, const ReportAccount& row, bool recursive)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (! m_grid.contains(outergroup)) {
     DEBUG_OUTPUT(QString("Adding group [%1]").arg(outergroup));
     m_grid[outergroup] = PivotOuterGroup(m_numColumns);
   }
 
   if (! m_grid[outergroup].contains(innergroup)) {
     DEBUG_OUTPUT(QString("Adding group [%1][%2]").arg(outergroup).arg(innergroup));
     m_grid[outergroup][innergroup] = PivotInnerGroup(m_numColumns);
   }
 
   if (! m_grid[outergroup][innergroup].contains(row)) {
     DEBUG_OUTPUT(QString("Adding row [%1][%2][%3]").arg(outergroup).arg(innergroup).arg(row.debugName()));
     m_grid[outergroup][innergroup][row] = PivotGridRowSet(m_numColumns);
 
     if (recursive && !row.isTopLevel())
       createRow(outergroup, row.parent(), recursive);
   }
 }
 
 int PivotTable::columnValue(const QDate& _date) const
 {
   if (m_config.isColumnsAreDays())
     return (m_beginDate.daysTo(_date));
   else
     return (_date.year() * 12 + _date.month());
 }
 
 QDate PivotTable::columnDate(int column) const
 {
   if (m_config.isColumnsAreDays())
     return m_beginDate.addDays(m_config.columnPitch() * column - m_startColumn);
   else
     return m_beginDate.addMonths(m_config.columnPitch() * column).addDays(-m_startColumn);
 }
 
 QString PivotTable::renderCSV() const
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int pricePrecision = 0;
   int currencyPrecision = 0;
   int precision = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
 
   bool isMultipleCurrencies = false;
 
   //
   // Table Header
   //
 
   QString result = i18n("Account");
 
   auto column = 0;
   while (column < m_numColumns) {
     result += QString(",%1").arg(QString(m_columnHeadings[column++]));
     if (m_rowTypeList.size() > 1) {
       QString separator;
       separator = separator.fill(',', m_rowTypeList.size() - 1);
       result += separator;
     }
   }
 
   //show total columns
   if (m_config.isShowingRowTotals())
     result += QString(",%1").arg(i18nc("Total balance", "Total"));
 
   result += '\n';
 
   // Row Type Header
   if (m_rowTypeList.size() > 1) {
     column = 0;
     while (column < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString(",%1").arg(m_columnTypeHeaderList[i]);
       }
       column++;
     }
     if (m_config.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString(",%1").arg(m_columnTypeHeaderList[i]);
       }
     }
     result += '\n';
   }
 
   //
   // Outer groups
   //
 
   // iterate over outer groups
   PivotGrid::const_iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     //
     // Outer Group Header
     //
 
     if (!(m_config.isIncludingPrice() || m_config.isIncludingAveragePrice()))
       result += it_outergroup.key() + '\n';
 
     //
     // Inner Groups
     //
 
     PivotOuterGroup::const_iterator it_innergroup = (*it_outergroup).begin();
     int rownum = 0;
     while (it_innergroup != (*it_outergroup).end()) {
       //
       // Rows
       //
 
       QString innergroupdata;
       PivotInnerGroup::const_iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         ReportAccount rowname = it_row.key();
 
         //
         // Columns
         //
 
         QString rowdata;
         column = 0;
 
         bool isUsed = false;
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           isUsed |= it_row.value()[ m_rowTypeList[i] ][0].isUsed();
 
         if (it_row.key().accountType() != eMyMoney::Account::Type::Investment) {
           while (column < m_numColumns) {
 
             //show columns
             foreach (const auto rowType, m_rowTypeList) {
               if (rowType == ePrice) {
                 if (pricePrecision == 0) {
                   if (it_row.key().isInvest()) {
                     pricePrecision = file->currency(it_row.key().currencyId()).pricePrecision();
                     precision = pricePrecision;
                   } else
                     precision = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
                 } else
                   precision = pricePrecision;
               } else {
                 if (currencyPrecision == 0) {
                   if (it_row.key().isInvest()) // stock account isn't eveluated in currency, so take investment account instead
                     currencyPrecision = MyMoneyMoney::denomToPrec(it_row.key().parent().fraction());
                   else
                     currencyPrecision = MyMoneyMoney::denomToPrec(it_row.key().fraction());
                   precision = currencyPrecision;
                 } else
                   precision = currencyPrecision;
               }
               rowdata += QString(",\"%1\"").arg(it_row.value()[rowType][column].formatMoney(QString(), precision, false));
               isUsed |= it_row.value()[rowType][column].isUsed();
             }
             column++;
           }
 
           if (m_config.isShowingRowTotals()) {
             for (int i = 0; i < m_rowTypeList.size(); ++i)
               rowdata += QString(",\"%1\"").arg((*it_row)[ m_rowTypeList[i] ].m_total.formatMoney(QString(), precision, false));
           }
         } else {
           for (auto i = 0; i < m_numColumns + m_rowTypeList.size(); ++i)
             rowdata.append(',');;
         }
 
         //
         // Row Header
         //
 
         if (!rowname.isClosed() || isUsed) {
           innergroupdata += "\"" + QString().fill(' ', rowname.hierarchyDepth() - 1) + rowname.name();
 
           // if we don't convert the currencies to the base currency and the
           // current row contains a foreign currency, then we append the currency
           // to the name of the account
           if (!m_config.isConvertCurrency() && rowname.isForeignCurrency())
             innergroupdata += QString(" (%1)").arg(rowname.currencyId());
 
           innergroupdata += '\"';
 
           if (isUsed)
             innergroupdata += rowdata;
 
           innergroupdata += '\n';
           if (!isMultipleCurrencies && rowname.isForeignCurrency())
             isMultipleCurrencies = true;
           if (!m_containsNonBaseCurrency && rowname.isForeignCurrency())
             m_containsNonBaseCurrency = true;
         }
         ++it_row;
       }
 
       //
       // Inner Row Group Totals
       //
 
       bool finishrow = true;
       QString finalRow;
       bool isUsed = false;
       if (m_config.detailLevel() == MyMoneyReport::eDetailAll && ((*it_innergroup).size() > 1)) {
         // Print the individual rows
         result += innergroupdata;
 
         if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
           // Start the TOTALS row
           finalRow = i18nc("Total balance", "Total");
           isUsed = true;
         } else {
           ++rownum;
           finishrow = false;
         }
       } else {
         // Start the single INDIVIDUAL ACCOUNT row
         ReportAccount rowname = (*it_innergroup).begin().key();
         isUsed |= !rowname.isClosed();
 
         finalRow = "\"" + QString().fill(' ', rowname.hierarchyDepth() - 1) + rowname.name();
         if (!m_config.isConvertCurrency() && rowname.isForeignCurrency())
           finalRow += QString(" (%1)").arg(rowname.currencyId());
         finalRow += "\"";
       }
 
       // Finish the row started above, unless told not to
       if (finishrow) {
         column = 0;
 
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][0].isUsed();
 
         while (column < m_numColumns) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][column].isUsed();
             finalRow += QString(",\"%1\"").arg((*it_innergroup).m_total[ m_rowTypeList[i] ][column].formatMoney(QString(), precision, false));
           }
           column++;
         }
 
         if (m_config.isShowingRowTotals()) {
           for (int i = 0; i < m_rowTypeList.size(); ++i)
             finalRow += QString(",\"%1\"").arg((*it_innergroup).m_total[ m_rowTypeList[i] ].m_total.formatMoney(QString(), precision, false));
         }
 
         finalRow += '\n';
       }
 
       if (isUsed) {
         result += finalRow;
         ++rownum;
       }
       ++it_innergroup;
     }
 
     //
     // Outer Row Group Totals
     //
 
     if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
       result += QString("%1 %2").arg(i18nc("Total balance", "Total")).arg(it_outergroup.key());
       column = 0;
       while (column < m_numColumns) {
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           result += QString(",\"%1\"").arg((*it_outergroup).m_total[ m_rowTypeList[i] ][column].formatMoney(QString(), precision, false));
 
         column++;
       }
 
       if (m_config.isShowingRowTotals()) {
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           result += QString(",\"%1\"").arg((*it_outergroup).m_total[ m_rowTypeList[i] ].m_total.formatMoney(QString(), precision, false));
       }
 
       result += '\n';
     }
     ++it_outergroup;
   }
 
   //
   // Report Totals
   //
 
   if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
     result += i18n("Grand Total");
     auto totalcolumn = 0;
     while (totalcolumn < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i)
         result += QString(",\"%1\"").arg(m_grid.m_total[ m_rowTypeList[i] ][totalcolumn].formatMoney(QString(), precision, false));
 
       totalcolumn++;
     }
 
     if (m_config.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i)
         result += QString(",\"%1\"").arg(m_grid.m_total[ m_rowTypeList[i] ].m_total.formatMoney(QString(), precision, false));
     }
 
     result += '\n';
   }
   return result;
 }
 
 QString PivotTable::renderHTML() const
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int pricePrecision = 0;
   int currencyPrecision = 0;
   int precision = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
   QString colspan = QString(" colspan=\"%1\"").arg(m_numColumns + 1 + (m_config.isShowingRowTotals() ? 1 : 0));
 
   // setup a leftborder for better readability of budget vs actual reports
   QString leftborder;
   if (m_rowTypeList.size() > 1)
     leftborder = " class=\"leftborder\"";
 
   //
   // Table Header
   //
   QString result = QString("\n\n<table class=\"report\" cellspacing=\"0\">\n"
                     "<thead><tr class=\"itemheader\">\n<th>%1</th>").arg(i18n("Account"));
 
   QString headerspan;
   int span = m_rowTypeList.size();
 
   headerspan = QString(" colspan=\"%1\"").arg(span);
 
   auto column = 0;
   while (column < m_numColumns)
     result += QString("<th%1>%2</th>").arg(headerspan, QString(m_columnHeadings[column++]).replace(QRegExp(" "), "<br>"));
 
   if (m_config.isShowingRowTotals())
     result += QString("<th%1>%2</th>").arg(headerspan).arg(i18nc("Total balance", "Total"));
 
   result += "</tr></thead>\n";
 
   //
   // Header for multiple columns
   //
   if (span > 1) {
     result += "<tr><td></td>";
 
     column = 0;
     while (column < m_numColumns) {
       QString lb;
       if (column != 0)
         lb = leftborder;
 
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(m_columnTypeHeaderList[i])
                   .arg(i == 0 ? lb : QString());
       }
       column++;
     }
     if (m_config.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(m_columnTypeHeaderList[i])
                   .arg(i == 0 ? leftborder : QString());
       }
     }
     result += "</tr>";
   }
 
 
   // Skip the body of the report if the report only calls for totals to be shown
   if (m_config.detailLevel() != MyMoneyReport::eDetailTotal) {
     //
     // Outer groups
     //
 
     // Need to sort the outergroups.  They can't always be sorted by name.  So we create a list of
     // map iterators, and sort that.  Then we'll iterate through the map iterators and use those as
     // before.
     //
     // I hope this doesn't bog the performance of reports, given that we're copying the entire report
     // data.  If this is a perf hit, we could change to storing outergroup pointers, I think.
 
     QList<PivotOuterGroup> outergroups;
     PivotGrid::const_iterator it_outergroup_map = m_grid.begin();
     while (it_outergroup_map != m_grid.end()) {
       outergroups.push_back(it_outergroup_map.value());
 
       // copy the name into the outergroup, because we will now lose any association with
       // the map iterator
       outergroups.back().m_displayName = it_outergroup_map.key();
 
       ++it_outergroup_map;
     }
     qSort(outergroups.begin(), outergroups.end());
 
     QList<PivotOuterGroup>::const_iterator it_outergroup = outergroups.constBegin();
     while (it_outergroup != outergroups.constEnd()) {
       //
       // Outer Group Header
       //
 
       if (!(m_config.isIncludingPrice() || m_config.isIncludingAveragePrice()))
         result += QString("<tr class=\"sectionheader\"><td class=\"left\"%1>%2</td></tr>\n").arg(colspan).arg((*it_outergroup).m_displayName);
 
       // Skip the inner groups if the report only calls for outer group totals to be shown
       if (m_config.detailLevel() != MyMoneyReport::eDetailGroup) {
 
         //
         // Inner Groups
         //
 
         PivotOuterGroup::const_iterator it_innergroup = (*it_outergroup).begin();
         int rownum = 0;
         while (it_innergroup != (*it_outergroup).end()) {
           //
           // Rows
           //
 
           QString innergroupdata;
           PivotInnerGroup::const_iterator it_row = (*it_innergroup).begin();
 
           while (it_row != (*it_innergroup).end()) {
             //
             // Columns
             //
 
             QString rowdata;
             column = 0;
             pricePrecision = 0; // new row => new account => new precision
             currencyPrecision = 0;
             bool isUsed = it_row.value()[eActual][0].isUsed();
             if (it_row.key().accountType() != eMyMoney::Account::Type::Investment) {
               while (column < m_numColumns) {
                 QString lb;
                 if (column > 0)
                   lb = leftborder;
 
                 foreach (const auto rowType, m_rowTypeList) {
                   if (rowType == ePrice) {
                     if (pricePrecision == 0) {
                       if (it_row.key().isInvest()) {
                         pricePrecision = file->currency(it_row.key().currencyId()).pricePrecision();
                         precision = pricePrecision;
                       } else
                         precision = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
                     } else
                       precision = pricePrecision;
                   } else {
                     if (currencyPrecision == 0) {
                       if (it_row.key().isInvest()) // stock account isn't eveluated in currency, so take investment account instead
                         currencyPrecision = MyMoneyMoney::denomToPrec(it_row.key().parent().fraction());
                       else
                         currencyPrecision = MyMoneyMoney::denomToPrec(it_row.key().fraction());
                       precision = currencyPrecision;
                     } else
                       precision = currencyPrecision;
                   }
                   rowdata += QString("<td%2>%1</td>")
                       .arg(coloredAmount(it_row.value()[rowType][column], QString(), precision))
                       .arg(lb);
                   lb.clear();
                   isUsed |= it_row.value()[rowType][column].isUsed();
                 }
                 ++column;
               }
 
               if (m_config.isShowingRowTotals()) {
                 for (int i = 0; i < m_rowTypeList.size(); ++i) {
                   rowdata += QString("<td%2>%1</td>")
                       .arg(coloredAmount(it_row.value()[ m_rowTypeList[i] ].m_total, QString(), precision))
                       .arg(i == 0 ? leftborder : QString());
                 }
               }
             } else
               rowdata += QString(QLatin1Literal("<td colspan=%1></td>")).arg(m_numColumns + m_rowTypeList.size());
 
             //
             // Row Header
             //
 
             ReportAccount rowname = it_row.key();
 
             // don't show closed accounts if they have not been used
             if (!rowname.isClosed() || isUsed) {
               innergroupdata += QString("<tr class=\"row-%1\"%2><td%3 class=\"left\" style=\"text-indent: %4.0em\">%5%6</td>")
                                 .arg(rownum & 0x01 ? "even" : "odd")
                                 .arg(rowname.isTopLevel() ? " id=\"topparent\"" : "")
                                 .arg("") //.arg((*it_row).m_total.isZero() ? colspan : "")  // colspan the distance if this row will be blank
                                 .arg(rowname.hierarchyDepth() - 1)
                                 .arg(rowname.name().replace(QRegExp(" "), "&nbsp;"))
                                 .arg((m_config.isConvertCurrency() || !rowname.isForeignCurrency()) ? QString() : QString(" (%1)").arg(rowname.currency().id()));
 
               // Don't print this row if it's going to be all zeros
               // TODO: Uncomment this, and deal with the case where the data
               // is zero, but the budget is non-zero
               //if ( !(*it_row).m_total.isZero() )
               innergroupdata += rowdata;
 
               innergroupdata += "</tr>\n";
               if (!m_containsNonBaseCurrency && rowname.isForeignCurrency())
                 m_containsNonBaseCurrency = true;
             }
 
             ++it_row;
           }
 
           //
           // Inner Row Group Totals
           //
 
           bool finishrow = true;
           QString finalRow;
           bool isUsed = false;
           if (m_config.detailLevel() == MyMoneyReport::eDetailAll && ((*it_innergroup).size() > 1)) {
             // Print the individual rows
             result += innergroupdata;
 
             if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
               // Start the TOTALS row
               finalRow = QString("<tr class=\"row-%1\" id=\"subtotal\"><td class=\"left\">&nbsp;&nbsp;%2</td>")
                          .arg(rownum & 0x01 ? "even" : "odd")
                          .arg(i18nc("Total balance", "Total"));
               // don't suppress display of totals
               isUsed = true;
             } else {
               finishrow = false;
               ++rownum;
             }
           } else {
             // Start the single INDIVIDUAL ACCOUNT row
             // FIXME: There is a bit of a bug here with class=leftX.  There's only a finite number
             // of classes I can define in the .CSS file, and the user can theoretically nest deeper.
             // The right solution is to use style=Xem, and calculate X.  Let's see if anyone complains
             // first :)  Also applies to the row header case above.
             // FIXED: I found it in one of my reports and changed it to the proposed method.
             // This works for me (ipwizard)
             ReportAccount rowname = (*it_innergroup).begin().key();
             isUsed |= !rowname.isClosed();
             finalRow = QString("<tr class=\"row-%1\"%2><td class=\"left\" style=\"text-indent: %3.0em;\">%5%6</td>")
                        .arg(rownum & 0x01 ? "even" : "odd")
                        .arg(m_config.detailLevel() == MyMoneyReport::eDetailAll ? "id=\"solo\"" : "")
                        .arg(rowname.hierarchyDepth() - 1)
                        .arg(rowname.name().replace(QRegExp(" "), "&nbsp;"))
                        .arg((m_config.isConvertCurrency() || !rowname.isForeignCurrency()) ? QString() : QString(" (%1)").arg(rowname.currency().id()));
           }
 
           // Finish the row started above, unless told not to
           if (finishrow) {
             column = 0;
             isUsed |= (*it_innergroup).m_total[eActual][0].isUsed();
             while (column < m_numColumns) {
               QString lb;
               if (column != 0)
                 lb = leftborder;
 
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 finalRow += QString("<td%2>%1</td>")
                             .arg(coloredAmount((*it_innergroup).m_total[ m_rowTypeList[i] ][column], QString(), precision))
                             .arg(i == 0 ? lb : QString());
                 isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][column].isUsed();
               }
 
               column++;
             }
 
             if (m_config.isShowingRowTotals()) {
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 finalRow += QString("<td%2>%1</td>")
                             .arg(coloredAmount((*it_innergroup).m_total[ m_rowTypeList[i] ].m_total, QString(), precision))
                             .arg(i == 0 ? leftborder : QString());
               }
             }
 
             finalRow += "</tr>\n";
             if (isUsed) {
               result += finalRow;
               ++rownum;
             }
           }
 
           ++it_innergroup;
 
         } // end while iterating on the inner groups
 
       } // end if detail level is not "group"
 
       //
       // Outer Row Group Totals
       //
 
       if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
         result += QString("<tr class=\"sectionfooter\"><td class=\"left\">%1&nbsp;%2</td>").arg(i18nc("Total balance", "Total")).arg((*it_outergroup).m_displayName);
         column = 0;
         while (column < m_numColumns) {
           QString lb;
           if (column != 0)
             lb = leftborder;
 
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             result += QString("<td%2>%1</td>")
                       .arg(coloredAmount((*it_outergroup).m_total[ m_rowTypeList[i] ][column], QString(), precision))
                       .arg(i == 0 ? lb : QString());
           }
 
           column++;
         }
 
         if (m_config.isShowingRowTotals()) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             result += QString("<td%2>%1</td>")
                       .arg(coloredAmount((*it_outergroup).m_total[ m_rowTypeList[i] ].m_total, QString(), precision))
                       .arg(i == 0 ? leftborder : QString());
           }
         }
         result += "</tr>\n";
       }
 
       ++it_outergroup;
 
     } // end while iterating on the outergroups
 
   } // end if detail level is not "total"
 
   //
   // Report Totals
   //
 
   if (m_config.isConvertCurrency() && m_config.isShowingColumnTotals()) {
     result += QString("<tr class=\"spacer\"><td>&nbsp;</td></tr>\n");
     result += QString("<tr class=\"reportfooter\"><td class=\"left\">%1</td>").arg(i18n("Grand Total"));
     auto totalcolumn = 0;
     while (totalcolumn < m_numColumns) {
       QString lb;
       if (totalcolumn != 0)
         lb = leftborder;
 
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(coloredAmount(m_grid.m_total[ m_rowTypeList[i] ][totalcolumn], QString(), precision))
                   .arg(i == 0 ? lb : QString());
       }
 
       totalcolumn++;
     }
 
     if (m_config.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(coloredAmount(m_grid.m_total[ m_rowTypeList[i] ].m_total, QString(), precision))
                   .arg(i == 0 ? leftborder : QString());
       }
     }
 
     result += "</tr>\n";
   }
   result += "</table>\n";
   return result;
 }
 
 void PivotTable::dump(const QString& file, const QString& /* context */) const
 {
   QFile g(file);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << renderHTML();
   g.close();
 }
 
 void PivotTable::drawChart(KReportChartView& chartView) const
 {
   chartView.drawPivotChart(m_grid, m_config, m_numColumns, m_columnHeadings, m_rowTypeList, m_columnTypeHeaderList);
 }
 
 QString PivotTable::coloredAmount(const MyMoneyMoney& amount, const QString& currencySymbol, int prec) const
 {
   const auto value = amount.formatMoney(currencySymbol, prec);
   if (amount.isNegative())
     return QString::fromLatin1("<font color=%1>%2</font>")
         .arg(KMyMoneySettings::schemeColor(SchemeColor::Negative).name(), value);
   else
     return value;
 }
 
 void PivotTable::calculateBudgetDiff()
 {
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = m_startColumn;
         switch (it_row.key().accountGroup()) {
           case eMyMoney::Account::Type::Income:
           case eMyMoney::Account::Type::Asset:
             while (column < m_numColumns) {
               it_row.value()[eBudgetDiff][column] = PivotCell(it_row.value()[eActual][column] - it_row.value()[eBudget][column]);
               ++column;
             }
             break;
           case eMyMoney::Account::Type::Expense:
           case eMyMoney::Account::Type::Liability:
             while (column < m_numColumns) {
               it_row.value()[eBudgetDiff][column] = PivotCell(it_row.value()[eBudget][column] - it_row.value()[eActual][column]);
               ++column;
             }
             break;
           default:
             break;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 
 }
 
 void PivotTable::calculateForecast()
 {
   //setup forecast
   MyMoneyForecast forecast = KMyMoneyUtils::forecast();
 
   //since this is a net worth forecast we want to include all account even those that are not in use
   forecast.setIncludeUnusedAccounts(true);
 
   //setup forecast dates
   if (m_endDate > QDate::currentDate()) {
     forecast.setForecastEndDate(m_endDate);
     forecast.setForecastStartDate(QDate::currentDate());
     forecast.setForecastDays(QDate::currentDate().daysTo(m_endDate));
   } else {
     forecast.setForecastStartDate(m_beginDate);
     forecast.setForecastEndDate(m_endDate);
     forecast.setForecastDays(m_beginDate.daysTo(m_endDate) + 1);
   }
 
   //adjust history dates if beginning date is before today
   if (m_beginDate < QDate::currentDate()) {
     forecast.setHistoryEndDate(m_beginDate.addDays(-1));
     forecast.setHistoryStartDate(forecast.historyEndDate().addDays(-forecast.accountsCycle()*forecast.forecastCycles()));
   }
 
   //run forecast
   if (m_config.rowType() == MyMoneyReport::eAssetLiability) { //asset and liability
     forecast.doForecast();
   } else { //income and expenses
     MyMoneyBudget budget;
     forecast.createBudget(budget, m_beginDate.addYears(-1), m_beginDate.addDays(-1), m_beginDate, m_endDate, false);
   }
 
   // check if we need to copy the opening balances
   // the conditions might be too tight but those fix a reported
   // problem and should avoid side effects in other situations
   // see https://bugs.kde.org/show_bug.cgi?id=391961
   const bool copyOpeningBalances = (m_startColumn == 1) &&
                                    !m_config.isIncludingSchedules() &&
                                    (m_config.isRunningSum());
 
   //go through the data and add forecast
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = m_startColumn;
         QDate forecastDate = m_beginDate;
         // check whether the opening balance needs to be setup
         if (copyOpeningBalances) {
           it_row.value()[eForecast][0] += it_row.value()[eActual][0];
         }
         //check whether columns are days or months
         if (m_config.isColumnsAreDays()) {
           while (column < m_numColumns) {
             it_row.value()[eForecast][column] = PivotCell(forecast.forecastBalance(it_row.key(), forecastDate));
 
             forecastDate = forecastDate.addDays(1);
             ++column;
           }
         } else {
           //if columns are months
           while (column < m_numColumns) {
             // the forecast balance is on the first day of the month see MyMoneyForecast::calculateScheduledMonthlyBalances()
             forecastDate = QDate(forecastDate.year(), forecastDate.month(), 1);
             //check that forecastDate is not over ending date
             if (forecastDate > m_endDate)
               forecastDate = m_endDate;
 
             //get forecast balance and set the corresponding column
             it_row.value()[eForecast][column] = PivotCell(forecast.forecastBalance(it_row.key(), forecastDate));
 
             forecastDate = forecastDate.addMonths(1);
             ++column;
           }
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::loadRowTypeList()
 {
   if ((m_config.isIncludingBudgetActuals()) ||
       (!m_config.hasBudget()
        && !m_config.isIncludingForecast()
        && !m_config.isIncludingMovingAverage()
        && !m_config.isIncludingPrice()
        && !m_config.isIncludingAveragePrice())
      ) {
     m_rowTypeList.append(eActual);
     m_columnTypeHeaderList.append(i18n("Actual"));
   }
 
   if (m_config.hasBudget()) {
     m_rowTypeList.append(eBudget);
     m_columnTypeHeaderList.append(i18n("Budget"));
   }
 
   if (m_config.isIncludingBudgetActuals()) {
     m_rowTypeList.append(eBudgetDiff);
     m_columnTypeHeaderList.append(i18n("Difference"));
   }
 
   if (m_config.isIncludingForecast()) {
     m_rowTypeList.append(eForecast);
     m_columnTypeHeaderList.append(i18n("Forecast"));
   }
 
   if (m_config.isIncludingMovingAverage()) {
     m_rowTypeList.append(eAverage);
     m_columnTypeHeaderList.append(i18n("Moving Average"));
   }
 
   if (m_config.isIncludingAveragePrice()) {
     m_rowTypeList.append(eAverage);
     m_columnTypeHeaderList.append(i18n("Moving Average Price"));
   }
 
   if (m_config.isIncludingPrice()) {
     m_rowTypeList.append(ePrice);
     m_columnTypeHeaderList.append(i18n("Price"));
   }
 }
 
 
 void PivotTable::calculateMovingAverage()
 {
   int delta = m_config.movingAverageDays() / 2;
 
   //go through the data and add the moving average
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = m_startColumn;
 
         //check whether columns are days or months
         if (m_config.columnType() == MyMoneyReport::eDays) {
           while (column < m_numColumns) {
             MyMoneyMoney totalPrice = MyMoneyMoney();
 
             QDate averageStart = columnDate(column).addDays(-delta);
             QDate averageEnd = columnDate(column).addDays(delta);
             for (QDate averageDate = averageStart; averageDate <= averageEnd; averageDate = averageDate.addDays(1)) {
               if (m_config.isConvertCurrency()) {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate) * it_row.key().baseCurrencyPrice(averageDate);
               } else {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate);
               }
               totalPrice = totalPrice.convert(10000);
             }
 
             //calculate the average price
             MyMoneyMoney averagePrice = totalPrice / MyMoneyMoney((averageStart.daysTo(averageEnd) + 1), 1);
 
             //get the actual value, multiply by the average price and save that value
             MyMoneyMoney averageValue = it_row.value()[eActual][column] * averagePrice;
             it_row.value()[eAverage][column] = PivotCell(averageValue.convert(10000));
 
             ++column;
           }
         } else {
           //if columns are months
           while (column < m_numColumns) {
             QDate averageStart = columnDate(column);
 
             //set the right start date depending on the column type
             switch (m_config.columnType()) {
               case MyMoneyReport::eYears: {
                   averageStart = QDate(columnDate(column).year(), 1, 1);
                   break;
                 }
               case MyMoneyReport::eBiMonths: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1).addMonths(-1);
                   break;
                 }
               case MyMoneyReport::eQuarters: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1).addMonths(-1);
                   break;
                 }
               case MyMoneyReport::eMonths: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1);
                   break;
                 }
               case MyMoneyReport::eWeeks: {
                   averageStart = columnDate(column).addDays(-columnDate(column).dayOfWeek() + 1);
                   break;
                 }
               default:
                 break;
             }
 
             //gather the actual data and calculate the average
             MyMoneyMoney totalPrice = MyMoneyMoney();
             QDate averageEnd = columnDate(column);
             for (QDate averageDate = averageStart; averageDate <= averageEnd; averageDate = averageDate.addDays(1)) {
               if (m_config.isConvertCurrency()) {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate) * it_row.key().baseCurrencyPrice(averageDate);
               } else {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate);
               }
               totalPrice = totalPrice.convert(10000);
             }
 
             MyMoneyMoney averagePrice = totalPrice / MyMoneyMoney((averageStart.daysTo(averageEnd) + 1), 1);
             MyMoneyMoney averageValue = it_row.value()[eActual][column] * averagePrice;
 
             //fill in the average
             it_row.value()[eAverage][column] = PivotCell(averageValue.convert(10000));
 
             ++column;
           }
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::fillBasePriceUnit(ERowType rowType)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QString baseCurrencyId = file->baseCurrency().id();
 
   //get the first price date for securities
   QMap<QString, QDate> securityDates = securityFirstPrice();
 
   //go through the data
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = m_startColumn;
 
         //if it is a base currency fill all the values
         bool firstPriceExists = false;
         if (it_row.key().currencyId() == baseCurrencyId) {
           firstPriceExists = true;
         }
 
         while (column < m_numColumns) {
           //check whether the date for that column is on or after the first price
           if (!firstPriceExists
               && securityDates.contains(it_row.key().currencyId())
               && columnDate(column) >= securityDates.value(it_row.key().currencyId())) {
             firstPriceExists = true;
           }
 
           //only add the dummy value if there is a price for that date
           if (firstPriceExists) {
             //insert a unit of currency for each account
             it_row.value()[rowType][column] = PivotCell(MyMoneyMoney::ONE);
           }
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 QMap<QString, QDate> PivotTable::securityFirstPrice()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyPriceList priceList = file->priceList();
   QMap<QString, QDate> securityPriceDate;
 
   MyMoneyPriceList::const_iterator prices_it;
   for (prices_it = priceList.constBegin(); prices_it != priceList.constEnd(); ++prices_it) {
     MyMoneyPrice firstPrice = (*((*prices_it).constBegin()));
 
     //check the security in the from field
     //if it is there, check if it is older
     if (securityPriceDate.contains(firstPrice.from())) {
       if (securityPriceDate.value(firstPrice.from()) > firstPrice.date()) {
         securityPriceDate[firstPrice.from()] = firstPrice.date();
       }
     } else {
       securityPriceDate.insert(firstPrice.from(), firstPrice.date());
     }
 
     //check the security in the to field
     //if it is there, check if it is older
     if (securityPriceDate.contains(firstPrice.to())) {
       if (securityPriceDate.value(firstPrice.to()) > firstPrice.date()) {
         securityPriceDate[firstPrice.to()] = firstPrice.date();
       }
     } else {
       securityPriceDate.insert(firstPrice.to(), firstPrice.date());
     }
   }
   return securityPriceDate;
 }
 
 void PivotTable::includeInvestmentSubAccounts()
 {
   // if we're not in expert mode, we need to make sure
   // that all stock accounts for the selected investment
   // account are also selected
   QStringList accountList;
   if (m_config.accounts(accountList)) {
     if (!KMyMoneySettings::expertMode()) {
       foreach (const auto sAccount, accountList) {
         auto acc = MyMoneyFile::instance()->account(sAccount);
         if (acc.accountType() == eMyMoney::Account::Type::Investment) {
           foreach (const auto sSubAccount, acc.accountList()) {
             if (!accountList.contains(sSubAccount)) {
               m_config.addAccount(sSubAccount);
             }
           }
         }
       }
     }
   }
 }
 
 int PivotTable::currentDateColumn()
 {
 
   //return -1 if the columns do not include the current date
   if (m_beginDate > QDate::currentDate() || m_endDate < QDate::currentDate()) {
     return -1;
   }
 
   //check the date of each column and return if it is the one for the current date
   //if columns are not days, return the one for the current month or year
   int column = m_startColumn;
 
   while (column < m_numColumns) {
     if (columnDate(column) >= QDate::currentDate()) {
       break;
     }
     column++;
   }
 
   //if there is no column matching the current date, return -1
   if (column == m_numColumns) {
     column = -1;
   }
   return column;
 }
 
 } // namespace
diff --git a/kmymoney/reports/querytable.cpp b/kmymoney/reports/querytable.cpp
index 3f67313b6..8bf1bda65 100644
--- a/kmymoney/reports/querytable.cpp
+++ b/kmymoney/reports/querytable.cpp
@@ -1,2168 +1,2168 @@
 /***************************************************************************
                           querytable.cpp
                          -------------------
     begin                : Fri Jul 23 2004
     copyright            : (C) 2004-2005 by Ace Jones <acejones@users.sourceforge.net>
                            (C) 2007 Sascha Pfau <MrPeacock@gmail.com>
                            (C) 2017 Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /****************************************************************************
   Contains code from the func_xirr and related methods of financial.cpp
   - KOffice 1.6 by Sascha Pfau.  Sascha agreed to relicense those methods under
   GPLv2 or later.
 *****************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "querytable.h"
 
 #include <cmath>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyreport.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "reportaccount.h"
 #include "mymoneyenums.h"
 
 namespace reports
 {
 
 // ****************************************************************************
 //
 // CashFlowListItem implementation
 //
 //   Cash flow analysis tools for investment reports
 //
 // ****************************************************************************
 
 QDate CashFlowListItem::m_sToday = QDate::currentDate();
 
 MyMoneyMoney CashFlowListItem::NPV(double _rate) const
 {
   double T = static_cast<double>(m_sToday.daysTo(m_date)) / 365.0;
   MyMoneyMoney result(m_value.toDouble() / pow(1 + _rate, T), 100);
 
   //qDebug() << "CashFlowListItem::NPV( " << _rate << " ) == " << result;
 
   return result;
 }
 
 // ****************************************************************************
 //
 // CashFlowList implementation
 //
 //   Cash flow analysis tools for investment reports
 //
 // ****************************************************************************
 
 CashFlowListItem CashFlowList::mostRecent() const
 {
   CashFlowList dupe(*this);
 
   qSort(dupe);
 
   //qDebug() << " CashFlowList::mostRecent() == " << dupe.back().date().toString(Qt::ISODate);
 
   return dupe.back();
 }
 
 MyMoneyMoney CashFlowList::NPV(double _rate) const
 {
   MyMoneyMoney result;
 
   const_iterator it_cash = constBegin();
   while (it_cash != constEnd()) {
     result += (*it_cash).NPV(_rate);
     ++it_cash;
   }
 
   //qDebug() << "CashFlowList::NPV( " << _rate << " ) == " << result << "------------------------" << endl;
 
   return result;
 }
 
 double CashFlowList::calculateXIRR() const
 {
   double resultRate = 0.00001;
 
   double resultZero = 0.00000;
   //if ( args.count() > 2 )
   //  resultRate = calc->conv()->asFloat ( args[2] ).asFloat();
 
 // check pairs and count >= 2 and guess > -1.0
   //if ( args[0].count() != args[1].count() || args[1].count() < 2 || resultRate <= -1.0 )
   //  return Value::errorVALUE();
 
 // define max epsilon
   static const double maxEpsilon = 1e-5;
 
 // max number of iterations
   static const int maxIter = 50;
 
 // Newton's method - try to find a res, with a accuracy of maxEpsilon
   double rateEpsilon, newRate, resultValue;
   int i = 0;
   bool contLoop;
 
   do {
     resultValue = xirrResult(resultRate);
 
     double resultDerive = xirrResultDerive(resultRate);
 
     //check what happens if xirrResultDerive is zero
     //Don't know if it is correct to dismiss the result
     if (resultDerive != 0) {
       newRate =  resultRate - resultValue / resultDerive;
     } else {
 
       newRate =  resultRate - resultValue;
     }
 
     rateEpsilon = fabs(newRate - resultRate);
 
     resultRate = newRate;
     contLoop = (rateEpsilon > maxEpsilon) && (fabs(resultValue) > maxEpsilon);
   } while (contLoop && (++i < maxIter));
 
   if (contLoop)
     return resultZero;
 
   return resultRate;
 }
 
 double CashFlowList::xirrResult(double& rate) const
 {
   QDate date;
 
   double r = rate + 1.0;
   double res = 0.00000;//back().value().toDouble();
 
   QList<CashFlowListItem>::const_iterator list_it = constBegin();
   while (list_it != constEnd()) {
     double e_i = ((* list_it).today().daysTo((* list_it).date())) / 365.0;
     MyMoneyMoney val = (* list_it).value();
 
     if (e_i < 0) {
       res += val.toDouble() * pow(r, -e_i);
     } else {
       res += val.toDouble() / pow(r, e_i);
     }
     ++list_it;
   }
 
   return res;
 }
 
 
 double CashFlowList::xirrResultDerive(double& rate) const
 {
   QDate date;
 
   double r = rate + 1.0;
   double res = 0.00000;
 
   QList<CashFlowListItem>::const_iterator list_it = constBegin();
   while (list_it != constEnd()) {
     double e_i = ((* list_it).today().daysTo((* list_it).date())) / 365.0;
     MyMoneyMoney val = (* list_it).value();
 
     res -= e_i * val.toDouble() / pow(r, e_i + 1.0);
     ++list_it;
   }
 
   return res;
 }
 
 double CashFlowList::IRR() const
 {
   double result = 0.0;
 
   // set 'today', which is the most recent of all dates in the list
   CashFlowListItem::setToday(mostRecent().date());
 
   result = calculateXIRR();
   return result;
 }
 
 MyMoneyMoney CashFlowList::total() const
 {
   MyMoneyMoney result;
 
   const_iterator it_cash = constBegin();
   while (it_cash != constEnd()) {
     result += (*it_cash).value();
     ++it_cash;
   }
 
   return result;
 }
 
 void CashFlowList::dumpDebug() const
 {
   const_iterator it_item = constBegin();
   while (it_item != constEnd()) {
     qDebug() << (*it_item).date().toString(Qt::ISODate) << " " << (*it_item).value().toString();
     ++it_item;
   }
 }
 
 // ****************************************************************************
 //
 // QueryTable implementation
 //
 // ****************************************************************************
 
 /**
   * TODO
   *
   * - Collapse 2- & 3- groups when they are identical
   * - Way more test cases (especially splits & transfers)
   * - Option to collapse splits
   * - Option to exclude transfers
   *
   */
 
 QueryTable::QueryTable(const MyMoneyReport& _report): ListTable(_report)
 {
   // separated into its own method to allow debugging (setting breakpoints
   // directly in ctors somehow does not work for me (ipwizard))
   // TODO: remove the init() method and move the code back to the ctor
   init();
 }
 
 void QueryTable::init()
 {
   m_columns.clear();
   m_group.clear();
   m_subtotal.clear();
   m_postcolumns.clear();
   switch (m_config.rowType()) {
     case MyMoneyReport::eAccountByTopAccount:
     case MyMoneyReport::eEquityType:
     case MyMoneyReport::eAccountType:
     case MyMoneyReport::eInstitution:
       constructAccountTable();
       m_columns << ctAccount;
       break;
 
     case MyMoneyReport::eAccount:
       constructTransactionTable();
       m_columns << ctAccountID << ctPostDate;
       break;
 
     case MyMoneyReport::ePayee:
     case MyMoneyReport::eTag:
     case MyMoneyReport::eMonth:
     case MyMoneyReport::eWeek:
       constructTransactionTable();
       m_columns << ctPostDate << ctAccount;
       break;
     case MyMoneyReport::eCashFlow:
       constructSplitsTable();
       m_columns << ctPostDate;
       break;
     default:
       constructTransactionTable();
       m_columns << ctPostDate;
   }
 
   // Sort the data to match the report definition
   m_subtotal << ctValue;
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eCashFlow:
       m_group << ctCategoryType << ctTopCategory << ctCategory;
       break;
     case MyMoneyReport::eCategory:
       m_group << ctCategoryType << ctTopCategory << ctCategory;
       break;
     case MyMoneyReport::eTopCategory:
       m_group << ctCategoryType << ctTopCategory;
       break;
     case MyMoneyReport::eTopAccount:
       m_group << ctTopAccount << ctAccount;
       break;
     case MyMoneyReport::eAccount:
       m_group << ctAccount;
       break;
     case MyMoneyReport::eAccountReconcile:
       m_group << ctAccount << ctReconcileFlag;
       break;
     case MyMoneyReport::ePayee:
       m_group << ctPayee;
       break;
     case MyMoneyReport::eTag:
       m_group << ctTag;
       break;
     case MyMoneyReport::eMonth:
       m_group << ctMonth;
       break;
     case MyMoneyReport::eWeek:
       m_group << ctWeek;
       break;
     case MyMoneyReport::eAccountByTopAccount:
       m_group << ctTopAccount;
       break;
     case MyMoneyReport::eEquityType:
       m_group << ctEquityType;
       break;
     case MyMoneyReport::eAccountType:
       m_group << ctType;
       break;
     case MyMoneyReport::eInstitution:
       m_group << ctInstitution << ctTopAccount;
       break;
     default:
-      throw MYMONEYEXCEPTION("QueryTable::QueryTable(): unhandled row type");
+      throw MYMONEYEXCEPTION_CSTRING("QueryTable::QueryTable(): unhandled row type");
   }
 
   QVector<cellTypeE> sort = QVector<cellTypeE>::fromList(m_group) << QVector<cellTypeE>::fromList(m_columns) << ctID << ctRank;
 
   m_columns.clear();
   switch (m_config.rowType()) {
     case MyMoneyReport::eAccountByTopAccount:
     case MyMoneyReport::eEquityType:
     case MyMoneyReport::eAccountType:
     case MyMoneyReport::eInstitution:
       m_columns << ctAccount;
       break;
 
     default:
       m_columns << ctPostDate;
   }
 
   unsigned qc = m_config.queryColumns();
 
   if (qc & MyMoneyReport::eQCnumber)
     m_columns << ctNumber;
   if (qc & MyMoneyReport::eQCpayee)
     m_columns << ctPayee;
   if (qc & MyMoneyReport::eQCtag)
     m_columns << ctTag;
   if (qc & MyMoneyReport::eQCcategory)
     m_columns << ctCategory;
   if (qc & MyMoneyReport::eQCaccount)
     m_columns << ctAccount;
   if (qc & MyMoneyReport::eQCreconciled)
     m_columns << ctReconcileFlag;
   if (qc & MyMoneyReport::eQCmemo)
     m_columns << ctMemo;
   if (qc & MyMoneyReport::eQCaction)
     m_columns << ctAction;
   if (qc & MyMoneyReport::eQCshares)
     m_columns << ctShares;
   if (qc & MyMoneyReport::eQCprice)
     m_columns << ctPrice;
   if (qc & MyMoneyReport::eQCperformance) {
     m_subtotal.clear();
     switch (m_config.investmentSum()) {
       case MyMoneyReport::eSumOwnedAndSold:
         m_columns << ctBuys << ctSells << ctReinvestIncome << ctCashIncome
                   << ctEndingBalance << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctSells << ctReinvestIncome << ctCashIncome
                    << ctEndingBalance << ctReturn << ctReturnInvestment;
         break;
       case MyMoneyReport::eSumOwned:
         m_columns << ctBuys << ctReinvestIncome << ctMarketValue
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctReinvestIncome << ctMarketValue
                    << ctReturn << ctReturnInvestment;
         break;
       case MyMoneyReport::eSumSold:
         m_columns << ctBuys << ctSells << ctCashIncome
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctSells << ctCashIncome
                    << ctReturn << ctReturnInvestment;
         break;
       case MyMoneyReport::eSumPeriod:
       default:
         m_columns << ctStartingBalance << ctBuys << ctSells
                   << ctReinvestIncome << ctCashIncome << ctEndingBalance
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctStartingBalance << ctBuys << ctSells
                    << ctReinvestIncome << ctCashIncome << ctEndingBalance
                    << ctReturn << ctReturnInvestment;
         break;
     }
   }
   if (qc & MyMoneyReport::eQCcapitalgain) {
     m_subtotal.clear();
     switch (m_config.investmentSum()) {
       case MyMoneyReport::eSumOwned:
         m_columns << ctShares << ctBuyPrice << ctLastPrice
                   << ctBuys << ctMarketValue << ctPercentageGain
                   << ctCapitalGain;
         m_subtotal << ctShares << ctBuyPrice << ctLastPrice
                    << ctBuys << ctMarketValue << ctPercentageGain
                    << ctCapitalGain;
         break;
       case MyMoneyReport::eSumSold:
       default:
         m_columns << ctBuys << ctSells << ctCapitalGain;
         m_subtotal << ctBuys << ctSells << ctCapitalGain;
         if (m_config.isShowingSTLTCapitalGains()) {
           m_columns << ctBuysST << ctSellsST << ctCapitalGainST
                     << ctBuysLT << ctSellsLT << ctCapitalGainLT;
           m_subtotal << ctBuysST << ctSellsST << ctCapitalGainST
                      << ctBuysLT << ctSellsLT << ctCapitalGainLT;
         }
         break;
     }
   }
   if (qc & MyMoneyReport::eQCloan) {
     m_columns << ctPayment << ctInterest << ctFees;
     m_postcolumns << ctBalance;
   }
   if (qc & MyMoneyReport::eQCbalance)
     m_postcolumns << ctBalance;
 
   TableRow::setSortCriteria(sort);
   qSort(m_rows);
   if (m_config.isShowingColumnTotals())
     constructTotalRows(); // adds total rows to m_rows
 }
 
 void QueryTable::constructTotalRows()
 {
   if (m_rows.isEmpty())
     return;
 
   // qSort places grand total at last position, because it doesn't belong to any group
   for (int i = 0; i < m_rows.count(); ++i) {
     if (m_rows.at(0)[ctRank] == QLatin1String("4") || m_rows.at(0)[ctRank] == QLatin1String("5")) // it should be unlikely that total row is at the top of rows, so...
       m_rows.move(0, m_rows.count() - 1 - i);                       // ...move it at the bottom
     else
       break;
   }
 
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<cellTypeE> subtotals = m_subtotal;
   QList<cellTypeE> groups = m_group;
   QList<cellTypeE> columns = m_columns;
   if (!m_subtotal.isEmpty() && subtotals.count() == 1)
     columns.append(m_subtotal);
   QList<cellTypeE> postcolumns = m_postcolumns;
   if (!m_postcolumns.isEmpty())
     columns.append(postcolumns);
 
   QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>> totalCurrency;
   QList<QMap<cellTypeE, MyMoneyMoney>> totalGroups;
   QMap<cellTypeE, MyMoneyMoney> totalsValues;
 
   // initialize all total values under summed columns to be zero
   foreach (auto subtotal, subtotals) {
     totalsValues.insert(subtotal, MyMoneyMoney());
   }
   totalsValues.insert(ctRowsCount, MyMoneyMoney());
 
   // create total groups containing totals row for each group
   totalGroups.append(totalsValues);  // prepend with extra group for grand total
   for (int j = 0; j < groups.count(); ++j) {
     totalGroups.append(totalsValues);
   }
 
   QList<TableRow> stashedTotalRows;
   int iCurrentRow, iNextRow;
   for (iCurrentRow = 0; iCurrentRow < m_rows.count();) {
     iNextRow = iCurrentRow + 1;
 
     // total rows are useless at summing so remove whole block of them at once
     while (iNextRow != m_rows.count() && (m_rows.at(iNextRow).value(ctRank) == QLatin1String("4") || m_rows.at(iNextRow).value(ctRank) == QLatin1String("5"))) {
       stashedTotalRows.append(m_rows.takeAt(iNextRow)); // ...but stash them just in case
     }
 
     bool lastRow = (iNextRow == m_rows.count());
 
     // sum all subtotal values for lowest group
     QString currencyID = m_rows.at(iCurrentRow).value(ctCurrency);
     if (m_rows.at(iCurrentRow).value(ctRank) == QLatin1String("1")) { // don't sum up on balance (rank = 0 || rank = 3) and minor split (rank = 2)
       foreach (auto subtotal, subtotals) {
         if (!totalCurrency.contains(currencyID))
           totalCurrency[currencyID].append(totalGroups);
         totalCurrency[currencyID].last()[subtotal] += MyMoneyMoney(m_rows.at(iCurrentRow)[subtotal]);
       }
       totalCurrency[currencyID].last()[ctRowsCount] += MyMoneyMoney::ONE;
     }
 
     // iterate over groups from the lowest to the highest to find group change
     for (int i = groups.count() - 1; i >= 0 ; --i) {
       // if any of groups from next row changes (or next row is the last row), then it's time to put totals row
       if (lastRow || m_rows.at(iCurrentRow)[groups.at(i)] != m_rows.at(iNextRow)[groups.at(i)]) {
         bool isMainCurrencyTotal = true;
         QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>>::iterator currencyGrp = totalCurrency.begin();
         while (currencyGrp != totalCurrency.end()) {
           if (!MyMoneyMoney((*currencyGrp).at(i + 1).value(ctRowsCount)).isZero()) {    // if no rows summed up, then no totals row
             TableRow totalsRow;
             // sum all subtotal values for higher groups (excluding grand total) and reset lowest group values
             QMap<cellTypeE, MyMoneyMoney>::iterator upperGrp = (*currencyGrp)[i].begin();
             QMap<cellTypeE, MyMoneyMoney>::iterator lowerGrp = (*currencyGrp)[i + 1].begin();
 
             while(upperGrp != (*currencyGrp)[i].end()) {
               totalsRow[lowerGrp.key()] = lowerGrp.value().toString();  // fill totals row with subtotal values...
               (*upperGrp) += (*lowerGrp);
               //          (*lowerGrp) = MyMoneyMoney();
               ++upperGrp;
               ++lowerGrp;
             }
 
             // custom total values calculations
             foreach (auto subtotal, subtotals) {
               if (subtotal == ctReturnInvestment)
                 totalsRow[subtotal] = helperROI((*currencyGrp).at(i + 1).value(ctBuys) - (*currencyGrp).at(i + 1).value(ctReinvestIncome), (*currencyGrp).at(i + 1).value(ctSells),
                                                 (*currencyGrp).at(i + 1).value(ctStartingBalance), (*currencyGrp).at(i + 1).value(ctEndingBalance) + (*currencyGrp).at(i + 1).value(ctMarketValue),
                                                 (*currencyGrp).at(i + 1).value(ctCashIncome)).toString();
               else if (subtotal == ctPercentageGain)
                 totalsRow[subtotal] = (((*currencyGrp).at(i + 1).value(ctBuys) + (*currencyGrp).at(i + 1).value(ctMarketValue)) / (*currencyGrp).at(i + 1).value(ctBuys).abs()).toString();
               else if (subtotal == ctPrice)
                 totalsRow[subtotal] = MyMoneyMoney((*currencyGrp).at(i + 1).value(ctPrice) / (*currencyGrp).at(i + 1).value(ctRowsCount)).toString();
             }
 
             // total values that aren't calculated here, but are taken untouched from external source, e.g. constructPerformanceRow
             if (!stashedTotalRows.isEmpty()) {
               for (int j = 0; j < stashedTotalRows.count(); ++j) {
                 if (stashedTotalRows.at(j).value(ctCurrency) != currencyID)
                   continue;
                 foreach (auto subtotal, subtotals) {
                   if (subtotal == ctReturn)
                     totalsRow[ctReturn] = stashedTotalRows.takeAt(j)[ctReturn];
                 }
                 break;
               }
             }
 
             (*currencyGrp).replace(i + 1, totalsValues);
             for (int j = 0; j < groups.count(); ++j) {
               totalsRow[groups.at(j)] = m_rows.at(iCurrentRow)[groups.at(j)];   // ...and identification
             }
 
             currencyID = currencyGrp.key();
             if (currencyID.isEmpty() && totalCurrency.count() > 1)
               currencyID = file->baseCurrency().id();
             totalsRow[ctCurrency] = currencyID;
             if (isMainCurrencyTotal) {
               totalsRow[ctRank] = QLatin1Char('4');
               isMainCurrencyTotal = false;
             } else
               totalsRow[ctRank] = QLatin1Char('5');
             totalsRow[ctDepth] = QString::number(i);
             totalsRow.remove(ctRowsCount);
 
             m_rows.insert(iNextRow++, totalsRow);  // iCurrentRow and iNextRow can diverge here by more than one
           }
           ++currencyGrp;
         }
       }
     }
 
     // code to put grand total row
     if (lastRow) {
       bool isMainCurrencyTotal = true;
       QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>>::iterator currencyGrp = totalCurrency.begin();
       while (currencyGrp != totalCurrency.end()) {
         TableRow totalsRow;
         QMap<cellTypeE, MyMoneyMoney>::const_iterator grandTotalGrp = (*currencyGrp)[0].constBegin();
         while(grandTotalGrp != (*currencyGrp)[0].constEnd()) {
           totalsRow[grandTotalGrp.key()] = grandTotalGrp.value().toString();
           ++grandTotalGrp;
         }
 
         foreach (auto subtotal, subtotals) {
           if (subtotal == ctReturnInvestment)
             totalsRow[subtotal] = helperROI((*currencyGrp).at(0).value(ctBuys) - (*currencyGrp).at(0).value(ctReinvestIncome), (*currencyGrp).at(0).value(ctSells),
                                             (*currencyGrp).at(0).value(ctStartingBalance), (*currencyGrp).at(0).value(ctEndingBalance) + (*currencyGrp).at(0).value(ctMarketValue),
                                             (*currencyGrp).at(0).value(ctCashIncome)).toString();
           else if (subtotal == ctPercentageGain)
             totalsRow[subtotal] = (((*currencyGrp).at(0).value(ctBuys) + (*currencyGrp).at(0).value(ctMarketValue)) / (*currencyGrp).at(0).value(ctBuys).abs()).toString();
           else if (subtotal == ctPrice)
             totalsRow[subtotal] = MyMoneyMoney((*currencyGrp).at(0).value(ctPrice) / (*currencyGrp).at(0).value(ctRowsCount)).toString();
         }
 
         if (!stashedTotalRows.isEmpty()) {
           for (int j = 0; j < stashedTotalRows.count(); ++j) {
             foreach (auto subtotal, subtotals) {
               if (subtotal == ctReturn)
                 totalsRow[ctReturn] = stashedTotalRows.takeAt(j)[ctReturn];
             }
           }
         }
 
         for (int j = 0; j < groups.count(); ++j) {
           totalsRow[groups.at(j)] = QString();      // no identification
         }
 
         currencyID = currencyGrp.key();
         if (currencyID.isEmpty() && totalCurrency.count() > 1)
           currencyID = file->baseCurrency().id();
         totalsRow[ctCurrency] = currencyID;
         if (isMainCurrencyTotal) {
           totalsRow[ctRank] = QLatin1Char('4');
           isMainCurrencyTotal = false;
         } else
           totalsRow[ctRank] = QLatin1Char('5');
         totalsRow[ctDepth] = QString();
 
         m_rows.append(totalsRow);
         ++currencyGrp;
       }
       break;                                      // no use to loop further
     }
     iCurrentRow = iNextRow;                             // iCurrent makes here a leap forward by at least one
   }
 }
 
 void QueryTable::constructTransactionTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   MyMoneyReport report(m_config);
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
 
   bool use_transfers;
   bool use_summary;
   bool hide_details;
   bool tag_special_case = false;
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eCategory:
     case MyMoneyReport::eTopCategory:
       use_summary = false;
       use_transfers = false;
       hide_details = false;
       break;
     case MyMoneyReport::ePayee:
       use_summary = false;
       use_transfers = false;
       hide_details = (m_config.detailLevel() == MyMoneyReport::eDetailNone);
       break;
     case MyMoneyReport::eTag:
       use_summary = false;
       use_transfers = false;
       hide_details = (m_config.detailLevel() == MyMoneyReport::eDetailNone);
       tag_special_case = true;
       break;
     default:
       use_summary = true;
       use_transfers = true;
       hide_details = (m_config.detailLevel() == MyMoneyReport::eDetailNone);
       break;
   }
 
   // support for opening and closing balances
   QMap<QString, MyMoneyAccount> accts;
 
   //get all transactions for this report
   QList<MyMoneyTransaction> transactions = file->transactionList(report);
   for (QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin(); it_transaction != transactions.constEnd(); ++it_transaction) {
 
     TableRow qA, qS;
     QDate pd;
     QList<QString> tagIdListCache;
 
     qA[ctID] = qS[ctID] = (* it_transaction).id();
     qA[ctEntryDate] = qS[ctEntryDate] = (* it_transaction).entryDate().toString(Qt::ISODate);
     qA[ctPostDate] = qS[ctPostDate] = (* it_transaction).postDate().toString(Qt::ISODate);
     qA[ctCommodity] = qS[ctCommodity] = (* it_transaction).commodity();
 
     pd = (* it_transaction).postDate();
     qA[ctMonth] = qS[ctMonth] = i18n("Month of %1", QDate(pd.year(), pd.month(), 1).toString(Qt::ISODate));
     qA[ctWeek] = qS[ctWeek] = i18n("Week of %1", pd.addDays(1 - pd.dayOfWeek()).toString(Qt::ISODate));
 
     if (!m_containsNonBaseCurrency && (*it_transaction).commodity() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (report.isConvertCurrency())
       qA[ctCurrency] = qS[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = qS[ctCurrency] = (*it_transaction).commodity();
 
     // to handle splits, we decide on which account to base the split
     // (a reference point or point of view so to speak). here we take the
     // first account that is a stock account or loan account (or the first account
     // that is not an income or expense account if there is no stock or loan account)
     // to be the account (qA) that will have the sub-item "split" entries. we add
     // one transaction entry (qS) for each subsequent entry in the split.
 
     const QList<MyMoneySplit>& splits = (*it_transaction).splits();
     QList<MyMoneySplit>::const_iterator myBegin, it_split;
 
     for (it_split = splits.constBegin(), myBegin = splits.constEnd(); it_split != splits.constEnd(); ++it_split) {
       ReportAccount splitAcc((* it_split).accountId());
       // always put split with a "stock" account if it exists
       if (splitAcc.isInvest())
         break;
 
       // prefer to put splits with a "loan" account if it exists
       if (splitAcc.isLoan())
         myBegin = it_split;
 
       if ((myBegin == splits.end()) && ! splitAcc.isIncomeExpense()) {
         myBegin = it_split;
       }
     }
 
     // select our "reference" split
     if (it_split == splits.end()) {
       it_split = myBegin;
     } else {
       myBegin = it_split;
     }
 
     // skip this transaction if we didn't find a valid base account - see the above description
     // for the base account's description - if we don't find it avoid a crash by skipping the transaction
     if (myBegin == splits.end())
       continue;
 
     // if the split is still unknown, use the first one. I have seen this
     // happen with a transaction that has only a single split referencing an income or expense
     // account and has an amount and value of 0. Such a transaction will fall through
     // the above logic and leave 'it_split' pointing to splits.end() which causes the remainder
     // of this to end in an infinite loop.
     if (it_split == splits.end()) {
       it_split = splits.begin();
     }
 
     // for "loan" reports, the loan transaction gets special treatment.
     // the splits of a loan transaction are placed on one line in the
     // reference (loan) account (qA). however, we process the matching
     // split entries (qS) normally.
 
     bool loan_special_case = false;
     if (m_config.queryColumns() & MyMoneyReport::eQCloan) {
       ReportAccount splitAcc((*it_split).accountId());
       loan_special_case = splitAcc.isLoan();
     }
 
     bool include_me = true;
     bool transaction_text = false; //indicates whether a text should be considered as a match for the transaction or for a split only
     QString a_fullname;
     QString a_memo;
     int pass = 1;
 
     QString myBeginCurrency;
     QString baseCurrency = file->baseCurrency().id();
 
     QMap<QString, MyMoneyMoney> xrMap; // container for conversion rates from given currency to myBeginCurrency
     do {
       MyMoneyMoney xr;
       ReportAccount splitAcc((* it_split).accountId());
       QString splitCurrency;
       if (splitAcc.isInvest())
         splitCurrency = file->account(file->account((*it_split).accountId()).parentAccountId()).currencyId();
       else
         splitCurrency = file->account((*it_split).accountId()).currencyId();
       if (it_split == myBegin)
         myBeginCurrency = splitCurrency;
 
       //get fraction for account
       int fraction = splitAcc.currency().smallestAccountFraction();
 
       //use base currency fraction if not initialized
       if (fraction == -1)
         fraction = file->baseCurrency().smallestAccountFraction();
 
       QString institution = splitAcc.institutionId();
       QString payee = (*it_split).payeeId();
 
       const QList<QString> tagIdList = (*it_split).tagIdList();
 
       //convert to base currency
       if (m_config.isConvertCurrency()) {
         xr = xrMap.value(splitCurrency, xr);  // check if there is conversion rate to myBeginCurrency already stored...
         if (xr == MyMoneyMoney())             // ...if not...
             xr = (*it_split).price();         // ...take conversion rate to myBeginCurrency from split
         else if (splitAcc.isInvest())         // if it's stock split...
           xr *= (*it_split).price();          // ...multiply it by stock price stored in split
 
         if (!m_containsNonBaseCurrency && myBeginCurrency != baseCurrency)
           m_containsNonBaseCurrency = true;
         if (myBeginCurrency != baseCurrency) {                             // myBeginCurrency can differ from baseCurrency...
           MyMoneyPrice price = file->price(myBeginCurrency, baseCurrency,
                                            (*it_transaction).postDate());  // ...so check conversion rate...
           if (price.isValid()) {
             xr *= price.rate(baseCurrency);                                // ...and multiply it by current price...
             qA[ctCurrency] = qS[ctCurrency] = baseCurrency;
           } else
             qA[ctCurrency] = qS[ctCurrency] = myBeginCurrency;             // ...and set information about non-baseCurrency
         }
       } else if (splitAcc.isInvest())
         xr = (*it_split).price();
       else
         xr = MyMoneyMoney::ONE;
 
       if (it_split == myBegin) {
         include_me = m_config.includes(splitAcc);
         if (include_me)
           // track accts that will need opening and closing balances
           //FIXME in some cases it will show the opening and closing
           //balances but no transactions if the splits are all filtered out -- asoliverez
           accts.insert(splitAcc.id(), splitAcc);
 
         qA[ctAccount] = splitAcc.name();
         qA[ctAccountID] = splitAcc.id();
         qA[ctTopAccount] = splitAcc.topParentName();
 
         if (splitAcc.isInvest()) {
           // use the institution of the parent for stock accounts
           institution = splitAcc.parent().institutionId();
           MyMoneyMoney shares = (*it_split).shares();
 
           int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
           qA[ctAction] = (*it_split).action();
           qA[ctShares] = shares.isZero() ? QString() : shares.toString();
           qA[ctPrice] = shares.isZero() ? QString() : xr.convertPrecision(pricePrecision).toString();
 
           if (((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) && shares.isNegative())
             qA[ctAction] = "Sell";
 
           qA[ctInvestAccount] = splitAcc.parent().name();
 
           MyMoneySplit stockSplit = (*it_split);
           MyMoneySplit assetAccountSplit;
           QList<MyMoneySplit> feeSplits;
           QList<MyMoneySplit> interestSplits;
           MyMoneySecurity currency;
           MyMoneySecurity security;
           eMyMoney::Split::InvestmentTransactionType transactionType;
           KMyMoneyUtils::dissectTransaction((*it_transaction), stockSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
           if (!(assetAccountSplit == MyMoneySplit())) {
             for (it_split = splits.begin(); it_split != splits.end(); ++it_split) {
               if ((*it_split) == assetAccountSplit) {
                 splitAcc = ReportAccount(assetAccountSplit.accountId()); // switch over from stock split to asset split because amount in stock split doesn't take fees/interests into account
                 myBegin = it_split;                       // set myBegin to asset split, so stock split can be listed in details under splits
                 myBeginCurrency = (file->account((*myBegin).accountId())).currencyId();
                 if (!m_containsNonBaseCurrency && myBeginCurrency != baseCurrency)
                   m_containsNonBaseCurrency = true;
                 if (m_config.isConvertCurrency()) {
                   if (myBeginCurrency != baseCurrency) {
                     MyMoneyPrice price = file->price(myBeginCurrency, baseCurrency, (*it_transaction).postDate());
                     if (price.isValid()) {
                       xr = price.rate(baseCurrency);
                       qA[ctCurrency] = qS[ctCurrency] = baseCurrency;
                     } else
                       qA[ctCurrency] = qS[ctCurrency] = myBeginCurrency;
                   } else
                     xr = MyMoneyMoney::ONE;
 
                   qA[ctPrice] = shares.isZero() ? QString() : (stockSplit.price() * xr / (*it_split).price()).toString();
                   // put conversion rate for all splits with this currency, so...
                   // every split of transaction have the same conversion rate
                   xrMap.insert(splitCurrency, MyMoneyMoney::ONE / (*it_split).price());
                 } else
                   xr = (*it_split).price();
                 break;
               }
             }
           }
         } else
           qA[ctPrice] = xr.toString();
 
         a_fullname = splitAcc.fullName();
         a_memo = (*it_split).memo();
 
         transaction_text = m_config.match((*it_split));
 
         qA[ctInstitution] = institution.isEmpty()
                             ? i18n("No Institution")
                             : file->institution(institution).name();
 
         qA[ctPayee] = payee.isEmpty()
                       ? i18n("[Empty Payee]")
                       : file->payee(payee).name().simplified();
 
         if (tag_special_case) {
           tagIdListCache = tagIdList;
         } else {
           QString delimiter;
           foreach(const auto tagId, tagIdList) {
             qA[ctTag] += delimiter + file->tag(tagId).name().simplified();
             delimiter = QLatin1Char(',');
           }
         }
         qA[ctReconcileDate] = (*it_split).reconcileDate().toString(Qt::ISODate);
         qA[ctReconcileFlag] = KMyMoneyUtils::reconcileStateToString((*it_split).reconcileFlag(), true);
         qA[ctNumber] = (*it_split).number();
 
         qA[ctMemo] = a_memo;
 
         qA[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
 
         qS[ctReconcileDate] = qA[ctReconcileDate];
         qS[ctReconcileFlag] = qA[ctReconcileFlag];
         qS[ctNumber] = qA[ctNumber];
 
         qS[ctTopCategory] = splitAcc.topParentName();
         qS[ctCategoryType] = i18n("Transfer");
 
         // only include the configured accounts
         if (include_me) {
 
           if (loan_special_case) {
 
             // put the principal amount in the "value" column and convert to lowest fraction
             qA[ctValue] = (-(*it_split).shares() * xr).convert(fraction).toString();
 
             qA[ctRank] = QLatin1Char('1');
             qA[ctSplit].clear();
 
           } else {
             if ((splits.count() > 2) && use_summary) {
 
               // add the "summarized" split transaction
               // this is the sub-total of the split detail
               // convert to lowest fraction
               qA[ctRank] = QLatin1Char('1');
               qA[ctCategory] = i18n("[Split Transaction]");
               qA[ctTopCategory] = i18nc("Split transaction", "Split");
               qA[ctCategoryType] = i18nc("Split transaction", "Split");
 
               m_rows += qA;
             }
           }
         }
 
       } else {
 
         if (include_me) {
 
           if (loan_special_case) {
             MyMoneyMoney value = (-(* it_split).shares() * xr).convert(fraction);
 
             if ((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization)) {
               // put the payment in the "payment" column and convert to lowest fraction
               qA[ctPayee] = value.toString();
             } else if ((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
               // put the interest in the "interest" column and convert to lowest fraction
               qA[ctInterest] = value.toString();
             } else if (splits.count() > 2) {
               // [dv: This comment carried from the original code. I am
               // not exactly clear on what it means or why we do this.]
               // Put the initial pay-in nowhere (that is, ignore it). This
               // is dangerous, though. The only way I can tell the initial
               // pay-in apart from fees is if there are only 2 splits in
               // the transaction.  I wish there was a better way.
             } else {
               // accumulate everything else in the "fees" column
               MyMoneyMoney n0 = MyMoneyMoney(qA[ctFees]);
               qA[ctFees] = (n0 + value).toString();
             }
             // we don't add qA here for a loan transaction. we'll add one
             // qA afer all of the split components have been processed.
             // (see below)
 
           }
 
           //--- special case to hide split transaction details
           else if (hide_details && (splits.count() > 2)) {
             // essentially, don't add any qA entries
           }
           //--- default case includes all transaction details
           else {
 
             //this is when the splits are going to be shown as children of the main split
             if ((splits.count() > 2) && use_summary) {
               qA[ctValue].clear();
 
               //convert to lowest fraction
               qA[ctSplit] = (-(*it_split).shares() * xr).convert(fraction).toString();
               qA[ctRank] = QLatin1Char('2');
             } else {
               //this applies when the transaction has only 2 splits, or each split is going to be
               //shown separately, eg. transactions by category
               switch (m_config.rowType()) {
                 case MyMoneyReport::eCategory:
                 case MyMoneyReport::eTopCategory:
                   if (splitAcc.isIncomeExpense())
                     qA[ctValue] = (-(*it_split).shares() * xr).convert(fraction).toString(); // needed for category reports, in case of multicurrency transaction it breaks it
                   break;
                 default:
                   break;
               }
               qA[ctSplit].clear();
               qA[ctRank] = QLatin1Char('1');
             }
 
             qA [ctMemo] = (*it_split).memo();
 
             if (!m_containsNonBaseCurrency && splitAcc.currencyId() != file->baseCurrency().id())
               m_containsNonBaseCurrency = true;
             if (report.isConvertCurrency())
               qS[ctCurrency] = file->baseCurrency().id();
             else
               qS[ctCurrency] = splitAcc.currency().id();
 
             if (! splitAcc.isIncomeExpense()) {
               qA[ctCategory] = ((*it_split).shares().isNegative()) ?
                                i18n("Transfer from %1", splitAcc.fullName())
                                : i18n("Transfer to %1", splitAcc.fullName());
               qA[ctTopCategory] = splitAcc.topParentName();
               qA[ctCategoryType] = i18n("Transfer");
             } else {
               qA [ctCategory] = splitAcc.fullName();
               qA [ctTopCategory] = splitAcc.topParentName();
               qA [ctCategoryType] = MyMoneyAccount::accountTypeToString(splitAcc.accountGroup());
             }
 
             if (use_transfers || (splitAcc.isIncomeExpense() && m_config.includes(splitAcc))) {
               //if it matches the text of the main split of the transaction or
               //it matches this particular split, include it
               //otherwise, skip it
               //if the filter is "does not contain" exclude the split if it does not match
               //even it matches the whole split
               if ((m_config.isInvertingText() &&
                    m_config.match((*it_split)))
                   || (!m_config.isInvertingText()
                       && (transaction_text
                           || m_config.match((*it_split))))) {
                 if (tag_special_case) {
                   if (!tagIdListCache.size())
                     qA[ctTag] = i18n("[No Tag]");
                   else
                     for (int i = 0; i < tagIdListCache.size(); i++) {
                       qA[ctTag] = file->tag(tagIdListCache[i]).name().simplified();
                       m_rows += qA;
                     }
                 } else {
                   m_rows += qA;
                 }
               }
             }
           }
         }
 
         if (m_config.includes(splitAcc) && use_transfers &&
             !(splitAcc.isInvest() && include_me)) { // otherwise stock split is displayed twice in report
           if (! splitAcc.isIncomeExpense()) {
             //multiply by currency and convert to lowest fraction
             qS[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
 
             qS[ctRank] = QLatin1Char('1');
 
             qS[ctAccount] = splitAcc.name();
             qS[ctAccountID] = splitAcc.id();
             qS[ctTopAccount] = splitAcc.topParentName();
 
             qS[ctCategory] = ((*it_split).shares().isNegative())
                              ? i18n("Transfer to %1", a_fullname)
                              : i18n("Transfer from %1", a_fullname);
 
             qS[ctInstitution] = institution.isEmpty()
                                 ? i18n("No Institution")
                                 : file->institution(institution).name();
 
             qS[ctMemo] = (*it_split).memo().isEmpty()
                          ? a_memo
                          : (*it_split).memo();
 
             //FIXME-ALEX When is used this? I can't find in which condition we arrive here... maybe this code is useless?
             QString delimiter;
             for (int i = 0; i < tagIdList.size(); i++) {
               qA[ctTag] += delimiter + file->tag(tagIdList[i]).name().simplified();
               delimiter = '+';
             }
 
             qS[ctPayee] = payee.isEmpty()
                           ? qA[ctPayee]
                           : file->payee(payee).name().simplified();
 
             //check the specific split against the filter for text and amount
             //TODO this should be done at the engine, but I have no clear idea how -- asoliverez
             //if the filter is "does not contain" exclude the split if it does not match
             //even it matches the whole split
             if ((m_config.isInvertingText() &&
                  m_config.match((*it_split)))
                 || (!m_config.isInvertingText()
                     && (transaction_text
                         || m_config.match((*it_split))))) {
               m_rows += qS;
 
               // track accts that will need opening and closing balances
               accts.insert(splitAcc.id(), splitAcc);
             }
           }
         }
       }
 
       ++it_split;
 
       // look for wrap-around
       if (it_split == splits.end())
         it_split = splits.begin();
 
       // but terminate if this transaction has only a single split
       if (splits.count() < 2)
         break;
 
       //check if there have been more passes than there are splits
       //this is to prevent infinite loops in cases of data inconsistency -- asoliverez
       ++pass;
       if (pass > splits.count())
         break;
 
     } while (it_split != myBegin);
     if (loan_special_case) {
       m_rows += qA;
     }
   }
 
   // now run through our accts list and add opening and closing balances
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eAccount:
     case MyMoneyReport::eTopAccount:
       break;
 
       // case MyMoneyReport::eCategory:
       // case MyMoneyReport::eTopCategory:
       // case MyMoneyReport::ePayee:
       // case MyMoneyReport::eMonth:
       // case MyMoneyReport::eWeek:
     default:
       return;
   }
 
   QDate startDate, endDate;
 
   report.validDateRange(startDate, endDate);
   QString strStartDate = startDate.toString(Qt::ISODate);
   QString strEndDate = endDate.toString(Qt::ISODate);
   startDate = startDate.addDays(-1);
 
   QMap<QString, MyMoneyAccount>::const_iterator it_account, accts_end;
   for (it_account = accts.constBegin(); it_account != accts.constEnd(); ++it_account) {
     TableRow qA;
 
     ReportAccount account(*it_account);
 
     //get fraction for account
     int fraction = account.currency().smallestAccountFraction();
 
     //use base currency fraction if not initialized
     if (fraction == -1)
       fraction = file->baseCurrency().smallestAccountFraction();
 
     QString institution = account.institutionId();
 
     // use the institution of the parent for stock accounts
     if (account.isInvest())
       institution = account.parent().institutionId();
 
     MyMoneyMoney startBalance, endBalance, startPrice, endPrice;
     MyMoneyMoney startShares, endShares;
 
     //get price and convert currency if necessary
     if (m_config.isConvertCurrency()) {
       startPrice = (account.deepCurrencyPrice(startDate) * account.baseCurrencyPrice(startDate)).reduce();
       endPrice = (account.deepCurrencyPrice(endDate) * account.baseCurrencyPrice(endDate)).reduce();
     } else {
       startPrice = account.deepCurrencyPrice(startDate).reduce();
       endPrice = account.deepCurrencyPrice(endDate).reduce();
     }
     startShares = file->balance(account.id(), startDate);
     endShares = file->balance(account.id(), endDate);
 
     //get starting and ending balances
     startBalance = startShares * startPrice;
     endBalance = endShares * endPrice;
 
     //starting balance
     // don't show currency if we're converting or if it's not foreign
     if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (m_config.isConvertCurrency())
       qA[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = account.currency().id();
 
     qA[ctAccountID] = account.id();
     qA[ctAccount] = account.name();
     qA[ctTopAccount] = account.topParentName();
     qA[ctInstitution] = institution.isEmpty() ? i18n("No Institution") : file->institution(institution).name();
     qA[ctRank] = QLatin1Char('0');
 
     qA[ctPrice] = startPrice.convertPrecision(account.currency().pricePrecision()).toString();
     if (account.isInvest()) {
       qA[ctShares] = startShares.toString();
     }
 
     qA[ctPostDate] = strStartDate;
     qA[ctBalance] = startBalance.convert(fraction).toString();
     qA[ctValue].clear();
     qA[ctID] = QLatin1Char('A');
     m_rows += qA;
 
     //ending balance
     qA[ctPrice] = endPrice.convertPrecision(account.currency().pricePrecision()).toString();
 
     if (account.isInvest()) {
       qA[ctShares] = endShares.toString();
     }
 
     qA[ctPostDate] = strEndDate;
     qA[ctBalance] = endBalance.toString();
     qA[ctRank] = QLatin1Char('3');
     qA[ctID] = QLatin1Char('Z');
     m_rows += qA;
   }
 }
 
 MyMoneyMoney QueryTable::helperROI(const MyMoneyMoney &buys, const MyMoneyMoney &sells, const MyMoneyMoney &startingBal, const MyMoneyMoney &endingBal, const MyMoneyMoney &cashIncome) const
 {
   MyMoneyMoney returnInvestment;
   if (!buys.isZero() || !startingBal.isZero()) {
     returnInvestment = (sells + buys + cashIncome + endingBal - startingBal) / (startingBal - buys);
     returnInvestment = returnInvestment.convert(10000);
   } else
     returnInvestment = MyMoneyMoney(); // if no investment then no return on investment
   return returnInvestment;
 }
 
 MyMoneyMoney QueryTable::helperIRR(const CashFlowList &all) const
 {
   MyMoneyMoney annualReturn;
   try {
     double irr = all.IRR();
 #ifdef Q_CC_MSVC
     annualReturn = MyMoneyMoney(_isnan(irr) ? 0 : irr, 10000);
 #else
     annualReturn = MyMoneyMoney(std::isnan(irr) ? 0 : irr, 10000);
 #endif
   } catch (QString e) {
     qDebug() << e;
   }
   return annualReturn;
 }
 
 void QueryTable::sumInvestmentValues(const ReportAccount& account, QList<CashFlowList>& cfList, QList<MyMoneyMoney>& shList) const
 {
   for (int i = InvestmentValue::Buys; i < InvestmentValue::End; ++i)
     cfList.append(CashFlowList());
   for (int i = InvestmentValue::Buys; i <= InvestmentValue::BuysOfOwned; ++i)
     shList.append(MyMoneyMoney());
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   MyMoneyReport report = m_config;
   QDate startingDate;
   QDate endingDate;
   QDate newStartingDate;
   QDate newEndingDate;
   const bool isSTLT = report.isShowingSTLTCapitalGains();
   const int settlementPeriod = report.settlementPeriod();
   QDate termSeparator = report.termSeparator().addDays(-settlementPeriod);
   report.validDateRange(startingDate, endingDate);
   newStartingDate = startingDate;
   newEndingDate = endingDate;
 
   if (report.queryColumns() & MyMoneyReport::eQCcapitalgain) {
     // Saturday and Sunday aren't valid settlement dates
     if (endingDate.dayOfWeek() == Qt::Saturday)
       endingDate = endingDate.addDays(-1);
     else if (endingDate.dayOfWeek() == Qt::Sunday)
       endingDate = endingDate.addDays(-2);
 
     if (termSeparator.dayOfWeek() == Qt::Saturday)
       termSeparator = termSeparator.addDays(-1);
     else if (termSeparator.dayOfWeek() == Qt::Sunday)
       termSeparator = termSeparator.addDays(-2);
     if (startingDate.daysTo(endingDate) <= settlementPeriod)        // no days to check for
       return;
     termSeparator = termSeparator.addDays(-settlementPeriod);
     newEndingDate = endingDate.addDays(-settlementPeriod);
   }
 
   shList[BuysOfOwned] = file->balance(account.id(), newEndingDate); // get how many shares there are at the end of period
   MyMoneyMoney stashedBuysOfOwned = shList.at(BuysOfOwned);
 
   bool reportedDateRange = true;  // flag marking sell transactions between startingDate and endingDate
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
   report.clearAccountFilter();
   report.addAccount(account.id());
   report.setDateFilter(newStartingDate, newEndingDate);
 
   do {
     QList<MyMoneyTransaction> transactions = file->transactionList(report);
     for (QList<MyMoneyTransaction>::const_reverse_iterator  it_t = transactions.crbegin(); it_t != transactions.crend(); ++it_t) {
       MyMoneySplit shareSplit = (*it_t).splitByAccount(account.id());
       MyMoneySplit assetAccountSplit;
       QList<MyMoneySplit> feeSplits;
       QList<MyMoneySplit> interestSplits;
       MyMoneySecurity security;
       MyMoneySecurity currency;
       eMyMoney::Split::InvestmentTransactionType transactionType;
       KMyMoneyUtils::dissectTransaction((*it_t), shareSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
       QDate postDate = (*it_t).postDate();
       MyMoneyMoney price;
       //get price for the day of the transaction if we have to calculate base currency
       //we are using the value of the split which is in deep currency
       if (m_config.isConvertCurrency())
         price = account.baseCurrencyPrice(postDate); //we only need base currency because the value is in deep currency
       else
         price = MyMoneyMoney::ONE;
       MyMoneyMoney value = assetAccountSplit.value() * price;
       MyMoneyMoney shares = shareSplit.shares();
 
       if (transactionType == eMyMoney::Split::InvestmentTransactionType::BuyShares) {
         if (reportedDateRange) {
           cfList[Buys].append(CashFlowListItem(postDate, value));
           shList[Buys] += shares;
         }
 
         if (shList.at(BuysOfOwned).isZero()) {                      // add sold shares
           if (shList.at(BuysOfSells) + shares > shList.at(Sells).abs()) { // add partially sold shares
             MyMoneyMoney tempVal = (((shList.at(Sells).abs() - shList.at(BuysOfSells))) / shares) * value;
             cfList[BuysOfSells].append(CashFlowListItem(postDate, tempVal));
             shList[BuysOfSells] = shList.at(Sells).abs();
             if (isSTLT && postDate < termSeparator) {
               cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, tempVal));
               shList[LongTermBuysOfSells] = shList.at(BuysOfSells);
             }
           } else {                                                  // add wholly sold shares
             cfList[BuysOfSells].append(CashFlowListItem(postDate, value));
             shList[BuysOfSells] += shares;
             if (isSTLT && postDate < termSeparator) {
               cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, value));
               shList[LongTermBuysOfSells] += shares;
             }
           }
         } else if (shList.at(BuysOfOwned) >= shares) {              // subtract not-sold shares
           shList[BuysOfOwned] -= shares;
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, value));
         } else {                                                    // subtract partially not-sold shares
           MyMoneyMoney tempVal = ((shares - shList.at(BuysOfOwned)) / shares) * value;
           MyMoneyMoney tempVal2 = (shares - shList.at(BuysOfOwned));
           cfList[BuysOfSells].append(CashFlowListItem(postDate, tempVal));
           shList[BuysOfSells] += tempVal2;
           if (isSTLT && postDate < termSeparator) {
             cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, tempVal));
             shList[LongTermBuysOfSells] += tempVal2;
           }
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, (shList.at(BuysOfOwned) / shares) * value));
           shList[BuysOfOwned] = MyMoneyMoney();
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::SellShares && reportedDateRange) {
         cfList[Sells].append(CashFlowListItem(postDate, value));
         shList[Sells] += shares;
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::SplitShares) {          // shares variable is denominator of split ratio here
         for (int i = Buys; i <= InvestmentValue::BuysOfOwned; ++i)
           shList[i] /= shares;
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::AddShares ||            // added shares, when sold give 100% capital gain
                  transactionType == eMyMoney::Split::InvestmentTransactionType::ReinvestDividend) {
         if (shList.at(BuysOfOwned).isZero()) {                            // add added/reinvested shares
           if (shList.at(BuysOfSells) + shares > shList.at(Sells).abs()) { // add partially added/reinvested shares
             shList[BuysOfSells] = shList.at(Sells).abs();
             if (postDate < termSeparator)
               shList[LongTermBuysOfSells] = shList[BuysOfSells];
           } else {                                                        // add wholly added/reinvested shares
             shList[BuysOfSells] += shares;
             if (postDate < termSeparator)
               shList[LongTermBuysOfSells] += shares;
           }
         } else if (shList.at(BuysOfOwned) >= shares) {                    // subtract not-added/not-reinvested shares
           shList[BuysOfOwned] -= shares;
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, value));
         } else {                                                          // subtract partially not-added/not-reinvested shares
           MyMoneyMoney tempVal = (shares - shList.at(BuysOfOwned));
           shList[BuysOfSells] += tempVal;
           if (postDate < termSeparator)
             shList[LongTermBuysOfSells] += tempVal;
 
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, (shList.at(BuysOfOwned) / shares) * value));
           shList[BuysOfOwned] = MyMoneyMoney();
         }
         if (transactionType == eMyMoney::Split::InvestmentTransactionType::ReinvestDividend) {
           value = MyMoneyMoney();
           foreach (const auto split, interestSplits)
             value += split.value();
           value *= price;
           cfList[ReinvestIncome].append(CashFlowListItem(postDate, -value));
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::RemoveShares && reportedDateRange) // removed shares give no value in return so no capital gain on them
         shList[Sells] += shares;
       else if (transactionType == eMyMoney::Split::InvestmentTransactionType::Dividend || transactionType == eMyMoney::Split::InvestmentTransactionType::Yield)
         cfList[CashIncome].append(CashFlowListItem(postDate, value));
 
     }
     reportedDateRange = false;
     newEndingDate = newStartingDate;
     newStartingDate = newStartingDate.addYears(-1);
     report.setDateFilter(newStartingDate, newEndingDate); // search for matching buy transactions year earlier
 
   } while (
            (
              (report.investmentSum() == MyMoneyReport::eSumOwned && !shList[BuysOfOwned].isZero()) ||
              (report.investmentSum() == MyMoneyReport::eSumSold && !shList.at(Sells).isZero() && shList.at(Sells).abs() > shList.at(BuysOfSells).abs()) ||
              (report.investmentSum() == MyMoneyReport::eSumOwnedAndSold && (!shList[BuysOfOwned].isZero() || (!shList.at(Sells).isZero() && shList.at(Sells).abs() > shList.at(BuysOfSells).abs())))
            ) && account.openingDate() <= newEndingDate
           );
 
   // we've got buy value and no sell value of long-term shares, so get them
   if (isSTLT && !shList[LongTermBuysOfSells].isZero()) {
     newStartingDate = startingDate;
     newEndingDate = endingDate.addDays(-settlementPeriod);
     report.setDateFilter(newStartingDate, newEndingDate); // search for matching buy transactions year earlier
     QList<MyMoneyTransaction> transactions = file->transactionList(report);
     shList[BuysOfOwned] = shList[LongTermBuysOfSells];
 
     foreach (const auto transaction, transactions) {
       MyMoneySplit shareSplit = transaction.splitByAccount(account.id());
       MyMoneySplit assetAccountSplit;
       QList<MyMoneySplit> feeSplits;
       QList<MyMoneySplit> interestSplits;
       MyMoneySecurity security;
       MyMoneySecurity currency;
       eMyMoney::Split::InvestmentTransactionType transactionType;
       KMyMoneyUtils::dissectTransaction(transaction, shareSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
       QDate postDate = transaction.postDate();
       MyMoneyMoney price;
       if (m_config.isConvertCurrency())
         price = account.baseCurrencyPrice(postDate); //we only need base currency because the value is in deep currency
       else
         price = MyMoneyMoney::ONE;
       MyMoneyMoney value = assetAccountSplit.value() * price;
       MyMoneyMoney shares = shareSplit.shares();
 
       if (transactionType == eMyMoney::Split::InvestmentTransactionType::SellShares) {
         if ((shList.at(LongTermSellsOfBuys) + shares).abs() >= shList.at(LongTermBuysOfSells)) { // add partially sold long-term shares
           cfList[LongTermSellsOfBuys].append(CashFlowListItem(postDate, (shList.at(LongTermSellsOfBuys).abs() - shList.at(LongTermBuysOfSells)) / shares * value));
           shList[LongTermSellsOfBuys] = shList.at(LongTermBuysOfSells);
           break;
         } else {                      // add wholly sold long-term shares
           cfList[LongTermSellsOfBuys].append(CashFlowListItem(postDate, value));
           shList[LongTermSellsOfBuys] += shares;
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::RemoveShares) {
         if ((shList.at(LongTermSellsOfBuys) + shares).abs() >= shList.at(LongTermBuysOfSells)) {
           shList[LongTermSellsOfBuys] = shList.at(LongTermBuysOfSells);
           break;
         } else
           shList[LongTermSellsOfBuys] += shares;
       }
     }
   }
 
   shList[BuysOfOwned] = stashedBuysOfOwned;
   report.setDateFilter(startingDate, endingDate); // reset data filter for next security
   return;
 }
 
 void QueryTable::constructPerformanceRow(const ReportAccount& account, TableRow& result, CashFlowList &all) const
 {
   MyMoneyReport report = m_config;
   QDate startingDate;
   QDate endingDate;
   report.validDateRange(startingDate, endingDate);
   startingDate = startingDate.addDays(-1);
 
   MyMoneyFile* file = MyMoneyFile::instance();
   //get fraction depending on type of account
   int fraction = account.currency().smallestAccountFraction();
   MyMoneyMoney price;
   if (m_config.isConvertCurrency())
     price = account.deepCurrencyPrice(startingDate) * account.baseCurrencyPrice(startingDate);
   else
     price = account.deepCurrencyPrice(startingDate);
 
   MyMoneyMoney startingBal = file->balance(account.id(), startingDate) * price;
 
   //convert to lowest fraction
   startingBal = startingBal.convert(fraction);
 
   //calculate ending balance
   if (m_config.isConvertCurrency())
     price = account.deepCurrencyPrice(endingDate) * account.baseCurrencyPrice(endingDate);
   else
     price = account.deepCurrencyPrice(endingDate);
 
   MyMoneyMoney endingBal = file->balance((account).id(), endingDate) * price;
 
   //convert to lowest fraction
   endingBal = endingBal.convert(fraction);
 
   QList<CashFlowList> cfList;
   QList<MyMoneyMoney> shList;
   sumInvestmentValues(account, cfList, shList);
 
   MyMoneyMoney buysTotal;
   MyMoneyMoney sellsTotal;
   MyMoneyMoney cashIncomeTotal;
   MyMoneyMoney reinvestIncomeTotal;
 
   switch (m_config.investmentSum()) {
   case MyMoneyReport::eSumOwnedAndSold:
     buysTotal = cfList.at(BuysOfSells).total() + cfList.at(BuysOfOwned).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     reinvestIncomeTotal = cfList.at(ReinvestIncome).total();
     startingBal = MyMoneyMoney();
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         cashIncomeTotal.isZero() && reinvestIncomeTotal.isZero())
       return;
 
     all.append(cfList.at(BuysOfSells));
     all.append(cfList.at(BuysOfOwned));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctEndingBalance] = endingBal.toString();
     break;
   case MyMoneyReport::eSumOwned:
     buysTotal = cfList.at(BuysOfOwned).total();
     startingBal = MyMoneyMoney();
     if (buysTotal.isZero() && endingBal.isZero())
       return;
     all.append(cfList.at(BuysOfOwned));
     all.append(CashFlowListItem(endingDate, endingBal));
 
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctMarketValue] = endingBal.toString();
     break;
   case MyMoneyReport::eSumSold:
     buysTotal = cfList.at(BuysOfSells).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     startingBal = endingBal = MyMoneyMoney();
     // check if there are any meaningfull values before adding them to results
     if (buysTotal.isZero() && sellsTotal.isZero() && cashIncomeTotal.isZero())
       return;
     all.append(cfList.at(BuysOfSells));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     break;
   case MyMoneyReport::eSumPeriod:
   default:
     buysTotal = cfList.at(Buys).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     reinvestIncomeTotal = cfList.at(ReinvestIncome).total();
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         cashIncomeTotal.isZero() && reinvestIncomeTotal.isZero() &&
         startingBal.isZero() && endingBal.isZero())
       return;
 
     all.append(cfList.at(Buys));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
     all.append(CashFlowListItem(startingDate, -startingBal));
     all.append(CashFlowListItem(endingDate, endingBal));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctStartingBalance] = startingBal.toString();
     result[ctEndingBalance] = endingBal.toString();
     break;
   }
 
   MyMoneyMoney returnInvestment = helperROI(buysTotal - reinvestIncomeTotal, sellsTotal, startingBal, endingBal, cashIncomeTotal);
   MyMoneyMoney annualReturn = helperIRR(all);
 
   result[ctBuys] = buysTotal.toString();
   result[ctReturn] = annualReturn.toString();
   result[ctReturnInvestment] = returnInvestment.toString();
   result[ctEquityType] = MyMoneySecurity::securityTypeToString(file->security(account.currencyId()).securityType());
 }
 
 void QueryTable::constructCapitalGainRow(const ReportAccount& account, TableRow& result) const
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<CashFlowList> cfList;
   QList<MyMoneyMoney> shList;
   sumInvestmentValues(account, cfList, shList);
 
   MyMoneyMoney buysTotal = cfList.at(BuysOfSells).total();
   MyMoneyMoney sellsTotal = cfList.at(Sells).total();
   MyMoneyMoney longTermBuysOfSellsTotal = cfList.at(LongTermBuysOfSells).total();
   MyMoneyMoney longTermSellsOfBuys = cfList.at(LongTermSellsOfBuys).total();
 
   switch (m_config.investmentSum()) {
   case MyMoneyReport::eSumOwned:
   {
     if (shList.at(BuysOfOwned).isZero())
       return;
 
     MyMoneyReport report = m_config;
     QDate startingDate;
     QDate endingDate;
     report.validDateRange(startingDate, endingDate);
 
     //get fraction depending on type of account
     int fraction = account.currency().smallestAccountFraction();
     MyMoneyMoney price;
 
     //calculate ending balance
     if (m_config.isConvertCurrency())
       price = account.deepCurrencyPrice(endingDate) * account.baseCurrencyPrice(endingDate);
     else
       price = account.deepCurrencyPrice(endingDate);
 
     MyMoneyMoney endingBal = shList.at(BuysOfOwned) * price;
 
     //convert to lowest fraction
     endingBal = endingBal.convert(fraction);
 
     buysTotal = cfList.at(BuysOfOwned).total() - cfList.at(ReinvestIncome).total();
 
     int pricePrecision = file->security(account.currencyId()).pricePrecision();
     result[ctBuys] = buysTotal.toString();
     result[ctShares] = shList.at(BuysOfOwned).toString();
     result[ctBuyPrice] = (buysTotal.abs() / shList.at(BuysOfOwned)).convertPrecision(pricePrecision).toString();
     result[ctLastPrice] = price.toString();
     result[ctMarketValue] = endingBal.toString();
     result[ctCapitalGain] = (buysTotal + endingBal).toString();
     result[ctPercentageGain] = ((buysTotal + endingBal)/buysTotal.abs()).toString();
     break;
   }
   case MyMoneyReport::eSumSold:
   default:
     buysTotal = cfList.at(BuysOfSells).total() - cfList.at(ReinvestIncome).total();
     sellsTotal = cfList.at(Sells).total();
     longTermBuysOfSellsTotal = cfList.at(LongTermBuysOfSells).total();
     longTermSellsOfBuys = cfList.at(LongTermSellsOfBuys).total();
     // check if there are any meaningfull values before adding them to results
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         longTermBuysOfSellsTotal.isZero() && longTermSellsOfBuys.isZero())
       return;
 
     result[ctBuys] = buysTotal.toString();
     result[ctSells] = sellsTotal.toString();
     result[ctCapitalGain] = (buysTotal + sellsTotal).toString();
     if (m_config.isShowingSTLTCapitalGains()) {
       result[ctBuysLT] = longTermBuysOfSellsTotal.toString();
       result[ctSellsLT] = longTermSellsOfBuys.toString();
       result[ctCapitalGainLT] = (longTermBuysOfSellsTotal + longTermSellsOfBuys).toString();
       result[ctBuysST] = (buysTotal - longTermBuysOfSellsTotal).toString();
       result[ctSellsST] = (sellsTotal - longTermSellsOfBuys).toString();
       result[ctCapitalGainST] = ((buysTotal - longTermBuysOfSellsTotal) + (sellsTotal - longTermSellsOfBuys)).toString();
     }
     break;
   }
 
   result[ctEquityType] = MyMoneySecurity::securityTypeToString(file->security(account.currencyId()).securityType());
 }
 
 void QueryTable::constructAccountTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   QMap<QString, QMap<QString, CashFlowList>> currencyCashFlow; // for total calculation
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
   for (auto it_account = accounts.constBegin(); it_account != accounts.constEnd(); ++it_account) {
     // Note, "Investment" accounts are never included in account rows because
     // they don't contain anything by themselves.  In reports, they are only
     // useful as a "topaccount" aggregator of stock accounts
     if ((*it_account).isAssetLiability() && m_config.includes((*it_account)) && (*it_account).accountType() != eMyMoney::Account::Type::Investment) {
       // don't add the account if it is closed. In fact, the business logic
       // should prevent that an account can be closed with a balance not equal
       // to zero, but we never know.
       MyMoneyMoney shares = file->balance((*it_account).id(), m_config.toDate());
       if (shares.isZero() && (*it_account).isClosed())
         continue;
 
       ReportAccount account(*it_account);
       TableRow qaccountrow;
       CashFlowList accountCashflow; // for total calculation
       switch(m_config.queryColumns()) {
         case MyMoneyReport::eQCperformance:
         {
           constructPerformanceRow(account, qaccountrow, accountCashflow);
           if (!qaccountrow.isEmpty()) {
             // assuming that that report is grouped by topaccount
             qaccountrow[ctTopAccount] = account.topParentName();
             if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
               m_containsNonBaseCurrency = true;
             if (m_config.isConvertCurrency())
               qaccountrow[ctCurrency] = file->baseCurrency().id();
             else
               qaccountrow[ctCurrency] = account.currency().id();
 
             if (!currencyCashFlow.value(qaccountrow.value(ctCurrency)).contains(qaccountrow.value(ctTopAccount)))
               currencyCashFlow[qaccountrow.value(ctCurrency)].insert(qaccountrow.value(ctTopAccount), accountCashflow);   // create cashflow for unknown account...
             else
               currencyCashFlow[qaccountrow.value(ctCurrency)][qaccountrow.value(ctTopAccount)] += accountCashflow;        // ...or add cashflow for known account
           }
           break;
         }
         case MyMoneyReport::eQCcapitalgain:
           constructCapitalGainRow(account, qaccountrow);
           break;
         default:
         {
           //get fraction for account
           int fraction = account.currency().smallestAccountFraction() != -1 ?
                 account.currency().smallestAccountFraction() : file->baseCurrency().smallestAccountFraction();
 
           MyMoneyMoney netprice = account.deepCurrencyPrice(m_config.toDate());
           if (m_config.isConvertCurrency() && account.isForeignCurrency())
             netprice *= account.baseCurrencyPrice(m_config.toDate()); // display currency is base currency, so set the price
 
           netprice = netprice.reduce();
           shares = shares.reduce();
           int pricePrecision = file->security(account.currencyId()).pricePrecision();
           qaccountrow[ctPrice] = netprice.convertPrecision(pricePrecision).toString();
           qaccountrow[ctValue] = (netprice * shares).convert(fraction).toString();
           qaccountrow[ctShares] = shares.toString();
 
           QString iid = account.institutionId();
 
           // If an account does not have an institution, get it from the top-parent.
           if (iid.isEmpty() && !account.isTopLevel())
             iid = account.topParent().institutionId();
 
           if (iid.isEmpty())
             qaccountrow[ctInstitution] = i18nc("No institution", "None");
           else
             qaccountrow[ctInstitution] = file->institution(iid).name();
 
           qaccountrow[ctType] = MyMoneyAccount::accountTypeToString(account.accountType());
         }
       }
 
       if (qaccountrow.isEmpty()) // don't add the account if there are no calculated values
         continue;
 
       qaccountrow[ctRank] = QLatin1Char('1');
       qaccountrow[ctAccount] = account.name();
       qaccountrow[ctAccountID] = account.id();
       qaccountrow[ctTopAccount] = account.topParentName();
       if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
         m_containsNonBaseCurrency = true;
       if (m_config.isConvertCurrency())
         qaccountrow[ctCurrency] = file->baseCurrency().id();
       else
         qaccountrow[ctCurrency] = account.currency().id();
       m_rows.append(qaccountrow);
     }
   }
 
   if (m_config.queryColumns() == MyMoneyReport::eQCperformance && m_config.isShowingColumnTotals()) {
     TableRow qtotalsrow;
     qtotalsrow[ctRank] = QLatin1Char('4'); // add identification of row as total
     QMap<QString, CashFlowList> currencyGrandCashFlow;
 
     QMap<QString, QMap<QString, CashFlowList>>::iterator currencyAccGrp = currencyCashFlow.begin();
     while (currencyAccGrp != currencyCashFlow.end()) {
       // convert map of top accounts with cashflows to TableRow
       for (QMap<QString, CashFlowList>::iterator topAccount = (*currencyAccGrp).begin(); topAccount != (*currencyAccGrp).end(); ++topAccount) {
         qtotalsrow[ctTopAccount] = topAccount.key();
         qtotalsrow[ctReturn] = helperIRR(topAccount.value()).toString();
         qtotalsrow[ctCurrency] = currencyAccGrp.key();
         currencyGrandCashFlow[currencyAccGrp.key()] += topAccount.value();  // cumulative sum of cashflows of each topaccount
         m_rows.append(qtotalsrow);            // rows aren't sorted yet, so no problem with adding them randomly at the end
       }
       ++currencyAccGrp;
     }
     QMap<QString, CashFlowList>::iterator currencyGrp = currencyGrandCashFlow.begin();
     qtotalsrow[ctTopAccount].clear();          // empty topaccount because it's grand cashflow
     while (currencyGrp != currencyGrandCashFlow.end()) {
       qtotalsrow[ctReturn] = helperIRR(currencyGrp.value()).toString();
       qtotalsrow[ctCurrency] = currencyGrp.key();
       m_rows.append(qtotalsrow);
       ++currencyGrp;
     }
   }
 }
 
 void QueryTable::constructSplitsTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   MyMoneyReport report(m_config);
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
 
   // support for opening and closing balances
   QMap<QString, MyMoneyAccount> accts;
 
   //get all transactions for this report
   QList<MyMoneyTransaction> transactions = file->transactionList(report);
   for (QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin(); it_transaction != transactions.constEnd(); ++it_transaction) {
 
     TableRow qA, qS;
     QDate pd;
 
     qA[ctID] = qS[ctID] = (* it_transaction).id();
     qA[ctEntryDate] = qS[ctEntryDate] = (* it_transaction).entryDate().toString(Qt::ISODate);
     qA[ctPostDate] = qS[ctPostDate] = (* it_transaction).postDate().toString(Qt::ISODate);
     qA[ctCommodity] = qS[ctCommodity] = (* it_transaction).commodity();
 
     pd = (* it_transaction).postDate();
     qA[ctMonth] = qS[ctMonth] = i18n("Month of %1", QDate(pd.year(), pd.month(), 1).toString(Qt::ISODate));
     qA[ctWeek] = qS[ctWeek] = i18n("Week of %1", pd.addDays(1 - pd.dayOfWeek()).toString(Qt::ISODate));
 
     if (!m_containsNonBaseCurrency && (*it_transaction).commodity() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (report.isConvertCurrency())
       qA[ctCurrency] = qS[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = qS[ctCurrency] = (*it_transaction).commodity();
 
     // to handle splits, we decide on which account to base the split
     // (a reference point or point of view so to speak). here we take the
     // first account that is a stock account or loan account (or the first account
     // that is not an income or expense account if there is no stock or loan account)
     // to be the account (qA) that will have the sub-item "split" entries. we add
     // one transaction entry (qS) for each subsequent entry in the split.
     const QList<MyMoneySplit>& splits = (*it_transaction).splits();
     QList<MyMoneySplit>::const_iterator myBegin, it_split;
     //S_end = splits.end();
 
     for (it_split = splits.constBegin(), myBegin = splits.constEnd(); it_split != splits.constEnd(); ++it_split) {
       ReportAccount splitAcc((* it_split).accountId());
       // always put split with a "stock" account if it exists
       if (splitAcc.isInvest())
         break;
 
       // prefer to put splits with a "loan" account if it exists
       if (splitAcc.isLoan())
         myBegin = it_split;
 
       if ((myBegin == splits.end()) && ! splitAcc.isIncomeExpense()) {
         myBegin = it_split;
       }
     }
 
     // select our "reference" split
     if (it_split == splits.end()) {
       it_split = myBegin;
     } else {
       myBegin = it_split;
     }
 
     // if the split is still unknown, use the first one. I have seen this
     // happen with a transaction that has only a single split referencing an income or expense
     // account and has an amount and value of 0. Such a transaction will fall through
     // the above logic and leave 'it_split' pointing to splits.end() which causes the remainder
     // of this to end in an infinite loop.
     if (it_split == splits.end()) {
       it_split = splits.begin();
     }
 
     // for "loan" reports, the loan transaction gets special treatment.
     // the splits of a loan transaction are placed on one line in the
     // reference (loan) account (qA). however, we process the matching
     // split entries (qS) normally.
     bool loan_special_case = false;
     if (m_config.queryColumns() & MyMoneyReport::eQCloan) {
       ReportAccount splitAcc((*it_split).accountId());
       loan_special_case = splitAcc.isLoan();
     }
 
     // There is a slight chance that at this point myBegin is still pointing to splits.end() if the
     // transaction only has income and expense splits (which should not happen). In that case, point
     // it to the first split
     if (myBegin == splits.end()) {
       myBegin = splits.begin();
     }
 
     //the account of the beginning splits
     ReportAccount myBeginAcc((*myBegin).accountId());
 
     bool include_me = true;
     QString a_fullname;
     QString a_memo;
     int pass = 1;
 
     do {
       MyMoneyMoney xr;
       ReportAccount splitAcc((* it_split).accountId());
 
       //get fraction for account
       int fraction = splitAcc.currency().smallestAccountFraction();
 
       //use base currency fraction if not initialized
       if (fraction == -1)
         fraction = file->baseCurrency().smallestAccountFraction();
 
       QString institution = splitAcc.institutionId();
       QString payee = (*it_split).payeeId();
 
       const QList<QString> tagIdList = (*it_split).tagIdList();
 
       if (m_config.isConvertCurrency()) {
         xr = (splitAcc.deepCurrencyPrice((*it_transaction).postDate()) * splitAcc.baseCurrencyPrice((*it_transaction).postDate())).reduce();
       } else {
         xr = splitAcc.deepCurrencyPrice((*it_transaction).postDate()).reduce();
       }
 
       // reverse the sign of incomes and expenses to keep consistency in the way it is displayed in other reports
       if (splitAcc.isIncomeExpense()) {
         xr = -xr;
       }
 
       if (splitAcc.isInvest()) {
 
         // use the institution of the parent for stock accounts
         institution = splitAcc.parent().institutionId();
         MyMoneyMoney shares = (*it_split).shares();
         int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
         qA[ctAction] = (*it_split).action();
         qA[ctShares] = shares.isZero() ? QString() : (*it_split).shares().toString();
         qA[ctPrice] = shares.isZero() ? QString() : xr.convertPrecision(pricePrecision).toString();
 
         if (((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) && (*it_split).shares().isNegative())
           qA[ctAction] = "Sell";
 
         qA[ctInvestAccount] = splitAcc.parent().name();
       }
 
       include_me = m_config.includes(splitAcc);
       a_fullname = splitAcc.fullName();
       a_memo = (*it_split).memo();
 
       int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
       qA[ctPrice] = xr.convertPrecision(pricePrecision).toString();
       qA[ctAccount] = splitAcc.name();
       qA[ctAccountID] = splitAcc.id();
       qA[ctTopAccount] = splitAcc.topParentName();
 
       qA[ctInstitution] = institution.isEmpty()
                           ? i18n("No Institution")
                           : file->institution(institution).name();
 
       //FIXME-ALEX Is this useless? Isn't constructSplitsTable called only for cashflow type report?
       QString delimiter;
       foreach(const auto tagId, tagIdList) {
         qA[ctTag] += delimiter + file->tag(tagId).name().simplified();
         delimiter = QLatin1Char(',');
       }
 
       qA[ctPayee] = payee.isEmpty()
                     ? i18n("[Empty Payee]")
                     : file->payee(payee).name().simplified();
 
       qA[ctReconcileDate] = (*it_split).reconcileDate().toString(Qt::ISODate);
       qA[ctReconcileFlag] = KMyMoneyUtils::reconcileStateToString((*it_split).reconcileFlag(), true);
       qA[ctNumber] = (*it_split).number();
 
       qA[ctMemo] = a_memo;
 
       qS[ctReconcileDate] = qA[ctReconcileDate];
       qS[ctReconcileFlag] = qA[ctReconcileFlag];
       qS[ctNumber] = qA[ctNumber];
 
       qS[ctTopCategory] = splitAcc.topParentName();
 
       // only include the configured accounts
       if (include_me) {
         // add the "summarized" split transaction
         // this is the sub-total of the split detail
         // convert to lowest fraction
         qA[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
         qA[ctRank] = QLatin1Char('1');
 
         //fill in account information
         if (! splitAcc.isIncomeExpense() && it_split != myBegin) {
           qA[ctAccount] = ((*it_split).shares().isNegative()) ?
                           i18n("Transfer to %1", myBeginAcc.fullName())
                           : i18n("Transfer from %1", myBeginAcc.fullName());
         } else if (it_split == myBegin) {
           //handle the main split
           if ((splits.count() > 2)) {
             //if it is the main split and has multiple splits, note that
             qA[ctAccount] = i18n("[Split Transaction]");
           } else {
             //fill the account name of the second split
             QList<MyMoneySplit>::const_iterator tempSplit = splits.constBegin();
 
             //there are supposed to be only 2 splits if we ever get here
             if (tempSplit == myBegin && splits.count() > 1)
               ++tempSplit;
 
             //show the name of the category, or "transfer to/from" if it as an account
             ReportAccount tempSplitAcc((*tempSplit).accountId());
             if (! tempSplitAcc.isIncomeExpense()) {
               qA[ctAccount] = ((*it_split).shares().isNegative()) ?
                               i18n("Transfer to %1", tempSplitAcc.fullName())
                               : i18n("Transfer from %1", tempSplitAcc.fullName());
             } else {
               qA[ctAccount] = tempSplitAcc.fullName();
             }
           }
         } else {
           //in any other case, fill in the account name of the main split
           qA[ctAccount] = myBeginAcc.fullName();
         }
 
         //category data is always the one of the split
         qA [ctCategory] = splitAcc.fullName();
         qA [ctTopCategory] = splitAcc.topParentName();
         qA [ctCategoryType] = MyMoneyAccount::accountTypeToString(splitAcc.accountGroup());
 
         m_rows += qA;
 
         // track accts that will need opening and closing balances
         accts.insert(splitAcc.id(), splitAcc);
       }
       ++it_split;
 
       // look for wrap-around
       if (it_split == splits.end())
         it_split = splits.begin();
 
       //check if there have been more passes than there are splits
       //this is to prevent infinite loops in cases of data inconsistency -- asoliverez
       ++pass;
       if (pass > splits.count())
         break;
 
     } while (it_split != myBegin);
 
     if (loan_special_case) {
       m_rows += qA;
     }
   }
 
   // now run through our accts list and add opening and closing balances
 
   switch (m_config.rowType()) {
     case MyMoneyReport::eAccount:
     case MyMoneyReport::eTopAccount:
       break;
 
       // case MyMoneyReport::eCategory:
       // case MyMoneyReport::eTopCategory:
       // case MyMoneyReport::ePayee:
       // case MyMoneyReport::eMonth:
       // case MyMoneyReport::eWeek:
     default:
       return;
   }
 
   QDate startDate, endDate;
 
   report.validDateRange(startDate, endDate);
   QString strStartDate = startDate.toString(Qt::ISODate);
   QString strEndDate = endDate.toString(Qt::ISODate);
   startDate = startDate.addDays(-1);
 
   QMap<QString, MyMoneyAccount>::const_iterator it_account, accts_end;
   for (it_account = accts.constBegin(); it_account != accts.constEnd(); ++it_account) {
     TableRow qA;
 
     ReportAccount account((* it_account));
 
     //get fraction for account
     int fraction = account.currency().smallestAccountFraction();
 
     //use base currency fraction if not initialized
     if (fraction == -1)
       fraction = file->baseCurrency().smallestAccountFraction();
 
     QString institution = account.institutionId();
 
     // use the institution of the parent for stock accounts
     if (account.isInvest())
       institution = account.parent().institutionId();
 
     MyMoneyMoney startBalance, endBalance, startPrice, endPrice;
     MyMoneyMoney startShares, endShares;
 
     //get price and convert currency if necessary
     if (m_config.isConvertCurrency()) {
       startPrice = (account.deepCurrencyPrice(startDate) * account.baseCurrencyPrice(startDate)).reduce();
       endPrice = (account.deepCurrencyPrice(endDate) * account.baseCurrencyPrice(endDate)).reduce();
     } else {
       startPrice = account.deepCurrencyPrice(startDate).reduce();
       endPrice = account.deepCurrencyPrice(endDate).reduce();
     }
     startShares = file->balance(account.id(), startDate);
     endShares = file->balance(account.id(), endDate);
 
     //get starting and ending balances
     startBalance = startShares * startPrice;
     endBalance = endShares * endPrice;
 
     //starting balance
     // don't show currency if we're converting or if it's not foreign
     if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (m_config.isConvertCurrency())
       qA[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = account.currency().id();
 
     qA[ctAccountID] = account.id();
     qA[ctAccount] = account.name();
     qA[ctTopAccount] = account.topParentName();
     qA[ctInstitution] = institution.isEmpty() ? i18n("No Institution") : file->institution(institution).name();
     qA[ctRank] = QLatin1Char('0');
 
     int pricePrecision = file->security(account.currencyId()).pricePrecision();
     qA[ctPrice] = startPrice.convertPrecision(pricePrecision).toString();
     if (account.isInvest()) {
       qA[ctShares] = startShares.toString();
     }
 
     qA[ctPostDate] = strStartDate;
     qA[ctBalance] = startBalance.convert(fraction).toString();
     qA[ctValue].clear();
     qA[ctID] = QLatin1Char('A');
     m_rows += qA;
 
     qA[ctRank] = QLatin1Char('3');
     //ending balance
     qA[ctPrice] = endPrice.convertPrecision(pricePrecision).toString();
 
     if (account.isInvest()) {
       qA[ctShares] = endShares.toString();
     }
 
     qA[ctPostDate] = strEndDate;
     qA[ctBalance] = endBalance.toString();
     qA[ctID] = QLatin1Char('Z');
     m_rows += qA;
   }
 }
 
 
 
 }
diff --git a/kmymoney/reports/tests/pivottable-test.cpp b/kmymoney/reports/tests/pivottable-test.cpp
index 7acbe760c..7e8caeabc 100644
--- a/kmymoney/reports/tests/pivottable-test.cpp
+++ b/kmymoney/reports/tests/pivottable-test.cpp
@@ -1,1077 +1,1077 @@
 /***************************************************************************
                           pivottabletest.cpp
                           -------------------
     copyright            : (C) 2002-2005 by Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "pivottable-test.h"
 
 #include <QList>
 #include <QFile>
 #include <QTest>
 #include <QTextCodec>
 
 // DOH, mmreport.h uses this without including it!!
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneyreport.h"
 #include "mymoneystatement.h"
 #include "mymoneysplit.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 #include "mymoneystoragedump.h"
 #include "mymoneystoragexml.h"
 #include "mymoneyenums.h"
 
 #include "pivottable.h"
 #include "reportstestcommon.h"
 #include "kmymoneysettings.h"
 
 using namespace reports;
 using namespace test;
 
 QTEST_GUILESS_MAIN(PivotTableTest)
 
 void PivotTableTest::setup()
 {
 }
 
 void PivotTableTest::init()
 {
   storage = new MyMoneyStorageMgr;
   file = MyMoneyFile::instance();
   file->attachStorage(storage);
 
   MyMoneyFileTransaction ft;
   file->addCurrency(MyMoneySecurity("CAD", "Canadian Dollar",        "C$"));
   file->addCurrency(MyMoneySecurity("USD", "US Dollar",              "$"));
   file->addCurrency(MyMoneySecurity("JPY", "Japanese Yen",           QChar(0x00A5), 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2("Thomas Baumgart");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount(QString("Checking Account"), eMyMoney::Account::Type::Checkings, moCheckingOpen, QDate(2004, 5, 15), acAsset);
   acCredit = makeAccount(QString("Credit Card"), eMyMoney::Account::Type::CreditCard, moCreditOpen, QDate(2004, 7, 15), acLiability);
   acSolo = makeAccount(QString("Solo"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acParent = makeAccount(QString("Parent"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acChild = makeAccount(QString("Child"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acForeign = makeAccount(QString("Foreign"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
 
   acSecondChild = makeAccount(QString("Second Child"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acGrandChild1 = makeAccount(QString("Grand Child 1"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild);
   acGrandChild2 = makeAccount(QString("Grand Child 2"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild);
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 }
 
 void PivotTableTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void PivotTableTest::testNetWorthSingle()
 {
   try {
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eAssetLiability);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 7, 1).addDays(-1));
     XMLandback(filter);
     PivotTable networth_f(filter);
     writeTabletoCSV(networth_f);
 
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"][ReportAccount(acChecking)][eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"][ReportAccount(acChecking)][eActual][6] == moCheckingOpen);
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid.m_total[eActual][0] == moZero);
     QVERIFY(networth_f.m_grid.m_total[eActual][4] == moZero);
     QVERIFY(networth_f.m_grid.m_total[eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid.m_total[eActual][6] == moCheckingOpen);
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 void PivotTableTest::testNetWorthOfsetting()
 {
   // Test the net worth report to make sure it picks up the opening balance for two
   // accounts opened during the period of the report, one asset & one liability.  Test
   // that it calculates the totals correctly.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"][ReportAccount(acCredit)][eActual][7] == -moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(networth_f.m_grid.m_total[eActual][12] == moCheckingOpen + moCreditOpen);
 
 }
 
 void PivotTableTest::testNetWorthOpeningPrior()
 {
   // Test the net worth report to make sure it's picking up opening balances PRIOR to
   // the period of the report.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2005, 8, 1), QDate(2005, 12, 31));
   filter.setName("Net Worth Opening Prior 1");
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoCSV(networth_f);
 
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"].m_total[eActual][0] == -moCreditOpen);
   QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][0] == moCheckingOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][0] == moCheckingOpen + moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][1] == moCheckingOpen + moCreditOpen);
 
   // Test the net worth report to make sure that transactions prior to the report
   // period are included in the opening balance
 
   TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acChecking, acChild);
 
   filter.setName("Net Worth Opening Prior 2");
   PivotTable networth_f2(filter);
   writeTabletoCSV(networth_f2);
 
   MyMoneyMoney m1 = (networth_f2.m_grid["Liability"]["Credit Card"].m_total[eActual][1]);
   MyMoneyMoney m2 = (-moCreditOpen + moParent);
 
   QVERIFY((networth_f2.m_grid["Liability"]["Credit Card"].m_total[eActual][1]) == (-moCreditOpen + moParent));
   QVERIFY(networth_f2.m_grid["Asset"]["Checking Account"].m_total[eActual][1] == moCheckingOpen - moChild);
   QVERIFY(networth_f2.m_grid.m_total[eActual][1] == moCheckingOpen + moCreditOpen - moChild - moParent);
 }
 
 void PivotTableTest::testNetWorthDateFilter()
 {
   // Test a net worth report whose period is prior to the time any accounts are open,
   // so the report should be zero.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 2, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid.m_total[eActual][1] == moZero);
 
 }
 
 void PivotTableTest::testNetWorthOpening()
 {
   MyMoneyMoney openingBalance(12000000);
   auto acBasicAccount = makeAccount(QString("Basic Account"), eMyMoney::Account::Type::Checkings, openingBalance, QDate(2016, 1, 1), acAsset);
   auto ctBasicIncome = makeAccount(QString("Basic Income"), eMyMoney::Account::Type::Income, MyMoneyMoney(), QDate(2016, 1, 1), acIncome);
   auto ctBasicExpense = makeAccount(QString("Basic Expense"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2016, 1, 1), acExpense);
 
   TransactionHelper t1(QDate(2016, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-6200000), acBasicAccount, ctBasicIncome);
   TransactionHelper t2(QDate(2016, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-200000), acBasicAccount, ctBasicIncome);
   TransactionHelper t3(QDate(2016, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-200000), acBasicAccount, ctBasicIncome);
   TransactionHelper t4(QDate(2016, 10, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t5(QDate(2016, 11, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t6(QDate(2016, 12, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(100000), acBasicAccount, ctBasicExpense);
   TransactionHelper t7(QDate(2017, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t8(QDate(2017, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t9(QDate(2017, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t10(QDate(2017, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t11(QDate(2017, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(4500000), acBasicAccount, ctBasicExpense);
   TransactionHelper t12(QDate(2017, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
   TransactionHelper t13(QDate(2017, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), MyMoneyMoney(-100000), acBasicAccount, ctBasicIncome);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2016, 1, 1), QDate(2017, 12, 31));
   filter.addAccount(acBasicAccount);
   XMLandback(filter);
   PivotTable nt_opening1(filter);
   writeTabletoCSV(nt_opening1, "networth-opening-1.csv");
 
   QVERIFY(nt_opening1.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][0] == MyMoneyMoney()); // opening value on 1st Jan 2016 is 12000000, but before that i.e. 31st Dec 2015 opening value is 0
   for (auto i = 1; i <= 6; ++i)
     QVERIFY(nt_opening1.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][i] == openingBalance);
   QVERIFY(nt_opening1.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][7] == openingBalance + MyMoneyMoney(6200000));
   QVERIFY(nt_opening1.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][12] == MyMoneyMoney(18700000)); // value after t6 transaction
 
   filter.setDateFilter(QDate(2017, 1, 1), QDate(2017, 12, 31));
   XMLandback(filter);
   PivotTable nt_opening2(filter);
   writeTabletoCSV(nt_opening2, "networth-opening-2.csv");
 
   QVERIFY(nt_opening2.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][0] == MyMoneyMoney(18700000)); // opening value is equall to the value after t6 transaction
   QVERIFY(nt_opening2.m_grid["Asset"]["Basic Account"][ReportAccount(acBasicAccount)][eActual][12] == MyMoneyMoney(14800000));
 }
 
 void PivotTableTest::testSpendingEmpty()
 {
   // test a spending report with no entries
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   XMLandback(filter);
   PivotTable spending_f1(filter);
   QVERIFY(spending_f1.m_grid.m_total[eActual].m_total == moZero);
 
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   PivotTable spending_f2(filter);
   QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == moZero);
 }
 
 void PivotTableTest::testSingleTransaction()
 {
   // Test a single transaction
   TransactionHelper t(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setName("Spending with Single Transaction.html");
   XMLandback(filter);
   PivotTable spending_f(filter);
   writeTabletoHTML(spending_f, "Spending with Single Transaction.html");
 
   QVERIFY(spending_f.m_grid["Expense"]["Solo"][ReportAccount(acSolo)][eActual][1] == moSolo);
   QVERIFY(spending_f.m_grid["Expense"]["Solo"].m_total[eActual][1] == moSolo);
   QVERIFY(spending_f.m_grid["Expense"]["Solo"].m_total[eActual][0] == moZero);
   QVERIFY(spending_f.m_grid.m_total[eActual][1] == (-moSolo));
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == (-moSolo));
 
   filter.clearTransactionFilter();
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][2] == (moCheckingOpen - moSolo));
 }
 
 void PivotTableTest::testSubAccount()
 {
   // Test a sub-account with a value, under an account with a value
 
   TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setName("Spending with Sub-Account");
   XMLandback(filter);
   PivotTable spending_f(filter);
   writeTabletoHTML(spending_f, "Spending with Sub-Account.html");
 
   QVERIFY(spending_f.m_grid["Expense"]["Parent"][ReportAccount(acParent)][eActual][2] == moParent);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"][ReportAccount(acChild)][eActual][2] == moChild);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][2] == moParent + moChild);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][1] == moZero);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual].m_total == moParent + moChild);
   QVERIFY(spending_f.m_grid.m_total[eActual][2] == (-moParent - moChild));
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == (-moParent - moChild));
 
   filter.clearTransactionFilter();
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setName("Net Worth with Sub-Account");
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoHTML(networth_f, "Net Worth with Sub-Account.html");
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"].m_total[eActual][3] == moParent + moChild - moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][4] == -moParent - moChild + moCreditOpen + moCheckingOpen);
 
 }
 
 void PivotTableTest::testFilterIEvsIE()
 {
   // Test that removing an income/spending account will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acChild);
   filter.addCategory(acSolo);
   XMLandback(filter);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][2] == moChild);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][1] == moSolo);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moChild);
 
 }
 
 void PivotTableTest::testFilterALvsAL()
 {
   // Test that removing an asset/liability account will remove the entry from an asset/liability report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acChecking);
   filter.addCategory(acChild);
   filter.addCategory(acSolo);
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid.m_total[eActual][2] == -moSolo + moCheckingOpen);
 }
 
 void PivotTableTest::testFilterALvsIE()
 {
   // Test that removing an asset/liability account will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acChecking);
   QVERIFY(file->transactionList(filter).count() == 1);
 
   XMLandback(filter);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][2] == moZero);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][1] == moSolo);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 }
 
 void PivotTableTest::testFilterAllvsIE()
 {
   // Test that removing an asset/liability account AND an income/expense
   // category will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acCredit);
   filter.addCategory(acChild);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][1] == moZero);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][2] == moChild);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moChild);
 }
 
 void PivotTableTest::testFilterBasics()
 {
   // Test that the filters are operating the way that the reports expect them to
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
   TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
   MyMoneyTransactionFilter filter;
   filter.clear();
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acSolo);
   filter.setReportAllSplits(false);
   filter.setConsiderCategory(true);
 
   QVERIFY(file->transactionList(filter).count() == 1);
 
   filter.addCategory(acParent);
 
   QVERIFY(file->transactionList(filter).count() == 3);
 
   filter.addAccount(acChecking);
 
   QVERIFY(file->transactionList(filter).count() == 1);
 
   filter.clear();
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acParent);
   filter.addAccount(acCredit);
   filter.setReportAllSplits(false);
   filter.setConsiderCategory(true);
 
   QVERIFY(file->transactionList(filter).count() == 2);
 }
 
 void PivotTableTest::testMultipleCurrencies()
 {
   MyMoneyMoney moCanOpening(0.0, 10);
   MyMoneyMoney moJpyOpening(0.0, 10);
   MyMoneyMoney moCanPrice(0.75, 100);
   MyMoneyMoney moJpyPrice(0.010, 1000);
   MyMoneyMoney moJpyPrice2(0.011, 1000);
   MyMoneyMoney moJpyPrice3(0.014, 1000);
   MyMoneyMoney moJpyPrice4(0.0395, 10000);
   MyMoneyMoney moCanTransaction(100.0, 10);
   MyMoneyMoney moJpyTransaction(100.0, 10);
 
   QString acCanChecking = makeAccount(QString("Canadian Checking"), eMyMoney::Account::Type::Checkings, moCanOpening, QDate(2003, 11, 15), acAsset, "CAD");
   QString acJpyChecking = makeAccount(QString("Japanese Checking"), eMyMoney::Account::Type::Checkings, moJpyOpening, QDate(2003, 11, 15), acAsset, "JPY");
   QString acCanCash = makeAccount(QString("Canadian"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acForeign, "CAD");
   QString acJpyCash = makeAccount(QString("Japanese"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acForeign, "JPY");
 
   makePrice("CAD", QDate(2004, 1, 1), MyMoneyMoney(moCanPrice));
   makePrice("JPY", QDate(2004, 1, 1), MyMoneyMoney(moJpyPrice));
   makePrice("JPY", QDate(2004, 5, 1), MyMoneyMoney(moJpyPrice2));
   makePrice("JPY", QDate(2004, 6, 30), MyMoneyMoney(moJpyPrice3));
   makePrice("JPY", QDate(2004, 7, 15), MyMoneyMoney(moJpyPrice4));
 
   TransactionHelper t1(QDate(2004, 2, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t2(QDate(2004, 3, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t3(QDate(2004, 4, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t4(QDate(2004, 2, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
   TransactionHelper t5(QDate(2004, 3, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
   TransactionHelper t6(QDate(2004, 4, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
 
 #if 0
   QFile g("multicurrencykmy.xml");
   g.open(QIODevice::WriteOnly);
   MyMoneyStorageXML xml;
   IMyMoneyOperationsFormat& interface = xml;
   interface.writeFile(&g, dynamic_cast<IMyMoneySerialization*>(MyMoneyFile::instance()->storage()));
   g.close();
 #endif
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setConvertCurrency(true);
   filter.setName("Multiple Currency Spending Rerport (with currency conversion)");
   XMLandback(filter);
 
   PivotTable spending_f(filter);
 
   writeTabletoCSV(spending_f);
 
   // test single foreign currency
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][1] == (moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][2] == (moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][3] == (moCanTransaction*moCanPrice));
 
   // test multiple foreign currencies under a common parent
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][1] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][2] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][3] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"].m_total[eActual][1] == (moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"].m_total[eActual].m_total == (moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice + moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice + moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice));
 
   // Test the report type where we DO NOT convert the currency
   filter.setConvertCurrency(false);
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setName("Multiple Currency Spending Report (WITHOUT currency conversion)");
   XMLandback(filter);
   PivotTable spending_fnc(filter);
   writeTabletoCSV(spending_fnc);
 
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][1] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][2] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acCanCash)][eActual][3] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][1] == (moJpyTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][2] == (moJpyTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][ReportAccount(acJpyCash)][eActual][3] == (moJpyTransaction));
 
   filter.setConvertCurrency(true);
   filter.clearTransactionFilter();
   filter.setName("Multiple currency net worth");
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoCSV(networth_f);
 
   // test single foreign currency
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][ReportAccount(acCanChecking)][eActual][1] == (moCanOpening*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][ReportAccount(acCanChecking)][eActual][2] == ((moCanOpening - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][ReportAccount(acCanChecking)][eActual][3] == ((moCanOpening - moCanTransaction - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][ReportAccount(acCanChecking)][eActual][4] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][ReportAccount(acCanChecking)][eActual][12] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice));
 
   // test Stable currency price, fluctuating account balance
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][1] == (moJpyOpening*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][2] == ((moJpyOpening - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][3] == ((moJpyOpening - moJpyTransaction - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][4] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice));
 
   // test Fluctuating currency price, stable account balance
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][5] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice2));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][6] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice3));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][ReportAccount(acJpyChecking)][eActual][7] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice4));
 
   // test multiple currencies totalled up
   QVERIFY(networth_f.m_grid["Asset"].m_total[eActual][4] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice) + ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"].m_total[eActual][5] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice) + ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice2) + moCheckingOpen);
 
 }
 
 void PivotTableTest::testAdvancedFilter()
 {
   // test more advanced filtering capabilities
 
   // amount
   {
     TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setAmountFilter(moChild, moChild);
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moChild);
   }
 
   // payee (specific)
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moThomas, acCredit, acParent, QString(), "Thomas Baumgart");
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addPayee(MyMoneyFile::instance()->payeeByName("Thomas Baumgart").id());
     filter.setName("Spending with Payee Filter");
     XMLandback(filter);
     PivotTable spending_f(filter);
     writeTabletoHTML(spending_f, "Spending with Payee Filter.html");
 
     QVERIFY(spending_f.m_grid["Expense"]["Parent"][ReportAccount(acParent)][eActual][10] == moThomas);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moThomas);
   }
   // payee (no payee)
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moNoPayee, acCredit, acParent, QString(), QString());
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addPayee(QString());
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid["Expense"]["Parent"][ReportAccount(acParent)][eActual][10] == moNoPayee);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moNoPayee);
   }
 
   // text
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moThomas, acCredit, acParent, QString(), "Thomas Baumgart");
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setTextFilter(QRegExp("Thomas"));
     XMLandback(filter);
     PivotTable spending_f(filter);
   }
 
   // type (payment, deposit, transfer)
   {
     TransactionHelper t1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit), -moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer), moChild, acCredit, acChecking);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.addType((int)eMyMoney::TransactionFilter::Type::Payments);
     XMLandback(filter);
     PivotTable spending_f(filter);
 
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 
     filter.clearTransactionFilter();
     filter.addType((int)eMyMoney::TransactionFilter::Type::Deposits);
     XMLandback(filter);
     PivotTable spending_f2(filter);
 
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == moParent1);
 
     filter.clearTransactionFilter();
     filter.addType((int)eMyMoney::TransactionFilter::Type::Transfers);
     XMLandback(filter);
     PivotTable spending_f3(filter);
 
     QVERIFY(spending_f3.m_grid.m_total[eActual].m_total == moZero);
 
     filter.setRowType(MyMoneyReport::eAssetLiability);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31));
     XMLandback(filter);
     PivotTable networth_f4(filter);
 
     QVERIFY(networth_f4.m_grid["Asset"].m_total[eActual][11] == moCheckingOpen + moChild);
     QVERIFY(networth_f4.m_grid["Liability"].m_total[eActual][11] == - moCreditOpen + moChild);
     QVERIFY(networth_f4.m_grid.m_total[eActual][9] == moCheckingOpen + moCreditOpen);
     QVERIFY(networth_f4.m_grid.m_total[eActual][10] == moCheckingOpen + moCreditOpen);
   }
 
   // state (reconciled, cleared, not)
   {
     TransactionHelper t1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     QList<MyMoneySplit> splits = t1.splits();
     splits[0].setReconcileFlag(eMyMoney::Split::State::Cleared);
     splits[1].setReconcileFlag(eMyMoney::Split::State::Cleared);
     t1.modifySplit(splits[0]);
     t1.modifySplit(splits[1]);
     t1.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setReconcileFlag(eMyMoney::Split::State::Reconciled);
     splits[1].setReconcileFlag(eMyMoney::Split::State::Reconciled);
     t2.modifySplit(splits[0]);
     t2.modifySplit(splits[1]);
     t2.update();
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
     XMLandback(filter);
     PivotTable spending_f(filter);
 
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 
     filter.addState((int)eMyMoney::TransactionFilter::State::Reconciled);
     XMLandback(filter);
     PivotTable spending_f2(filter);
 
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == -moSolo - moParent1);
 
     filter.clearTransactionFilter();
     filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
     XMLandback(filter);
     PivotTable spending_f3(filter);
 
     QVERIFY(spending_f3.m_grid.m_total[eActual].m_total == -moChild - moParent2);
   }
 
   // number
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     QList<MyMoneySplit> splits = t1.splits();
     splits[0].setNumber("1");
     splits[1].setNumber("1");
     t1.modifySplit(splits[0]);
     t1.modifySplit(splits[1]);
     t1.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setNumber("2");
     splits[1].setNumber("2");
     t2.modifySplit(splits[0]);
     t2.modifySplit(splits[1]);
     t2.update();
 
     splits.clear();
     splits = t3.splits();
     splits[0].setNumber("3");
     splits[1].setNumber("3");
     t3.modifySplit(splits[0]);
     t3.modifySplit(splits[1]);
     t3.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setNumber("4");
     splits[1].setNumber("4");
     t4.modifySplit(splits[0]);
     t4.modifySplit(splits[1]);
     t4.update();
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setNumberFilter("1", "3");
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2);
   }
 
   // blank dates
   {
     TransactionHelper t1y1(QDate(2003, 10, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y1(QDate(2003, 11, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y1(QDate(2003, 12, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
     TransactionHelper t1y2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
     TransactionHelper t1y3(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y3(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y3(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(), QDate(2004, 7, 1));
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2);
 
     filter.clearTransactionFilter();
     XMLandback(filter);
     PivotTable spending_f2(filter);
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2);
 
   }
 
 }
 
 void PivotTableTest::testColumnType()
 {
   // test column type values of other than 'month'
 
   TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2003, 12, 31), QDate(2005, 12, 31));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setColumnType(MyMoneyReport::eBiMonths);
   XMLandback(filter);
   PivotTable spending_b(filter);
 
   QVERIFY(spending_b.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][1] == -moParent1 - moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][2] == -moParent2 - moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][3] == -moParent);
   QVERIFY(spending_b.m_grid.m_total[eActual][4] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][5] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][6] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][7] == -moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][8] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][9] == -moParent1);
   QVERIFY(spending_b.m_grid.m_total[eActual][10] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][11] == -moParent2);
   QVERIFY(spending_b.m_grid.m_total[eActual][12] == moZero);
 
   filter.setColumnType(MyMoneyReport::eQuarters);
   XMLandback(filter);
   PivotTable spending_q(filter);
 
   QVERIFY(spending_q.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][1] == -moSolo - moParent);
   QVERIFY(spending_q.m_grid.m_total[eActual][2] == -moSolo - moParent);
   QVERIFY(spending_q.m_grid.m_total[eActual][3] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][4] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][5] == -moSolo);
   QVERIFY(spending_q.m_grid.m_total[eActual][6] == -moParent1);
   QVERIFY(spending_q.m_grid.m_total[eActual][7] == -moParent2);
   QVERIFY(spending_q.m_grid.m_total[eActual][8] == moZero);
 
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setName("Net Worth by Quarter");
   XMLandback(filter);
   PivotTable networth_q(filter);
   writeTabletoHTML(networth_q, "Net Worth by Quarter.html");
 
   QVERIFY(networth_q.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(networth_q.m_grid.m_total[eActual][2] == -moSolo - moParent);
   QVERIFY(networth_q.m_grid.m_total[eActual][3] == -moSolo - moParent - moSolo - moParent + moCheckingOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][4] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][5] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][6] == -moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][7] == -moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][8] == -moParent2 - moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][9] == -moParent2 - moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
 
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setColumnType(MyMoneyReport::eYears);
   XMLandback(filter);
   PivotTable spending_y(filter);
 
   QVERIFY(spending_y.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(spending_y.m_grid.m_total[eActual][1] == -moSolo - moParent - moSolo - moParent);
   QVERIFY(spending_y.m_grid.m_total[eActual][2] == -moSolo - moParent);
   QVERIFY(spending_y.m_grid.m_total[eActual].m_total == -moSolo - moParent - moSolo - moParent - moSolo - moParent);
 
   filter.setRowType(MyMoneyReport::eAssetLiability);
   XMLandback(filter);
   PivotTable networth_y(filter);
 
   QVERIFY(networth_y.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(networth_y.m_grid.m_total[eActual][2] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_y.m_grid.m_total[eActual][3] == -moSolo - moParent - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
 
   // Test days-based reports
 
   TransactionHelper t1d1(QDate(2004, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2d1(QDate(2004, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3d1(QDate(2004, 7, 4), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   TransactionHelper t1d2(QDate(2004, 7, 14), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2d2(QDate(2004, 7, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3d2(QDate(2004, 7, 20), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   TransactionHelper t1d3(QDate(2004, 8, 2), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
   TransactionHelper t2d3(QDate(2004, 8, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
   TransactionHelper t3d3(QDate(2004, 8, 4), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
 
   filter.setDateFilter(QDate(2004, 7, 2), QDate(2004, 7, 14));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setColumnType(MyMoneyReport::eMonths);
   filter.setColumnsAreDays(true);
   filter.setName("Spending by Days");
 
   XMLandback(filter);
   PivotTable spending_days(filter);
   writeTabletoHTML(spending_days, "Spending by Days.html");
 
   QVERIFY(spending_days.m_grid.m_total[eActual][2] == -moParent2);
   QVERIFY(spending_days.m_grid.m_total[eActual][12] == -moSolo);
   QVERIFY(spending_days.m_grid.m_total[eActual].m_total == -moSolo - moParent2);
 
   // set the first day of the week to 1
   QLocale::setDefault(QLocale(QLocale::English, QLocale::UnitedKingdom));
 
   filter.setDateFilter(QDate(2004, 7, 2), QDate(2004, 8, 1));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setColumnType(static_cast<MyMoneyReport::EColumnType>(7));
   filter.setColumnsAreDays(true);
   filter.setName("Spending by Weeks");
 
   XMLandback(filter);
   PivotTable spending_weeks(filter);
   writeTabletoHTML(spending_weeks, "Spending by Weeks.html");
 
   // restore the locale
   QLocale::setDefault(QLocale::system());
 
   QVERIFY(spending_weeks.m_grid.m_total[eActual][0] == -moParent2);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][2] == -moSolo - moParent1);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][3] == -moParent2);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][4] == moZero);
   QVERIFY(spending_weeks.m_grid.m_total[eActual].m_total == -moSolo - moParent - moParent2);
 
 }
 
 void PivotTableTest::testInvestment()
 {
   try {
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
     eqStock2 = makeEquity("Stock2", "STK2");
 
     // Accounts
     acInvestment = makeAccount("Investment", eMyMoney::Account::Type::Investment, moZero, QDate(2004, 1, 1), acAsset);
     acStock1 = makeAccount("Stock 1", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock1);
     acStock2 = makeAccount("Stock 2", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock2);
     acDividends = makeAccount("Dividends", eMyMoney::Account::Type::Income, moZero, QDate(2004, 1, 1), acIncome);
 
     // Transactions
     //                         Date             Action                                              Shares                 Price   Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1b2(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(110.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(120.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1r1(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(100.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1r2(QDate(2004, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(80.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1c1(QDate(2004, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(100.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1c2(QDate(2004, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(120.00), acStock1, acChecking, acDividends);
 
     makeEquityPrice(eqStock1, QDate(2004, 10, 1), MyMoneyMoney(100.00));
 
     //
     // Net Worth Report (with investments)
     //
 
     MyMoneyReport networth_r;
     networth_r.setRowType(MyMoneyReport::eAssetLiability);
     networth_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31).addDays(-1));
     XMLandback(networth_r);
     PivotTable networth(networth_r);
 
     networth.dump("networth_i.html");
 
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][1] == moZero);
     // 1000 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][2] == MyMoneyMoney(100000.0));
     // 2000 shares @ $110.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][3] == MyMoneyMoney(220000.0));
     // 1800 shares @ $120.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][4] == MyMoneyMoney(216000.0));
     // 1600 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][5] == MyMoneyMoney(160000.0));
     // 1650 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][6] == MyMoneyMoney(165000.0));
     // 1700 shares @ $ 80.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][7] == MyMoneyMoney(136000.0));
     // 1700 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][8] == MyMoneyMoney(170000.0));
     // 1700 shares @ $120.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][9] == MyMoneyMoney(204000.0));
     // 1700 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][10] == MyMoneyMoney(170000.0));
 
 #if 0
     // Dump file & reports
     QFile g("investmentkmy.xml");
     g.open(QIODevice::WriteOnly);
     MyMoneyStorageXML xml;
     IMyMoneyOperationsFormat& interface = xml;
     interface.writeFile(&g, dynamic_cast<IMyMoneySerialization*>(MyMoneyFile::instance()->storage()));
     g.close();
 
     invtran.dump("invtran.html", "<html><head></head><body>%1</body></html>");
     invhold.dump("invhold.html", "<html><head></head><body>%1</body></html>");
 #endif
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 void PivotTableTest::testBudget()
 {
 
   // 1. Budget on A, transactions on A
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSolo, false, MyMoneyMoney(100.0));
 
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
                          MyMoneyReport::eMonths,
                          eMyMoney::TransactionFilter::Date::YearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   // 2. Budget on B, not applying to sub accounts, transactions on B and B:1
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, false, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
                          MyMoneyReport::eMonths,
                          eMyMoney::TransactionFilter::Date::YearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Both B and B:1 totals should show up
   //  - B actuals compare against B budget
   //  - B:1 actuals compare against 0
 
   // 3. Budget on C, applying to sub accounts, transactions on C and C:1 and C:1:a
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, true, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
                          MyMoneyReport::eMonths,
                          eMyMoney::TransactionFilter::Date::YearToDate,
                          MyMoneyReport::eDetailTop ,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Only C totals show up, not C:1 or C:1:a totals
   //  - C + C:1 totals compare against C budget
 
   // 4. Budget on D, not applying to sub accounts, budget on D:1 not applying, budget on D:2 applying.  Transactions on D, D:1, D:2, D:2:a, D:2:b
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, false, MyMoneyMoney(100.0));
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acChild, false, MyMoneyMoney(100.0));
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSecondChild, true, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
                          MyMoneyReport::eMonths,
                          eMyMoney::TransactionFilter::Date::YearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Totals for D, D:1, D:2 show up.  D:2:a and D:2:b do not
   //  - D actuals (only) compare against D budget
   //  - Ditto for D:1
   //  - D:2 acutals and children compare against D:2 budget
 
   // 5. Budget on E, no transactions on E
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSolo, false, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
                          MyMoneyReport::eMonths,
                          eMyMoney::TransactionFilter::Date::YearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 }
 
 void PivotTableTest::testHtmlEncoding()
 {
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
 
   QByteArray encoding = QTextCodec::codecForLocale()->name();
 
   QString html = networth_f.renderReport(QLatin1String("html"), encoding,
                                              filter.name(), false);
 
   QRegExp rx(QString::fromLatin1("*<meta * charset=" + encoding + "*>*"));
   rx.setPatternSyntax(QRegExp::Wildcard);
   rx.setCaseSensitivity(Qt::CaseInsensitive);
   QVERIFY(rx.exactMatch(html));
 }
diff --git a/kmymoney/reports/tests/querytable-test.cpp b/kmymoney/reports/tests/querytable-test.cpp
index d0b56de0f..9944c03d3 100644
--- a/kmymoney/reports/tests/querytable-test.cpp
+++ b/kmymoney/reports/tests/querytable-test.cpp
@@ -1,904 +1,904 @@
 /***************************************************************************
                           querytabletest.cpp
                           -------------------
     copyright            : (C) 2002 by Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "querytable-test.h"
 
 #include <QFile>
 #include <QTest>
 
 #include <KLocalizedString>
 
 #include "reportstestcommon.h"
 #include "querytable.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneystoragedump.h"
 #include "mymoneyreport.h"
 #include "mymoneysplit.h"
 #include "mymoneypayee.h"
 #include "mymoneystatement.h"
 #include "mymoneystoragexml.h"
 #include "mymoneyexception.h"
 #include "kmymoneysettings.h"
 
 using namespace reports;
 using namespace test;
 
 QTEST_GUILESS_MAIN(QueryTableTest)
 
 void QueryTableTest::setup()
 {
 }
 
 void QueryTableTest::init()
 {
   storage = new MyMoneyStorageMgr;
   file = MyMoneyFile::instance();
   file->attachStorage(storage);
   MyMoneyFileTransaction ft;
   file->addCurrency(MyMoneySecurity("CAD", "Canadian Dollar",        "C$"));
   file->addCurrency(MyMoneySecurity("USD", "US Dollar",              "$"));
   file->addCurrency(MyMoneySecurity("JPY", "Japanese Yen",           QChar(0x00A5), 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2("Thomas Baumgart");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount(QString("Checking Account"), eMyMoney::Account::Type::Checkings, moCheckingOpen, QDate(2004, 5, 15), acAsset);
   acCredit = makeAccount(QString("Credit Card"), eMyMoney::Account::Type::CreditCard, moCreditOpen, QDate(2004, 7, 15), acLiability);
   acSolo = makeAccount(QString("Solo"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acParent = makeAccount(QString("Parent"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acChild = makeAccount(QString("Child"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acForeign = makeAccount(QString("Foreign"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acTax = makeAccount(QString("Tax"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2005, 1, 11), acExpense, "", true);
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 }
 
 void QueryTableTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void QueryTableTest::testQueryBasics()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     unsigned cols;
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eCategory);
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     filter.setName("Transactions by Category");
     XMLandback(filter);
     QueryTable qtbl_1(filter);
 
     writeTabletoHTML(qtbl_1, "Transactions by Category.html");
 
     QList<ListTable::TableRow> rows = qtbl_1.rows();
 
     QVERIFY(rows.count() == 19);
     QVERIFY(rows[0][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[0][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-02-01");
     QVERIFY(rows[14][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[14][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[14][ListTable::ctPostDate] == "2005-01-01");
 
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == -(moParent1 + moParent2) * 3);
     QVERIFY(MyMoneyMoney(rows[10][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[16][ListTable::ctValue]) == -(moSolo) * 3);
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[18][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(MyMoneyReport::eTopCategory);
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     filter.setName("Transactions by Top Category");
     XMLandback(filter);
     QueryTable qtbl_2(filter);
 
     writeTabletoHTML(qtbl_2, "Transactions by Top Category.html");
 
     rows = qtbl_2.rows();
 
     QVERIFY(rows.count() == 16);
     QVERIFY(rows[0][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[0][ListTable::ctTopCategory] == "Parent");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-02-01");
     QVERIFY(rows[8][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[8][ListTable::ctTopCategory] == "Parent");
     QVERIFY(rows[8][ListTable::ctPostDate] == "2005-09-01");
     QVERIFY(rows[12][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[12][ListTable::ctTopCategory] == "Solo");
     QVERIFY(rows[12][ListTable::ctPostDate] == "2005-01-01");
 
     QVERIFY(MyMoneyMoney(rows[9][ListTable::ctValue]) == -(moParent1 + moParent2 + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[13][ListTable::ctValue]) == -(moSolo) * 3);
     QVERIFY(MyMoneyMoney(rows[14][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(MyMoneyReport::eAccount);
     filter.setName("Transactions by Account");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account.html");
 
     rows = qtbl_3.rows();
 
 #if 1
     QVERIFY(rows.count() == 19);
     QVERIFY(rows[1][ListTable::ctAccount] == "Checking Account");
     QVERIFY(rows[1][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[1][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[15][ListTable::ctAccount] == "Credit Card");
     QVERIFY(rows[15][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[15][ListTable::ctPostDate] == "2005-09-01");
 #else
     QVERIFY(rows.count() == 12);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[11][ListTable::ctAccount] == "Credit Card");
     QVERIFY(rows[11][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[11][ListTable::ctPostDate] == "2005-09-01");
 #endif
 
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == -(moSolo) * 3 + moCheckingOpen);
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == -(moParent1 + moParent2 + moChild) * 3 + moCreditOpen);
     QVERIFY(MyMoneyMoney(rows[18][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(MyMoneyReport::ePayee);
     filter.setName("Transactions by Payee");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCmemo | MyMoneyReport::eQCcategory;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_4(filter);
 
     writeTabletoHTML(qtbl_4, "Transactions by Payee.html");
 
     rows = qtbl_4.rows();
 
     QVERIFY(rows.count() == 14);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[7][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[7][ListTable::ctCategory] == "Parent: Child");
     QVERIFY(rows[7][ListTable::ctPostDate] == "2004-11-07");
     QVERIFY(rows[11][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[11][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[11][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[12][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[13][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(MyMoneyReport::eMonth);
     filter.setName("Transactions by Month");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_5(filter);
 
     writeTabletoHTML(qtbl_5, "Transactions by Month.html");
 
     rows = qtbl_5.rows();
 
     QVERIFY(rows.count() == 23);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[12][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[12][ListTable::ctCategory] == "Parent: Child");
     QVERIFY(rows[12][ListTable::ctPostDate] == "2004-11-07");
     QVERIFY(rows[20][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[20][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[20][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == -moSolo);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[9][ListTable::ctValue]) == -moParent1 + moCheckingOpen);
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(MyMoneyReport::eWeek);
     filter.setName("Transactions by Week");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_6(filter);
 
     writeTabletoHTML(qtbl_6, "Transactions by Week.html");
 
     rows = qtbl_6.rows();
 
     QVERIFY(rows.count() == 23);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[20][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[20][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[20][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == -moSolo);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[21][ListTable::ctValue]) == -moParent2);
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 
   // Test querytable::TableRow::operator> and operator==
 
   QueryTable::TableRow low;
   low[ListTable::ctPrice] = 'A';
   low[ListTable::ctLastPrice] = 'B';
   low[ListTable::ctBuyPrice] = 'C';
 
   QueryTable::TableRow high;
   high[ListTable::ctPrice] = 'A';
   high[ListTable::ctLastPrice] = 'C';
   high[ListTable::ctBuyPrice] = 'B';
 
   QueryTable::TableRow::setSortCriteria({ListTable::ctPrice, ListTable::ctLastPrice, ListTable::ctBuyPrice});
   QVERIFY(low < high);
   QVERIFY(low <= high);
   QVERIFY(high > low);
   QVERIFY(high <= high);
   QVERIFY(high == high);
 }
 
 void QueryTableTest::testCashFlowAnalysis()
 {
   //
   // Test IRR calculations
   //
 
   CashFlowList list;
 
   list += CashFlowListItem(QDate(2004, 5, 3), MyMoneyMoney(1000.0));
   list += CashFlowListItem(QDate(2004, 5, 20), MyMoneyMoney(59.0));
   list += CashFlowListItem(QDate(2004, 6, 3), MyMoneyMoney(14.0));
   list += CashFlowListItem(QDate(2004, 6, 24), MyMoneyMoney(92.0));
   list += CashFlowListItem(QDate(2004, 7, 6), MyMoneyMoney(63.0));
   list += CashFlowListItem(QDate(2004, 7, 25), MyMoneyMoney(15.0));
   list += CashFlowListItem(QDate(2004, 8, 5), MyMoneyMoney(92.0));
   list += CashFlowListItem(QDate(2004, 9, 2), MyMoneyMoney(18.0));
   list += CashFlowListItem(QDate(2004, 9, 21), MyMoneyMoney(5.0));
   list += CashFlowListItem(QDate(2004, 10, 16), MyMoneyMoney(-2037.0));
 
   MyMoneyMoney IRR(list.IRR(), 1000);
 
   QVERIFY(IRR == MyMoneyMoney(1676, 1000));
 
   list.pop_back();
   list += CashFlowListItem(QDate(2004, 10, 16), MyMoneyMoney(-1358.0));
 
   IRR = MyMoneyMoney(list.IRR(), 1000);
 
   QVERIFY(IRR.isZero());
 }
 
 void QueryTableTest::testAccountQuery()
 {
   try {
     QString htmlcontext = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\">\n<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"html/kmymoney.css\"></head><body>\n%1\n</body></html>\n");
 
     //
     // No transactions, opening balances only
     //
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eInstitution);
     filter.setName("Accounts by Institution (No transactions)");
     XMLandback(filter);
     QueryTable qtbl_1(filter);
 
     writeTabletoHTML(qtbl_1, "Accounts by Institution (No transactions).html");
 
     QList<ListTable::TableRow> rows = qtbl_1.rows();
 
     QVERIFY(rows.count() == 6);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == moCheckingOpen);
     QVERIFY(rows[0][ListTable::ctEquityType].isEmpty());
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == moCreditOpen);
     QVERIFY(rows[2][ListTable::ctEquityType].isEmpty());
 
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == moCheckingOpen + moCreditOpen);
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == moCheckingOpen + moCreditOpen);
 
     //
     // Adding in transactions
     //
 
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     filter.setRowType(MyMoneyReport::eInstitution);
     filter.setName("Accounts by Institution (With Transactions)");
     XMLandback(filter);
     QueryTable qtbl_2(filter);
 
     rows = qtbl_2.rows();
 
     QVERIFY(rows.count() == 6);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == (moCheckingOpen - moSolo*3));
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == (moCreditOpen - (moParent1 + moParent2 + moChild) * 3));
 
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == moCheckingOpen + moCreditOpen - (moParent1 + moParent2 + moSolo + moChild) * 3);
 
     //
     // Account TYPES
     //
 
     filter.setRowType(MyMoneyReport::eAccountType);
     filter.setName("Accounts by Type");
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == (moCheckingOpen - moSolo * 3));
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == (moCreditOpen - (moParent1 + moParent2 + moChild) * 3));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == moCheckingOpen - moSolo * 3);
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == moCreditOpen - (moParent1 + moParent2 + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == moCheckingOpen + moCreditOpen - (moParent1 + moParent2 + moSolo + moChild) * 3);
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 void QueryTableTest::testInvestment()
 {
   try {
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
     eqStock2 = makeEquity("Stock2", "STK2");
     eqStock3 = makeEquity("Stock3", "STK3");
     eqStock4 = makeEquity("Stock4", "STK4");
 
     // Accounts
     acInvestment = makeAccount("Investment", eMyMoney::Account::Type::Investment, moZero, QDate(2003, 11, 1), acAsset);
     acStock1 = makeAccount("Stock 1", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock1);
     acStock2 = makeAccount("Stock 2", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock2);
     acStock3 = makeAccount("Stock 3", eMyMoney::Account::Type::Stock, moZero, QDate(2003, 11, 1), acInvestment, eqStock3);
     acStock4 = makeAccount("Stock 4", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock4);
     acDividends = makeAccount("Dividends", eMyMoney::Account::Type::Income, moZero, QDate(2004, 1, 1), acIncome);
     acInterest = makeAccount("Interest", eMyMoney::Account::Type::Income, moZero, QDate(2004, 1, 1), acIncome);
     acFees = makeAccount("Fees", eMyMoney::Account::Type::Expense, moZero, QDate(2003, 11, 1), acExpense);
 
     // Transactions
     //                         Date             Action                                               Shares                Price   Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2003, 12, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock3, acChecking, QString());
     InvTransactionHelper s1b2(QDate(2004, 1, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(500.00), MyMoneyMoney(100.00), acStock4, acChecking, acFees, MyMoneyMoney(100.00));
     InvTransactionHelper s1b3(QDate(2004, 1, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(500.00), MyMoneyMoney(90.00), acStock4, acChecking, acFees, MyMoneyMoney(100.00));
     InvTransactionHelper s1b4(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1b5(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(110.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(120.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s3(QDate(2004, 5, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-1000.00), MyMoneyMoney(120.00), acStock4, acChecking, acFees, MyMoneyMoney(200.00));
     InvTransactionHelper s1r1(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(100.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1r2(QDate(2004, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(80.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1c1(QDate(2004, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(100.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1c2(QDate(2004, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(120.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1y1(QDate(2004, 9, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Yield),           MyMoneyMoney(10.00), MyMoneyMoney(110.00), acStock1, acChecking, acInterest);
 
     makeEquityPrice(eqStock1, QDate(2004, 10, 1), MyMoneyMoney(100.00));
     makeEquityPrice(eqStock3, QDate(2004, 10, 1), MyMoneyMoney(110.00));
     makeEquityPrice(eqStock4, QDate(2004, 10, 1), MyMoneyMoney(110.00));
 
     //
     // Investment Transactions Report
     //
 
     MyMoneyReport invtran_r(
       MyMoneyReport::eTopAccount,
       MyMoneyReport::eQCaction | MyMoneyReport::eQCshares | MyMoneyReport::eQCprice,
       eMyMoney::TransactionFilter::Date::UserDefined,
       MyMoneyReport::eDetailAll,
       i18n("Investment Transactions"),
       i18n("Test Report")
     );
     invtran_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31));
     invtran_r.setInvestmentsOnly(true);
     XMLandback(invtran_r);
     QueryTable invtran(invtran_r);
 
 #if 1
     writeTabletoHTML(invtran, "investment_transactions_test.html");
 
     QList<ListTable::TableRow> rows = invtran.rows();
 
     QVERIFY(rows.count() == 32);
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == MyMoneyMoney(-100000.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == MyMoneyMoney(-110000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == MyMoneyMoney(24000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == MyMoneyMoney(20000.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == MyMoneyMoney(5000.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == MyMoneyMoney(4000.00));
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctValue]) == MyMoneyMoney(-50100.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == MyMoneyMoney(-45100.00));
     // need to fix these... fundamentally different from the original test
     //QVERIFY(MyMoneyMoney(invtran.m_rows[8][ListTable::ctValue])==MyMoneyMoney( -1000.00));
     //QVERIFY(MyMoneyMoney(invtran.m_rows[11][ListTable::ctValue])==MyMoneyMoney( -1200.00));
     //QVERIFY(MyMoneyMoney(invtran.m_rows[14][ListTable::ctValue])==MyMoneyMoney( -1100.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctPrice]) == MyMoneyMoney(120.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctPrice]) == MyMoneyMoney());
     QVERIFY(MyMoneyMoney(rows[10][ListTable::ctPrice]) == MyMoneyMoney());
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctPrice]) == MyMoneyMoney(90.00));
 
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctShares]) == MyMoneyMoney(1000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctShares]) == MyMoneyMoney(-200.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctShares]) == MyMoneyMoney(50.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[11][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctShares]) == MyMoneyMoney(500.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctShares]) == MyMoneyMoney(500.00));
 
     QVERIFY(rows[1][ListTable::ctAction] == "Buy");
     QVERIFY(rows[3][ListTable::ctAction] == "Sell");
     QVERIFY(rows[5][ListTable::ctAction] == "Reinvest");
     QVERIFY(rows[7][ListTable::ctAction] == "Dividend");
     QVERIFY(rows[13][ListTable::ctAction] == "Yield");
     QVERIFY(rows[19][ListTable::ctAction] == "Buy");
     QVERIFY(rows[22][ListTable::ctAction] == "Buy");
 #else
     QVERIFY(rows.count() == 9);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == MyMoneyMoney(100000.00));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == MyMoneyMoney(110000.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == MyMoneyMoney(-24000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == MyMoneyMoney(-20000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == MyMoneyMoney(5000.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == MyMoneyMoney(4000.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == MyMoneyMoney(-1000.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctValue]) == MyMoneyMoney(-1200.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctValue]) == MyMoneyMoney(-1100.00));
 
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctPrice]) == MyMoneyMoney(120.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctPrice]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctPrice]) == MyMoneyMoney(0.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctShares]) == MyMoneyMoney(1000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctShares]) == MyMoneyMoney(-200.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctShares]) == MyMoneyMoney(50.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctShares]) == MyMoneyMoney(0.00));
 
     QVERIFY(rows[0][ListTable::ctAction] == "Buy");
     QVERIFY(rows[2][ListTable::ctAction] == "Sell");
     QVERIFY(rows[4][ListTable::ctAction] == "Reinvest");
     QVERIFY(rows[6][ListTable::ctAction] == "Dividend");
     QVERIFY(rows[8][ListTable::ctAction] == "Yield");
 #endif
 
 #if 1
     // i think this is the correct amount. different treatment of dividend and yield
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == MyMoneyMoney(-153700.00));
     QVERIFY(MyMoneyMoney(rows[29][ListTable::ctValue]) == MyMoneyMoney(24600.00));
     QVERIFY(MyMoneyMoney(rows[31][ListTable::ctValue]) == MyMoneyMoney(-129100.00));
 #else
     QVERIFY(searchHTML(html, i18n("Total Stock 1")) == MyMoneyMoney(171700.00));
     QVERIFY(searchHTML(html, i18n("Grand Total")) == MyMoneyMoney(171700.00));
 #endif
 
     //
     // Investment Performance Report
     //
 
     MyMoneyReport invhold_r(
       MyMoneyReport::eAccountByTopAccount,
       MyMoneyReport::eQCperformance,
       eMyMoney::TransactionFilter::Date::UserDefined,
       MyMoneyReport::eDetailAll,
       i18n("Investment Performance by Account"),
       i18n("Test Report")
     );
     invhold_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 10, 1));
     invhold_r.setInvestmentsOnly(true);
     XMLandback(invhold_r);
     QueryTable invhold(invhold_r);
 
     writeTabletoHTML(invhold, "Investment Performance by Account.html");
 
     rows = invhold.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReturn]) == MyMoneyMoney("669/10000"));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReturnInvestment]) == MyMoneyMoney("-39/5000"));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctBuys]) == MyMoneyMoney(-210000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctSells]) == MyMoneyMoney(44000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReinvestIncome]) == MyMoneyMoney(9000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctCashIncome]) == MyMoneyMoney(3300.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctReturn]) == MyMoneyMoney("1349/10000"));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctReturnInvestment]) == MyMoneyMoney("1/10"));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctStartingBalance]) == MyMoneyMoney(100000.00)); // this should stay non-zero to check if investment performance is calculated at non-zero starting balance
 
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctReturn]) == MyMoneyMoney("2501/2500"));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctReturnInvestment]) == MyMoneyMoney("323/1250"));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctBuys]) == MyMoneyMoney(-95200.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctSells]) == MyMoneyMoney(119800.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctEndingBalance]) == MyMoneyMoney(0.00)); // this should stay zero to check if investment performance is calculated at zero ending balance
 
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctEndingBalance]) == MyMoneyMoney(280000.00));
 
 #if 0
     // Dump file & reports
     QFile g("investmentkmy.xml");
     g.open(QIODevice::WriteOnly);
     MyMoneyStorageXML xml;
     IMyMoneyOperationsFormat& interface = xml;
     interface.writeFile(&g, dynamic_cast<IMyMoneySerialization*>(MyMoneyFile::instance()->storage()));
     g.close();
 
     invtran.dump("invtran.html", "<html><head></head><body>%1</body></html>");
     invhold.dump("invhold.html", "<html><head></head><body>%1</body></html>");
 #endif
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 // prevents bug #312135
 void QueryTableTest::testSplitShares()
 {
   try {
     MyMoneyMoney firstSharesPurchase(16);
     MyMoneyMoney splitFactor(2);
     MyMoneyMoney secondSharesPurchase(1);
     MyMoneyMoney sharesAtTheEnd = firstSharesPurchase / splitFactor + secondSharesPurchase;
     MyMoneyMoney priceBeforeSplit(74.99, 100);
     MyMoneyMoney priceAfterSplit = splitFactor * priceBeforeSplit;
 
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
 
     // Accounts
     acInvestment = makeAccount("Investment", eMyMoney::Account::Type::Investment, moZero, QDate(2017, 8, 1), acAsset);
     acStock1 =     makeAccount("Stock 1",    eMyMoney::Account::Type::Stock,      moZero, QDate(2017, 8, 1), acInvestment, eqStock1);
 
     // Transactions
     //                        Date               Action                           Shares                Price             Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2017, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),   firstSharesPurchase,  priceBeforeSplit, acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2017, 8, 2), MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares), splitFactor,          MyMoneyMoney(),   acStock1, QString(),  QString());
     InvTransactionHelper s1b2(QDate(2017, 8, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),   secondSharesPurchase, priceAfterSplit,  acStock1, acChecking, QString());
 
     //
     // Investment Performance Report
     //
 
     MyMoneyReport invhold_r(
       MyMoneyReport::eAccountByTopAccount,
       MyMoneyReport::eQCperformance,
       eMyMoney::TransactionFilter::Date::UserDefined,
       MyMoneyReport::eDetailAll,
       i18n("Investment Performance by Account"),
       i18n("Test Report")
     );
     invhold_r.setDateFilter(QDate(2017, 8, 1), QDate(2017, 8, 3));
     invhold_r.setInvestmentsOnly(true);
     XMLandback(invhold_r);
     QueryTable invhold(invhold_r);
 
     writeTabletoHTML(invhold, "Investment Performance by Account (with stock split).html");
 
     const auto rows = invhold.rows();
 
     QVERIFY(rows.count() == 3);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctBuys]) == sharesAtTheEnd * priceAfterSplit * MyMoneyMoney(-1));
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 // prevents bug #118159
 void QueryTableTest::testConversionRate()
 {
   try {
     MyMoneyMoney firsConversionRate(1.1800, 10000);
     MyMoneyMoney secondConversionRate(1.1567, 10000);
     MyMoneyMoney amountWithdrawn(100);
 
     const auto acCadChecking = makeAccount(QString("Canadian Checking"), eMyMoney::Account::Type::Checkings, moZero, QDate(2017, 8, 1), acAsset, "CAD");
 
     makePrice("CAD", QDate(2017, 8, 1), firsConversionRate);
     makePrice("CAD", QDate(2017, 8, 2), secondConversionRate);
 
     TransactionHelper t1(QDate(2017, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), amountWithdrawn, acCadChecking, acSolo, "CAD");
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eAccount);
     filter.setDateFilter(QDate(2017, 8, 1), QDate(2017, 8, 2));
     filter.setName("Transactions by Account");
     auto cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCbalance;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl(filter);
 
     writeTabletoHTML(qtbl, "Transactions by Account (conversion rate).html");
 
     const auto rows = qtbl.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == amountWithdrawn * firsConversionRate * MyMoneyMoney(-1));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctPrice]) == firsConversionRate);
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctBalance]) == amountWithdrawn * secondConversionRate * MyMoneyMoney(-1));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctPrice]) == secondConversionRate);
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 
 }
 
 //this is to prevent me from making mistakes again when modifying balances - asoliverez
 //this case tests only the opening and ending balance of the accounts
 void QueryTableTest::testBalanceColumn()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     unsigned cols;
 
     MyMoneyReport filter;
 
     filter.setRowType(MyMoneyReport::eAccount);
     filter.setName("Transactions by Account");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCbalance;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account.html");
 
     QString html = qtbl_3.renderHTML();
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 19);
 
     //this is to make sure that the dates of closing and opening balances and the balance numbers are ok
     QString openingDate = QLocale().toString(QDate(2004, 1, 1), QLocale::ShortFormat);
     QString closingDate = QLocale().toString(QDate(2005, 9, 1), QLocale::ShortFormat);
     QVERIFY(html.indexOf(openingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance")) > 0);
     QVERIFY(html.indexOf(closingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-702.36</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-705.69</td></tr>") > 0);
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 
 }
 
 void QueryTableTest::testBalanceColumnWithMultipleCurrencies()
 {
   try {
 
     MyMoneyMoney moJpyOpening(0.0, 1);
     MyMoneyMoney moJpyPrice(0.010, 100);
     MyMoneyMoney moJpyPrice2(0.011, 100);
     MyMoneyMoney moJpyPrice3(0.024, 100);
     MyMoneyMoney moTransaction(100, 1);
     MyMoneyMoney moJpyTransaction(100, 1);
 
     QString acJpyChecking = makeAccount(QString("Japanese Checking"), eMyMoney::Account::Type::Checkings, moJpyOpening, QDate(2003, 11, 15), acAsset, "JPY");
 
     makePrice("JPY", QDate(2004, 1, 1), MyMoneyMoney(moJpyPrice));
     makePrice("JPY", QDate(2004, 5, 1), MyMoneyMoney(moJpyPrice2));
     makePrice("JPY", QDate(2004, 6, 30), MyMoneyMoney(moJpyPrice3));
 
     QDate openingDate(2004, 2, 20);
     QDate intermediateDate(2004, 5, 20);
     QDate closingDate(2004, 7, 20);
 
     TransactionHelper t1(openingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t4(openingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     TransactionHelper t2(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t5(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     TransactionHelper t3(closingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t6(closingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     // test that an income/expense transaction that involves a currency exchange is properly reported
     TransactionHelper t7(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moJpyTransaction), acJpyChecking, acSolo, "JPY");
 
     unsigned cols;
 
     MyMoneyReport filter;
 
     filter.setRowType(MyMoneyReport::eAccount);
     filter.setName("Transactions by Account");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCbalance;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));
     // don't convert values to the default currency
     filter.setConvertCurrency(false);
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account (multiple currencies).html");
 
     QString html = qtbl_3.renderHTML();
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 24);
 
     //this is to make sure that the dates of closing and opening balances and the balance numbers are ok
     QString openingDateString = QLocale().toString(openingDate, QLocale::ShortFormat);
     QString intermediateDateString = QLocale().toString(intermediateDate, QLocale::ShortFormat);
     QString closingDateString = QLocale().toString(closingDate, QLocale::ShortFormat);
     // check the opening and closing balances
     QVERIFY(html.indexOf(openingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;0.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;304.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;-300.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>JPY&nbsp;-400.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 1.00 - price is 0.010 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000001>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;1.00</td><td>USD&nbsp;1.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 101.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000002>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;101.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 102.00 - price is 0.011 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000003>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;1.00</td><td>USD&nbsp;102.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 202.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000004>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;202.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 204.00 - price is 0.024 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000005>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;2.00</td><td>USD&nbsp;204.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 304.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000006>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;304.00</td></tr>") > 0);
 
     // a 100.00 JPY withdrawal should be displayed as such even if the expense account uses another currency
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000007>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Solo</td><td class=\"value\">JPY&nbsp;-100.00</td><td>JPY&nbsp;-300.00</td></tr>") > 0);
 
     // now run the same report again but this time convert all values to the base currency and make sure the values are correct
     filter.setConvertCurrency(true);
     XMLandback(filter);
     QueryTable qtbl_4(filter);
 
     writeTabletoHTML(qtbl_4, "Transactions by Account (multiple currencies converted to base).html");
 
     html = qtbl_4.renderHTML();
 
     rows = qtbl_4.rows();
 
     QVERIFY(rows.count() == 23);
 
     // check the opening and closing balances
     QVERIFY(html.indexOf(openingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;0.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;304.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-300.00</td></tr>") > 0);
     // although the balance should be -5.00 it's -8.00 because the foreign currency balance is converted using the closing date price (0.024)
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-8.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -1.00 when converted to the base currency using the opening date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000001>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-1.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -1.00 when converted to the base currency using the intermediate date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000003>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-2.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -2.00 when converted to the base currency using the closing date price (notice the balance is -5.00)
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000005>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-2.00</td><td>&nbsp;-5.00</td></tr>") > 0);
 
     // a 100.00 JPY withdrawal should be displayed as -1.00 when converted to the base currency using the intermediate date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000007>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Solo</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-3.00</td></tr>") > 0);
 
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
 
 void QueryTableTest::testTaxReport()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acChecking, acTax);
 
     unsigned cols;
     MyMoneyReport filter;
 
     filter.setRowType(MyMoneyReport::eCategory);
     filter.setName("Tax Transactions");
     cols = MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount;
     filter.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(cols));
     filter.setTax(true);
 
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Tax Transactions.html");
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QString html = qtbl_3.renderHTML();
     QVERIFY(rows.count() == 5);
   } catch (const MyMoneyException &e) {
-    QFAIL(qPrintable(e.what()));
+    QFAIL(e.what());
   }
 }
diff --git a/kmymoney/reports/tests/reportstestcommon.cpp b/kmymoney/reports/tests/reportstestcommon.cpp
index 737c6e539..739bad75c 100644
--- a/kmymoney/reports/tests/reportstestcommon.cpp
+++ b/kmymoney/reports/tests/reportstestcommon.cpp
@@ -1,497 +1,497 @@
 /***************************************************************************
                           reportstestcommon.cpp
                           -------------------
     copyright            : (C) 2002-2005 by Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "reportstestcommon.h"
 
 #include "kreportsview-test.h"
 
 #include <QList>
 #include <QFile>
 #include <QTextStream>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDebug>
 
 #include "pivottable.h"
 #include "querytable.h"
 using namespace reports;
 
 #include "mymoneyexception.h"
 #include "mymoneymoney.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneysplit.h"
 #include "mymoneystoragedump.h"
 #include "mymoneyreport.h"
 #include "mymoneypayee.h"
 #include "mymoneystatement.h"
 #include "mymoneystoragexml.h"
 
 namespace test
 {
 
 const MyMoneyMoney moCheckingOpen(0.0);
 const MyMoneyMoney moCreditOpen(-0.0);
 const MyMoneyMoney moConverterCheckingOpen(1418.0);
 const MyMoneyMoney moConverterCreditOpen(-418.0);
 const MyMoneyMoney moZero(0.0);
 const MyMoneyMoney moSolo(234.12);
 const MyMoneyMoney moParent1(88.01);
 const MyMoneyMoney moParent2(133.22);
 const MyMoneyMoney moParent(moParent1 + moParent2);
 const MyMoneyMoney moChild(14.00);
 const MyMoneyMoney moThomas(5.11);
 const MyMoneyMoney moNoPayee(8944.70);
 
 QString acAsset;
 QString acLiability;
 QString acExpense;
 QString acIncome;
 QString acChecking;
 QString acCredit;
 QString acSolo;
 QString acParent;
 QString acChild;
 QString acSecondChild;
 QString acGrandChild1;
 QString acGrandChild2;
 QString acForeign;
 QString acCanChecking;
 QString acJpyChecking;
 QString acCanCash;
 QString acJpyCash;
 QString inBank;
 QString eqStock1;
 QString eqStock2;
 QString eqStock3;
 QString eqStock4;
 QString acInvestment;
 QString acStock1;
 QString acStock2;
 QString acStock3;
 QString acStock4;
 QString acDividends;
 QString acInterest;
 QString acFees;
 QString acTax;
 QString acCash;
 
 TransactionHelper::TransactionHelper(const QDate& _date, const QString& _action, MyMoneyMoney _value, const QString& _accountid, const QString& _categoryid, const QString& _currencyid, const QString& _payee)
 {
   // _currencyid is the currency of the transaction, and of the _value
   // both the account and category can have their own currency (athough the category having
   // a foreign currency is not yet supported by the program, the reports will still allow it,
   // so it must be tested.)
   MyMoneyFile* file = MyMoneyFile::instance();
   bool haspayee = ! _payee.isEmpty();
   MyMoneyPayee payeeTest = file->payeeByName(_payee);
 
   MyMoneyFileTransaction ft;
   setPostDate(_date);
 
   QString currencyid = _currencyid;
   if (currencyid.isEmpty())
     currencyid = MyMoneyFile::instance()->baseCurrency().id();
   setCommodity(currencyid);
 
   MyMoneyMoney price;
   MyMoneySplit splitLeft;
   if (haspayee)
     splitLeft.setPayeeId(payeeTest.id());
   splitLeft.setAction(_action);
   splitLeft.setValue(-_value);
   price = MyMoneyFile::instance()->price(currencyid, file->account(_accountid).currencyId(), _date).rate(file->account(_accountid).currencyId());
   splitLeft.setShares(-_value * price);
   splitLeft.setAccountId(_accountid);
   addSplit(splitLeft);
 
   MyMoneySplit splitRight;
   if (haspayee)
     splitRight.setPayeeId(payeeTest.id());
   splitRight.setAction(_action);
   splitRight.setValue(_value);
   price = MyMoneyFile::instance()->price(currencyid, file->account(_categoryid).currencyId(), _date).rate(file->account(_categoryid).currencyId());
   splitRight.setShares(_value * price);
   splitRight.setAccountId(_categoryid);
   addSplit(splitRight);
 
   MyMoneyFile::instance()->addTransaction(*this);
   ft.commit();
 }
 
 TransactionHelper::~TransactionHelper()
 {
   MyMoneyFileTransaction ft;
   try {
     MyMoneyFile::instance()->removeTransaction(*this);
     ft.commit();
-  } catch (const MyMoneyException & e) {
+  } catch (const MyMoneyException &e) {
     qDebug() << e.what();
   }
 }
 
 void TransactionHelper::update()
 {
   MyMoneyFileTransaction ft;
   MyMoneyFile::instance()->modifyTransaction(*this);
   ft.commit();
 }
 
 InvTransactionHelper::InvTransactionHelper(const QDate& _date, const QString& _action, MyMoneyMoney _shares, MyMoneyMoney _price, const QString& _stockaccountid, const QString& _transferid, const QString& _categoryid, MyMoneyMoney _fee)
 {
   init(_date, _action, _shares, _price, _fee, _stockaccountid, _transferid, _categoryid);
 }
 
 void InvTransactionHelper::init(const QDate& _date, const QString& _action, MyMoneyMoney _shares, MyMoneyMoney _price, MyMoneyMoney _fee, const QString& _stockaccountid, const QString& _transferid, const QString& _categoryid)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyAccount stockaccount = file->account(_stockaccountid);
   MyMoneyMoney value = _shares * _price;
 
   setPostDate(_date);
 
   setCommodity("USD");
   MyMoneySplit s1;
   s1.setValue(value);
   s1.setAccountId(_stockaccountid);
 
   if (_action == MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend)) {
     s1.setShares(_shares);
     s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend));
 
     MyMoneySplit s2;
     s2.setAccountId(_categoryid);
     s2.setShares(-value);
     s2.setValue(-value);
     addSplit(s2);
   } else if (_action == MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend) || _action == MyMoneySplit::actionName(eMyMoney::Split::Action::Yield)) {
     s1.setAccountId(_categoryid);
     s1.setShares(-value);
     s1.setValue(-value);
 
     // Split 2 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.
     MyMoneySplit s2;
     s2.setValue(MyMoneyMoney());
     s2.setShares(MyMoneyMoney());
     s2.setAction(_action);
     s2.setAccountId(_stockaccountid);
     addSplit(s2);
 
     MyMoneySplit s3;
     s3.setAccountId(_transferid);
     s3.setShares(value);
     s3.setValue(value);
     addSplit(s3);
   } else if (_action == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) {
     s1.setShares(_shares);
     s1.setValue(value);
     s1.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares));
 
     MyMoneySplit s3;
     s3.setAccountId(_transferid);
     s3.setShares(-value - _fee);
     s3.setValue(-value - _fee);
     addSplit(s3);
 
     if (!_categoryid.isEmpty() && !_fee.isZero()) {
       MyMoneySplit s2;
       s2.setAccountId(_categoryid);
       s2.setValue(_fee);
       s2.setShares(_fee);
       addSplit(s2);
     }
   } else if (_action == MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares)) {
     s1.setShares(_shares.abs());
     s1.setValue(MyMoneyMoney());
     s1.setPrice(MyMoneyMoney());
   }
   addSplit(s1);
 
   //qDebug() << "created transaction, now adding...";
 
   MyMoneyFileTransaction ft;
   file->addTransaction(*this);
 
   //qDebug() << "updating price...";
 
   // update the price, while we're here
   if (_action != MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares)) {
     QString stockid = stockaccount.currencyId();
     QString basecurrencyid = file->baseCurrency().id();
     MyMoneyPrice price = file->price(stockid, basecurrencyid, _date, true);
     if (!price.isValid()) {
       MyMoneyPrice newprice(stockid, basecurrencyid, _date, _price, "test");
       file->addPrice(newprice);
     }
   }
   ft.commit();
   //qDebug() << "successfully added " << id();
 }
 
 QString makeAccount(const QString& _name, eMyMoney::Account::Type _type, MyMoneyMoney _balance, const QDate& _open, const QString& _parent, QString _currency, bool _taxReport, bool _openingBalance)
 {
   MyMoneyAccount info;
   MyMoneyFileTransaction ft;
 
   info.setName(_name);
   info.setAccountType(_type);
   info.setOpeningDate(_open);
   if (!_currency.isEmpty())
     info.setCurrencyId(_currency);
   else
     info.setCurrencyId(MyMoneyFile::instance()->baseCurrency().id());
 
   if (_taxReport)
     info.setValue("Tax", "Yes");
 
   if (_openingBalance)
     info.setValue("OpeningBalanceAccount", "Yes");
 
   MyMoneyAccount parent = MyMoneyFile::instance()->account(_parent);
   MyMoneyFile::instance()->addAccount(info, parent);
   // create the opening balance transaction if any
   if (!_balance.isZero()) {
     MyMoneySecurity sec = MyMoneyFile::instance()->currency(info.currencyId());
     MyMoneyFile::instance()->openingBalanceAccount(sec);
     MyMoneyFile::instance()->createOpeningBalanceTransaction(info, _balance);
   }
   ft.commit();
 
   return info.id();
 }
 
 void makePrice(const QString& _currencyid, const QDate& _date, const MyMoneyMoney& _price)
 {
   MyMoneyFileTransaction ft;
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneySecurity curr = file->currency(_currencyid);
   MyMoneyPrice price(_currencyid, file->baseCurrency().id(), _date, _price, "test");
   file->addPrice(price);
   ft.commit();
 }
 
 QString makeEquity(const QString& _name, const QString& _symbol)
 {
   MyMoneySecurity equity;
   MyMoneyFileTransaction ft;
 
   equity.setName(_name);
   equity.setTradingSymbol(_symbol);
   equity.setSmallestAccountFraction(1000);
   equity.setSecurityType(eMyMoney::Security::Type::None/*MyMoneyEquity::ETYPE_STOCK*/);
   MyMoneyFile::instance()->addSecurity(equity);
   ft.commit();
 
   return equity.id();
 }
 
 void makeEquityPrice(const QString& _id, const QDate& _date, const MyMoneyMoney& _price)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyFileTransaction ft;
   QString basecurrencyid = file->baseCurrency().id();
   MyMoneyPrice price = file->price(_id, basecurrencyid, _date, true);
   if (!price.isValid()) {
     MyMoneyPrice newprice(_id, basecurrencyid, _date, _price, "test");
     file->addPrice(newprice);
   }
   ft.commit();
 }
 
 void writeRCFtoXMLDoc(const MyMoneyReport& filter, QDomDocument* doc)
 {
   QDomProcessingInstruction instruct = doc->createProcessingInstruction(QString("xml"), QString("version=\"1.0\" encoding=\"utf-8\""));
   doc->appendChild(instruct);
 
   QDomElement root = doc->createElement("KMYMONEY-FILE");
   doc->appendChild(root);
 
   QDomElement reports = doc->createElement("REPORTS");
   root.appendChild(reports);
 
   QDomElement report = doc->createElement("REPORT");
   filter.write(report, doc);
   reports.appendChild(report);
 
 }
 
 void writeTabletoHTML(const PivotTable& table, const QString& _filename)
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString("report-%1%2.html").arg((filenumber < 10) ? "0" : "").arg(filenumber);
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderHTML();
   g.close();
 
 }
 
 void writeTabletoHTML(const QueryTable& table, const QString& _filename)
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString("report-%1%2.html").arg((filenumber < 10) ? "0" : "").arg(filenumber);
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderHTML();
   g.close();
 }
 
 void writeTabletoCSV(const PivotTable& table, const QString& _filename)
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString("report-%1%2.csv").arg((filenumber < 10) ? "0" : "").arg(filenumber);
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderCSV();
   g.close();
 
 }
 
 void writeTabletoCSV(const QueryTable& table, const QString& _filename)
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString("qreport-%1%2.csv").arg((filenumber < 10) ? "0" : "").arg(filenumber);
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderCSV();
   g.close();
 
 }
 
 void writeRCFtoXML(const MyMoneyReport& filter, const QString& _filename)
 {
   static unsigned filenum = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString("report-%1%2.xml").arg(QString::number(filenum).rightJustified(2, '0'));
     ++filenum;
   }
 
   QDomDocument* doc = new QDomDocument("KMYMONEY-FILE");
   Q_CHECK_PTR(doc);
 
   writeRCFtoXMLDoc(filter, doc);
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
 
   QTextStream stream(&g);
   stream.setCodec("UTF-8");
   stream << doc->toString();
   g.close();
 
   delete doc;
 }
 
 bool readRCFfromXMLDoc(QList<MyMoneyReport>& list, QDomDocument* doc)
 {
   bool result = false;
 
   QDomElement rootElement = doc->documentElement();
   if (!rootElement.isNull()) {
     QDomNode child = rootElement.firstChild();
     while (!child.isNull() && child.isElement()) {
       QDomElement childElement = child.toElement();
       if ("REPORTS" == childElement.tagName()) {
         result = true;
         QDomNode subchild = child.firstChild();
         while (!subchild.isNull() && subchild.isElement()) {
           MyMoneyReport filter;
           if (filter.read(subchild.toElement())) {
             list += filter;
           }
           subchild = subchild.nextSibling();
         }
       }
       child = child.nextSibling();
     }
   }
   return result;
 }
 
 bool readRCFfromXML(QList<MyMoneyReport>& list, const QString& filename)
 {
   int result = false;
   QFile f(filename);
   f.open(QIODevice::ReadOnly);
   QDomDocument* doc = new QDomDocument;
   if (doc->setContent(&f, false)) {
     result = readRCFfromXMLDoc(list, doc);
   }
   delete doc;
 
   return result;
 
 }
 
 void XMLandback(MyMoneyReport& filter)
 {
   // this function writes the filter to XML, and then reads
   // it back from XML overwriting the original filter;
   // in all cases, the result should be the same if the read
   // & write methods are working correctly.
 
   QDomDocument* doc = new QDomDocument("KMYMONEY-FILE");
   Q_CHECK_PTR(doc);
 
   writeRCFtoXMLDoc(filter, doc);
   QList<MyMoneyReport> list;
   if (readRCFfromXMLDoc(list, doc) && !list.isEmpty())
     filter = list[0];
   else
-    throw MYMONEYEXCEPTION("Failed to load report from XML");
+    throw MYMONEYEXCEPTION_CSTRING("Failed to load report from XML");
 
   delete doc;
 
 }
 
 MyMoneyMoney searchHTML(const QString& _html, const QString& _search)
 {
   Q_UNUSED(_html)
   QRegExp re(QString("%1[<>/td]*([\\-.0-9,]*)").arg(_search));
   if (re.indexIn(_html) > -1) {
     QString found = re.cap(1);
     found.remove(',');
 
     return MyMoneyMoney(found.toDouble());
   }
   return MyMoneyMoney();
 }
 
 } // end namespace test
diff --git a/kmymoney/views/kaccountsview.cpp b/kmymoney/views/kaccountsview.cpp
index c66926efc..c41915c1c 100644
--- a/kmymoney/views/kaccountsview.cpp
+++ b/kmymoney/views/kaccountsview.cpp
@@ -1,583 +1,583 @@
 /***************************************************************************
                           kaccountsview.cpp
                              -------------------
     copyright            : (C) 2007 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017, 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kaccountsview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QMenu>
 #include <QAction>
 #include <QBitArray>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "onlinejobadministration.h"
 #include "knewaccountwizard.h"
 #include "kbalancechartdlg.h"
 #include "kmymoneyutils.h"
 #include "kmymoneysettings.h"
 #include "storageenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 KAccountsView::KAccountsView(QWidget *parent) :
     KMyMoneyAccountsViewBase(*new KAccountsViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::NewAccount],          &QAction::triggered, this, &KAccountsView::slotNewAccount);
   connect(pActions[eMenu::Action::EditAccount],         &QAction::triggered, this, &KAccountsView::slotEditAccount);
   connect(pActions[eMenu::Action::DeleteAccount],       &QAction::triggered, this, &KAccountsView::slotDeleteAccount);
   connect(pActions[eMenu::Action::CloseAccount],        &QAction::triggered, this, &KAccountsView::slotCloseAccount);
   connect(pActions[eMenu::Action::ReopenAccount],       &QAction::triggered, this, &KAccountsView::slotReopenAccount);
   connect(pActions[eMenu::Action::ChartAccountBalance], &QAction::triggered, this, &KAccountsView::slotChartAccountBalance);
   connect(pActions[eMenu::Action::MapOnlineAccount],    &QAction::triggered, this, &KAccountsView::slotAccountMapOnline);
   connect(pActions[eMenu::Action::UnmapOnlineAccount],  &QAction::triggered, this, &KAccountsView::slotAccountUnmapOnline);
   connect(pActions[eMenu::Action::UpdateAccount],       &QAction::triggered, this, &KAccountsView::slotAccountUpdateOnline);
   connect(pActions[eMenu::Action::UpdateAllAccounts],   &QAction::triggered, this, &KAccountsView::slotAccountUpdateOnlineAll);
 }
 
 KAccountsView::~KAccountsView()
 {
 }
 
 void KAccountsView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KAccountsView);
         QTimer::singleShot(0, d->ui->m_accountTree, SLOT(setFocus()));
       }
       break;
 
     default:
       break;
   }
 }
 
 void KAccountsView::refresh()
 {
   Q_D(KAccountsView);
   if (!isVisible()) {
     d->m_needsRefresh = true;
     return;
   }
   d->m_needsRefresh = false;
   // TODO: check why the invalidate is needed here
   d->m_proxyModel->invalidate();
   d->m_proxyModel->setHideClosedAccounts(KMyMoneySettings::hideClosedAccounts());
   d->m_proxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
   if (KMyMoneySettings::showCategoriesInAccountsView()) {
     d->m_proxyModel->addAccountGroup(QVector<eMyMoney::Account::Type> {eMyMoney::Account::Type::Income, eMyMoney::Account::Type::Expense});
   } else {
     d->m_proxyModel->removeAccountType(eMyMoney::Account::Type::Income);
     d->m_proxyModel->removeAccountType(eMyMoney::Account::Type::Expense);
   }
 
   // reinitialize the default state of the hidden categories label
   d->m_haveUnusedCategories = false;
   d->ui->m_hiddenCategories->hide();  // hides label
   d->m_proxyModel->setHideUnusedIncomeExpenseAccounts(KMyMoneySettings::hideUnusedCategory());
 }
 
 void KAccountsView::showEvent(QShowEvent * event)
 {
   Q_D(KAccountsView);
   if (!d->m_proxyModel)
     d->init();
 
   emit customActionRequested(View::Accounts, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KAccountsView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KAccountsView);
 
   const auto file = MyMoneyFile::instance();
 
   if (d->m_onlinePlugins) {
     QList<MyMoneyAccount> accList;
     file->accountList(accList);
     QList<MyMoneyAccount>::const_iterator it_a;
     auto it_p = d->m_onlinePlugins->constEnd();
     for (it_a = accList.constBegin(); (it_p == d->m_onlinePlugins->constEnd()) && (it_a != accList.constEnd()); ++it_a) {
       if ((*it_a).hasOnlineMapping()) {
         // check if provider is available
         it_p = d->m_onlinePlugins->constFind((*it_a).onlineBankingSettings().value("provider").toLower());
         if (it_p != d->m_onlinePlugins->constEnd()) {
           QStringList protocols;
           (*it_p)->protocols(protocols);
           if (!protocols.isEmpty())
             pActions[eMenu::Action::UpdateAllAccounts]->setEnabled(true);
         }
       }
     }
   }
 
   if (typeid(obj) != typeid(MyMoneyAccount) &&
       (obj.id().isEmpty() && d->m_currentAccount.id().isEmpty())) // do not disable actions that were already disabled)
     return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
 
   const QVector<eMenu::Action> actionsToBeDisabled {
         eMenu::Action::NewAccount, eMenu::Action::EditAccount, eMenu::Action::DeleteAccount,
         eMenu::Action::CloseAccount, eMenu::Action::ReopenAccount,
         eMenu::Action::ChartAccountBalance,
         eMenu::Action::UnmapOnlineAccount, eMenu::Action::MapOnlineAccount, eMenu::Action::UpdateAccount
   };
 
   for (const auto& a : actionsToBeDisabled)
     pActions[a]->setEnabled(false);
 
   pActions[eMenu::Action::NewAccount]->setEnabled(true);
 
   if (acc.id().isEmpty()) {
     d->m_currentAccount = MyMoneyAccount();
     return;
   } else if (file->isStandardAccount(acc.id())) {
     d->m_currentAccount = acc;
     return;
   }
   d->m_currentAccount = acc;
 
   switch (acc.accountGroup()) {
     case eMyMoney::Account::Type::Asset:
     case eMyMoney::Account::Type::Liability:
     case eMyMoney::Account::Type::Equity:
     {
       pActions[eMenu::Action::EditAccount]->setEnabled(true);
       pActions[eMenu::Action::DeleteAccount]->setEnabled(!file->isReferenced(acc));
 
       auto b = acc.isClosed() ? true : false;
       pActions[eMenu::Action::ReopenAccount]->setEnabled(b);
       pActions[eMenu::Action::CloseAccount]->setEnabled(!b);
 
       if (!acc.isClosed()) {
         b = (d->canCloseAccount(acc) == KAccountsViewPrivate::AccountCanClose) ? true : false;
         pActions[eMenu::Action::CloseAccount]->setEnabled(b);
         d->hintCloseAccountAction(acc, pActions[eMenu::Action::CloseAccount]);
       }
 
       pActions[eMenu::Action::ChartAccountBalance]->setEnabled(true);
 
       if (d->m_currentAccount.hasOnlineMapping()) {
         pActions[eMenu::Action::UnmapOnlineAccount]->setEnabled(true);
 
         if (d->m_onlinePlugins) {
           // check if provider is available
           QMap<QString, KMyMoneyPlugin::OnlinePlugin*>::const_iterator it_p;
           it_p = d->m_onlinePlugins->constFind(d->m_currentAccount.onlineBankingSettings().value(QLatin1String("provider")).toLower());
           if (it_p != d->m_onlinePlugins->constEnd()) {
             QStringList protocols;
             (*it_p)->protocols(protocols);
             if (protocols.count() > 0) {
               pActions[eMenu::Action::UpdateAccount]->setEnabled(true);
             }
           }
         }
 
       } else {
         pActions[eMenu::Action::MapOnlineAccount]->setEnabled(d->m_onlinePlugins && !d->m_onlinePlugins->isEmpty());
       }
 
       break;
     }
     default:
       break;
   }
 
   QBitArray skip((int)eStorage::Reference::Count);
   if (!d->m_currentAccount.id().isEmpty()) {
     if (!file->isStandardAccount(d->m_currentAccount.id())) {
       switch (d->m_currentAccount.accountGroup()) {
         case eMyMoney::Account::Type::Asset:
         case eMyMoney::Account::Type::Liability:
         case eMyMoney::Account::Type::Equity:
 
           break;
 
         default:
           break;
       }
     }
   }
 
 }
 
 /**
   * The view is notified that an unused income expense account has been hidden.
   */
 void KAccountsView::slotUnusedIncomeExpenseAccountHidden()
 {
   Q_D(KAccountsView);
   d->m_haveUnusedCategories = true;
   d->ui->m_hiddenCategories->setVisible(d->m_haveUnusedCategories);
 }
 
 void KAccountsView::slotNetWorthChanged(const MyMoneyMoney &netWorth)
 {
   Q_D(KAccountsView);
   d->netBalProChanged(netWorth, d->ui->m_totalProfitsLabel, View::Accounts);
 }
 
 void KAccountsView::slotShowAccountMenu(const MyMoneyAccount& acc)
 {
   Q_UNUSED(acc);
   pMenus[eMenu::Menu::Account]->exec(QCursor::pos());
 }
 
 void KAccountsView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::OpenContextMenu:
       slotShowAccountMenu(static_cast<const MyMoneyAccount&>(obj));
       break;
 
     default:
       break;
   }
 }
 
 void KAccountsView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   Q_D(KAccountsView);
   switch (intent) {
     case eView::Intent::UpdateNetWorth:
       if (variant.count() == 1 && d->m_proxyModel)
         slotNetWorthChanged(variant.first().value<MyMoneyMoney>());
       break;
 
     case eView::Intent::SetOnlinePlugins:
       if (variant.count() == 1)
         d->m_onlinePlugins = static_cast<QMap<QString, KMyMoneyPlugin::OnlinePlugin*>*>(variant.first().value<void*>());
       break;
 
     default:
       break;
   }
 }
 
 void KAccountsView::slotNewAccount()
 {
   MyMoneyAccount account;
   account.setOpeningDate(KMyMoneySettings::firstFiscalDate());
   NewAccountWizard::Wizard::newAccount(account);
 }
 
 void KAccountsView::slotEditAccount()
 {
   Q_D(KAccountsView);
 
   switch (d->m_currentAccount.accountType()) {
     case eMyMoney::Account::Type::Loan:
     case eMyMoney::Account::Type::AssetLoan:
       d->editLoan();
       break;
     default:
       d->editAccount();
       break;
   }
   emit selectByObject(d->m_currentAccount, eView::Intent::None);
 }
 
 void KAccountsView::slotDeleteAccount()
 {
   Q_D(KAccountsView);
   if (d->m_currentAccount.id().isEmpty())
     return;  // need an account ID
 
   const auto file = MyMoneyFile::instance();
   // can't delete standard accounts or account which still have transactions assigned
   if (file->isStandardAccount(d->m_currentAccount.id()))
     return;
 
   // check if the account is referenced by a transaction or schedule
   QBitArray skip((int)eStorage::Reference::Count);
   skip.fill(false);
   skip.setBit((int)eStorage::Reference::Account);
   skip.setBit((int)eStorage::Reference::Institution);
   skip.setBit((int)eStorage::Reference::Payee);
   skip.setBit((int)eStorage::Reference::Tag);
   skip.setBit((int)eStorage::Reference::Security);
   skip.setBit((int)eStorage::Reference::Currency);
   skip.setBit((int)eStorage::Reference::Price);
   if (file->isReferenced(d->m_currentAccount, skip))
     return;
 
   MyMoneyFileTransaction ft;
 
   // retain the account name for a possible later usage in the error message box
   // since the account removal notifies the views the selected account can be changed
   // so we make sure by doing this that we display the correct name in the error message
   auto selectedAccountName = d->m_currentAccount.name();
 
   try {
     file->removeAccount(d->m_currentAccount);
     d->m_currentAccount.clearId();
     emit selectByObject(MyMoneyAccount(), eView::Intent::None);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::error(this, i18n("Unable to delete account '%1'. Cause: %2", selectedAccountName, e.what()));
+    KMessageBox::error(this, i18n("Unable to delete account '%1'. Cause: %2", selectedAccountName, QString::fromLatin1(e.what())));
   }
 }
 
 void KAccountsView::slotCloseAccount()
 {
   Q_D(KAccountsView);
   MyMoneyFileTransaction ft;
   try {
     d->m_currentAccount.setClosed(true);
     MyMoneyFile::instance()->modifyAccount(d->m_currentAccount);
     emit selectByObject(d->m_currentAccount, eView::Intent::None);
     ft.commit();
     if (KMyMoneySettings::hideClosedAccounts())
       KMessageBox::information(this, i18n("<qt>You have closed this account. It remains in the system because you have transactions which still refer to it, but it is not shown in the views. You can make it visible again by going to the View menu and selecting <b>Show all accounts</b> or by deselecting the <b>Do not show closed accounts</b> setting.</qt>"), i18n("Information"), "CloseAccountInfo");
   } catch (const MyMoneyException &) {
   }
 }
 
 void KAccountsView::slotReopenAccount()
 {
   Q_D(KAccountsView);
   const auto file = MyMoneyFile::instance();
   MyMoneyFileTransaction ft;
   try {
     auto& acc = d->m_currentAccount;
     while (acc.isClosed()) {
       acc.setClosed(false);
       file->modifyAccount(acc);
       acc = file->account(acc.parentAccountId());
     }
     emit selectByObject(d->m_currentAccount, eView::Intent::None);
     ft.commit();
   } catch (const MyMoneyException &) {
   }
 }
 
 void KAccountsView::slotChartAccountBalance()
 {
   Q_D(KAccountsView);
   if (!d->m_currentAccount.id().isEmpty()) {
     QPointer<KBalanceChartDlg> dlg = new KBalanceChartDlg(d->m_currentAccount, this);
     dlg->exec();
     delete dlg;
   }
 }
 
 void KAccountsView::slotNewCategory()
 {
   Q_D(KAccountsView);
   KNewAccountDlg::newCategory(d->m_currentAccount, MyMoneyAccount());
 }
 
 void KAccountsView::slotNewPayee(const QString& nameBase, QString& id)
 {
   KMyMoneyUtils::newPayee(nameBase, id);
 }
 
 void KAccountsView::slotAccountUnmapOnline()
 {
   Q_D(KAccountsView);
   // no account selected
   if (d->m_currentAccount.id().isEmpty())
     return;
 
   // not a mapped account
   if (!d->m_currentAccount.hasOnlineMapping())
     return;
 
   if (KMessageBox::warningYesNo(this, QString("<qt>%1</qt>").arg(i18n("Do you really want to remove the mapping of account <b>%1</b> to an online account? Depending on the details of the online banking method used, this action cannot be reverted.", d->m_currentAccount.name())), i18n("Remove mapping to online account")) == KMessageBox::Yes) {
     MyMoneyFileTransaction ft;
     try {
       d->m_currentAccount.setOnlineBankingSettings(MyMoneyKeyValueContainer());
       // delete the kvp that is used in MyMoneyStatementReader too
       // we should really get rid of it, but since I don't know what it
       // is good for, I'll keep it around. (ipwizard)
       d->m_currentAccount.deletePair("StatementKey");
       MyMoneyFile::instance()->modifyAccount(d->m_currentAccount);
       ft.commit();
       // The mapping could disable the online task system
       onlineJobAdministration::instance()->updateOnlineTaskProperties();
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(this, i18n("Unable to unmap account from online account: %1", e.what()));
+      KMessageBox::error(this, i18n("Unable to unmap account from online account: %1", QString::fromLatin1(e.what())));
     }
   }
   updateActions(d->m_currentAccount);
 }
 
 void KAccountsView::slotAccountMapOnline()
 {
   Q_D(KAccountsView);
   // no account selected
   if (d->m_currentAccount.id().isEmpty())
     return;
 
   // already an account mapped
   if (d->m_currentAccount.hasOnlineMapping())
     return;
 
   // check if user tries to map a brokerageAccount
   if (d->m_currentAccount.name().contains(i18n(" (Brokerage)"))) {
     if (KMessageBox::warningContinueCancel(this, i18n("You try to map a brokerage account to an online account. This is usually not advisable. In general, the investment account should be mapped to the online account. Please cancel if you intended to map the investment account, continue otherwise"), i18n("Mapping brokerage account")) == KMessageBox::Cancel) {
       return;
     }
   }
   if (!d->m_onlinePlugins)
     return;
 
   // if we have more than one provider let the user select the current provider
   QString provider;
   QMap<QString, KMyMoneyPlugin::OnlinePlugin*>::const_iterator it_p;
   switch (d->m_onlinePlugins->count()) {
     case 0:
       break;
     case 1:
       provider = d->m_onlinePlugins->begin().key();
       break;
     default: {
         QMenu popup(this);
         popup.setTitle(i18n("Select online banking plugin"));
 
         // Populate the pick list with all the provider
         for (it_p = d->m_onlinePlugins->constBegin(); it_p != d->m_onlinePlugins->constEnd(); ++it_p) {
           popup.addAction(it_p.key())->setData(it_p.key());
         }
 
         QAction *item = popup.actions()[0];
         if (item) {
           popup.setActiveAction(item);
         }
 
         // cancelled
         if ((item = popup.exec(QCursor::pos(), item)) == 0) {
           return;
         }
 
         provider = item->data().toString();
       }
       break;
   }
 
   if (provider.isEmpty())
     return;
 
   // find the provider
   it_p = d->m_onlinePlugins->constFind(provider.toLower());
   if (it_p != d->m_onlinePlugins->constEnd()) {
     // plugin found, call it
     MyMoneyKeyValueContainer settings;
     if ((*it_p)->mapAccount(d->m_currentAccount, settings)) {
       settings["provider"] = provider.toLower();
       MyMoneyAccount acc(d->m_currentAccount);
       acc.setOnlineBankingSettings(settings);
       MyMoneyFileTransaction ft;
       try {
         MyMoneyFile::instance()->modifyAccount(acc);
         ft.commit();
         // The mapping could enable the online task system
         onlineJobAdministration::instance()->updateOnlineTaskProperties();
       } catch (const MyMoneyException &e) {
-        KMessageBox::error(this, i18n("Unable to map account to online account: %1", e.what()));
+        KMessageBox::error(this, i18n("Unable to map account to online account: %1", QString::fromLatin1(e.what())));
       }
     }
   }
   updateActions(d->m_currentAccount);
 }
 
 void KAccountsView::slotAccountUpdateOnlineAll()
 {
   Q_D(KAccountsView);
   QList<MyMoneyAccount> accList;
   MyMoneyFile::instance()->accountList(accList);
   QList<MyMoneyAccount>::iterator it_a;
   QMap<QString, KMyMoneyPlugin::OnlinePlugin*>::const_iterator it_p;
 
   // remove all those from the list, that don't have a 'provider' or the
   // provider is not currently present
   for (it_a = accList.begin(); it_a != accList.end();) {
     if (!(*it_a).hasOnlineMapping()
         || d->m_onlinePlugins->find((*it_a).onlineBankingSettings().value("provider").toLower()) == d->m_onlinePlugins->end()) {
       it_a = accList.erase(it_a);
     } else
       ++it_a;
   }
   const QVector<eMenu::Action> disabledActions {eMenu::Action::UpdateAccount, eMenu::Action::UpdateAllAccounts};
   for (const auto& a : disabledActions)
     pActions[a]->setEnabled(false);
 
   // now work on the remaining list of accounts
   int cnt = accList.count() - 1;
   for (it_a = accList.begin(); it_a != accList.end(); ++it_a) {
     it_p = d->m_onlinePlugins->constFind((*it_a).onlineBankingSettings().value("provider").toLower());
     (*it_p)->updateAccount(*it_a, cnt != 0);
     --cnt;
   }
 
   // re-enable the disabled actions
   updateActions(d->m_currentAccount);
 }
 
 void KAccountsView::slotAccountUpdateOnline()
 {
   Q_D(KAccountsView);
   // no account selected
   if (d->m_currentAccount.id().isEmpty())
     return;
 
   // no online account mapped
   if (!d->m_currentAccount.hasOnlineMapping())
     return;
 
   const QVector<eMenu::Action> disabledActions {eMenu::Action::UpdateAccount, eMenu::Action::UpdateAllAccounts};
   for (const auto& a : disabledActions)
     pActions[a]->setEnabled(false);
 
   // find the provider
   QMap<QString, KMyMoneyPlugin::OnlinePlugin*>::const_iterator it_p;
   it_p = d->m_onlinePlugins->constFind(d->m_currentAccount.onlineBankingSettings().value("provider").toLower());
   if (it_p != d->m_onlinePlugins->constEnd()) {
     // plugin found, call it
     (*it_p)->updateAccount(d->m_currentAccount);
   }
 
   // re-enable the disabled actions
   updateActions(d->m_currentAccount);
 }
diff --git a/kmymoney/views/kaccountsview_p.h b/kmymoney/views/kaccountsview_p.h
index 988e96953..94f4fffe0 100644
--- a/kmymoney/views/kaccountsview_p.h
+++ b/kmymoney/views/kaccountsview_p.h
@@ -1,323 +1,323 @@
 /***************************************************************************
                           kaccountsview.cpp
                              -------------------
     copyright            : (C) 2007 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KACCOUNTSVIEW_P_H
 #define KACCOUNTSVIEW_P_H
 
 #include "kaccountsview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QAction>
 #include <QPointer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kaccountsview.h"
 #include "kmymoneyaccountsviewbase_p.h"
 
 #include "mymoneyexception.h"
 #include "mymoneysplit.h"
 #include "mymoneyschedule.h"
 #include "mymoneytransaction.h"
 #include "knewaccountdlg.h"
 #include "keditloanwizard.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "accountsviewproxymodel.h"
 #include "kmymoneyplugin.h"
 #include "icons.h"
 #include "mymoneyenums.h"
 
 using namespace Icons;
 
 class KAccountsViewPrivate : public KMyMoneyAccountsViewBasePrivate
 {
   Q_DECLARE_PUBLIC(KAccountsView)
 
 public:
   explicit KAccountsViewPrivate(KAccountsView *qq) :
     q_ptr(qq),
     ui(new Ui::KAccountsView),
     m_haveUnusedCategories(false),
     m_onlinePlugins(nullptr)
   {
   }
 
   ~KAccountsViewPrivate()
   {
     delete ui;
   }
 
   void init()
   {
     Q_Q(KAccountsView);
     ui->setupUi(q);
     m_accountTree = &ui->m_accountTree;
 
     // setup icons for collapse and expand button
     ui->m_collapseButton->setIcon(Icons::get(Icon::ListCollapse));
     ui->m_expandButton->setIcon(Icons::get(Icon::ListExpand));
 
     m_proxyModel = ui->m_accountTree->init(View::Accounts);
     q->connect(m_proxyModel, &AccountsProxyModel::unusedIncomeExpenseAccountHidden, q, &KAccountsView::slotUnusedIncomeExpenseAccountHidden);
     q->connect(ui->m_searchWidget, &QLineEdit::textChanged, m_proxyModel, &QSortFilterProxyModel::setFilterFixedString);
     q->connect(ui->m_accountTree, &KMyMoneyAccountTreeView::selectByObject, q, &KAccountsView::selectByObject);
     q->connect(ui->m_accountTree, &KMyMoneyAccountTreeView::selectByVariant, q, &KAccountsView::selectByVariant);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KAccountsView::refresh);
   }
 
   void editLoan()
   {
     Q_Q(KAccountsView);
     if (m_currentAccount.id().isEmpty())
       return;
 
     const auto file = MyMoneyFile::instance();
     if (file->isStandardAccount(m_currentAccount.id()))
       return;
 
     QPointer<KEditLoanWizard> wizard = new KEditLoanWizard(m_currentAccount);
     q->connect(wizard, &KEditLoanWizard::newCategory, q, &KAccountsView::slotNewCategory);
     q->connect(wizard, &KEditLoanWizard::createPayee, q, &KAccountsView::slotNewPayee);
     if (wizard->exec() == QDialog::Accepted && wizard != 0) {
       MyMoneySchedule sch;
       try {
         sch = file->schedule(m_currentAccount.value("schedule").toLatin1());
       } catch (const MyMoneyException &) {
         qDebug() << "schedule" << m_currentAccount.value("schedule").toLatin1() << "not found";
       }
       if (!(m_currentAccount == wizard->account())
           || !(sch == wizard->schedule())) {
         MyMoneyFileTransaction ft;
         try {
           file->modifyAccount(wizard->account());
           if (!sch.id().isEmpty()) {
             sch = wizard->schedule();
           }
           try {
             file->schedule(sch.id());
             file->modifySchedule(sch);
             ft.commit();
           } catch (const MyMoneyException &) {
             try {
               if(sch.transaction().splitCount() >= 2) {
                 file->addSchedule(sch);
               }
               ft.commit();
             } catch (const MyMoneyException &e) {
-              qDebug("Cannot add schedule: '%s'", qPrintable(e.what()));
+              qDebug("Cannot add schedule: '%s'", e.what());
             }
           }
         } catch (const MyMoneyException &e) {
           qDebug("Unable to modify account %s: '%s'", qPrintable(m_currentAccount.name()),
-                 qPrintable(e.what()));
+                 e.what());
         }
       }
     }
     delete wizard;
   }
 
   void editAccount()
   {
     if (m_currentAccount.id().isEmpty())
       return;
 
     const auto file = MyMoneyFile::instance();
     if (file->isStandardAccount(m_currentAccount.id()))
       return;
 
 
     // set a status message so that the application can't be closed until the editing is done
     //        slotStatusMsg(caption);
 
     auto tid = file->openingBalanceTransaction(m_currentAccount);
     MyMoneyTransaction t;
     MyMoneySplit s0, s1;
     QPointer<KNewAccountDlg> dlg =
         new KNewAccountDlg(m_currentAccount, true, false, 0, i18n("Edit account '%1'", m_currentAccount.name()));
 
     if (!tid.isEmpty()) {
       try {
         t = file->transaction(tid);
         s0 = t.splitByAccount(m_currentAccount.id());
         s1 = t.splitByAccount(m_currentAccount.id(), false);
         dlg->setOpeningBalance(s0.shares());
         if (m_currentAccount.accountGroup() == eMyMoney::Account::Type::Liability) {
           dlg->setOpeningBalance(-s0.shares());
         }
       } catch (const MyMoneyException &e) {
         qDebug() << "Error retrieving opening balance transaction " << tid << ": " << e.what() << "\n";
         tid.clear();
       }
     }
 
     // check for online modules
     QMap<QString, KMyMoneyPlugin::OnlinePlugin *>::const_iterator it_plugin;
     if (m_onlinePlugins) {
       it_plugin = m_onlinePlugins->constEnd();
       const auto& kvp = m_currentAccount.onlineBankingSettings();
       if (!kvp["provider"].isEmpty()) {
         // if we have an online provider for this account, we need to check
         // that we have the corresponding plugin. If that exists, we ask it
         // to provide an additional tab for the account editor.
         it_plugin = m_onlinePlugins->constFind(kvp["provider"].toLower());
         if (it_plugin != m_onlinePlugins->constEnd()) {
           QString name;
           auto w = (*it_plugin)->accountConfigTab(m_currentAccount, name);
           dlg->addTab(w, name);
         }
       }
     }
 
     if (dlg != 0 && dlg->exec() == QDialog::Accepted) {
       try {
         MyMoneyFileTransaction ft;
 
         auto account = dlg->account();
         auto parent = dlg->parentAccount();
         if (m_onlinePlugins && it_plugin != m_onlinePlugins->constEnd()) {
           account.setOnlineBankingSettings((*it_plugin)->onlineBankingSettings(account.onlineBankingSettings()));
         }
         auto bal = dlg->openingBalance();
         if (m_currentAccount.accountGroup() == eMyMoney::Account::Type::Liability) {
           bal = -bal;
         }
 
         // we need to modify first, as reparent would override all other changes
         file->modifyAccount(account);
         if (account.parentAccountId() != parent.id()) {
           file->reparentAccount(account, parent);
         }
         if (!tid.isEmpty() && dlg->openingBalance().isZero()) {
           file->removeTransaction(t);
 
         } else if (!tid.isEmpty() && !dlg->openingBalance().isZero()) {
           s0.setShares(bal);
           s0.setValue(bal);
           t.modifySplit(s0);
           s1.setShares(-bal);
           s1.setValue(-bal);
           t.modifySplit(s1);
           t.setPostDate(account.openingDate());
           file->modifyTransaction(t);
 
         } else if (tid.isEmpty() && !dlg->openingBalance().isZero()) {
           file->createOpeningBalanceTransaction(m_currentAccount, bal);
         }
 
         ft.commit();
 
         // reload the account object as it might have changed in the meantime
         //            slotSelectAccount(file->account(account.id()));
 
       } catch (const MyMoneyException &e) {
         Q_Q(KAccountsView);
         KMessageBox::error(q, i18n("Unable to modify account '%1'. Cause: %2", m_currentAccount.name(), e.what()));
       }
     }
 
     delete dlg;
     //        ready();
 
   }
 
   enum CanCloseAccountCodeE {
     AccountCanClose = 0,    // can close the account
     AccountBalanceNonZero,         // balance is non zero
     AccountChildrenOpen,          // account has open children account
     AccountScheduleReference         // account is referenced in a schedule
   };
 
   /**
     * This method checks, if an account can be closed or not. An account
     * can be closed if:
     *
     * - the balance is zero and
     * - all children are already closed and
     * - there is no unfinished schedule referencing the account
     *
     * @param acc reference to MyMoneyAccount object in question
     * @retval true account can be closed
     * @retval false account cannot be closed
     */
   CanCloseAccountCodeE canCloseAccount(const MyMoneyAccount& acc)
   {
     // balance must be zero
     if (!acc.balance().isZero())
       return AccountBalanceNonZero;
 
     // all children must be already closed
     foreach (const auto sAccount, acc.accountList()) {
       if (!MyMoneyFile::instance()->account(sAccount).isClosed()) {
         return AccountChildrenOpen;
       }
     }
 
     // there must be no unfinished schedule referencing the account
     QList<MyMoneySchedule> list = MyMoneyFile::instance()->scheduleList();
     QList<MyMoneySchedule>::const_iterator it_l;
     for (it_l = list.constBegin(); it_l != list.constEnd(); ++it_l) {
       if ((*it_l).isFinished())
         continue;
       if ((*it_l).hasReferenceTo(acc.id()))
         return AccountScheduleReference;
     }
     return AccountCanClose;
   }
 
   /**
    * This method checks if an account can be closed and enables/disables
    * the close account action
    * If disabled, it sets a tooltip explaning why it cannot be closed
    * @brief enableCloseAccountAction
    * @param acc reference to MyMoneyAccount object in question
    */
   void hintCloseAccountAction(const MyMoneyAccount& acc, QAction* a)
   {
     switch (canCloseAccount(acc)) {
       case AccountCanClose:
         a->setToolTip(QString());
         return;
       case AccountBalanceNonZero:
         a->setToolTip(i18n("The balance of the account must be zero before the account can be closed"));
         return;
       case AccountChildrenOpen:
         a->setToolTip(i18n("All subaccounts must be closed before the account can be closed"));
         return;
       case AccountScheduleReference:
         a->setToolTip(i18n("This account is still included in an active schedule"));
         return;
     }
   }
 
   KAccountsView       *q_ptr;
   Ui::KAccountsView   *ui;
   bool                m_haveUnusedCategories;
   MyMoneyAccount      m_currentAccount;
   QMap<QString, KMyMoneyPlugin::OnlinePlugin*>* m_onlinePlugins;
 };
 
 #endif
diff --git a/kmymoney/views/kcategoriesview.cpp b/kmymoney/views/kcategoriesview.cpp
index 67daaf393..2cf7fe88e 100644
--- a/kmymoney/views/kcategoriesview.cpp
+++ b/kmymoney/views/kcategoriesview.cpp
@@ -1,498 +1,498 @@
 /***************************************************************************
                           kcategoriesview.cpp  -  description
                              -------------------
     begin                : Sun Jan 20 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kcategoriesview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QBitArray>
 #include <QMenu>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "kmymoneysettings.h"
 #include "knewaccountdlg.h"
 #include "kcategoryreassigndlg.h"
 #include "mymoneyschedule.h"
 #include "mymoneybudget.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneyenums.h"
 #include "storageenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 KCategoriesView::KCategoriesView(QWidget *parent) :
     KMyMoneyAccountsViewBase(*new KCategoriesViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::NewCategory],    &QAction::triggered, this, &KCategoriesView::slotNewCategory);
   connect(pActions[eMenu::Action::EditCategory],   &QAction::triggered, this, &KCategoriesView::slotEditCategory);
   connect(pActions[eMenu::Action::DeleteCategory], &QAction::triggered, this, &KCategoriesView::slotDeleteCategory);
 }
 
 KCategoriesView::~KCategoriesView()
 {
 }
 
 void KCategoriesView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KCategoriesView);
         QTimer::singleShot(0, d->ui->m_accountTree, SLOT(setFocus()));
       }
       break;
 
     default:
       break;
   }
 }
 
 void KCategoriesView::refresh()
 {
   Q_D(KCategoriesView);
   if (!isVisible()) {
     d->m_needsRefresh = true;
     return;
   }
   d->m_needsRefresh = false;
 
   d->m_proxyModel->invalidate();
   d->m_proxyModel->setHideClosedAccounts(KMyMoneySettings::hideClosedAccounts());
 
   // reinitialize the default state of the hidden categories label
   d->m_haveUnusedCategories = false;
   d->ui->m_hiddenCategories->hide();
   d->m_proxyModel->setHideUnusedIncomeExpenseAccounts(KMyMoneySettings::hideUnusedCategory());
 }
 
 void KCategoriesView::showEvent(QShowEvent * event)
 {
   Q_D(KCategoriesView);
   if (!d->m_proxyModel)
     d->init();
 
   emit customActionRequested(View::Categories, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KCategoriesView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KCategoriesView);
   if (typeid(obj) != typeid(MyMoneyAccount) &&
       (obj.id().isEmpty() && d->m_currentCategory.id().isEmpty())) // do not disable actions that were already disabled))
     return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
 
   if (d->m_currentCategory.id().isEmpty() && acc.id().isEmpty())
     return;
 
   switch (acc.accountType()) {
     case eMyMoney::Account::Type::Income:
     case eMyMoney::Account::Type::Expense:
     {
       const auto file = MyMoneyFile::instance();
       auto b = file->isStandardAccount(acc.id()) ? false : true;
       pActions[eMenu::Action::NewCategory]->setEnabled(true);
       pActions[eMenu::Action::EditCategory]->setEnabled(b);
       // enable delete action, if category/account itself is not referenced
       // by any object except accounts, because we want to allow
       // deleting of sub-categories. Also, we allow transactions, schedules and budgets
       // to be present because we can re-assign them during the delete process
       QBitArray skip((int)eStorage::Reference::Count);
       skip.fill(false);
       skip.setBit((int)eStorage::Reference::Transaction);
       skip.setBit((int)eStorage::Reference::Account);
       skip.setBit((int)eStorage::Reference::Schedule);
       skip.setBit((int)eStorage::Reference::Budget);
 
       pActions[eMenu::Action::DeleteCategory]->setEnabled(b && !file->isReferenced(acc, skip));
       d->m_currentCategory = acc;
       break;
     }
     default:
     {
       pActions[eMenu::Action::NewCategory]->setEnabled(false);
       pActions[eMenu::Action::EditCategory]->setEnabled(false);
       pActions[eMenu::Action::DeleteCategory]->setEnabled(false);
       d->m_currentCategory = MyMoneyAccount();
       break;
     }
   }
 }
 
 /**
   * The view is notified that an unused income expense account has been hidden.
   */
 void KCategoriesView::slotUnusedIncomeExpenseAccountHidden()
 {
   Q_D(KCategoriesView);
   d->m_haveUnusedCategories = true;
   d->ui->m_hiddenCategories->setVisible(d->m_haveUnusedCategories);
 }
 
 void KCategoriesView::slotProfitChanged(const MyMoneyMoney &profit)
 {
   Q_D(KCategoriesView);
   d->netBalProChanged(profit, d->ui->m_totalProfitsLabel, View::Categories);
 }
 
 void KCategoriesView::slotShowCategoriesMenu(const MyMoneyAccount& acc)
 {
   Q_UNUSED(acc);
   pMenus[eMenu::Menu::Category]->exec(QCursor::pos());
 }
 
 void KCategoriesView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::OpenContextMenu:
       slotShowCategoriesMenu(static_cast<const MyMoneyAccount&>(obj));
       break;
 
     default:
       break;
   }
 }
 
 void KCategoriesView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   Q_D(KCategoriesView);
   switch (intent) {
     case eView::Intent::UpdateProfit:
       if (variant.count() == 1 && d->m_proxyModel)
         slotProfitChanged(variant.first().value<MyMoneyMoney>());
       break;
     default:
       break;
   }
 }
 
 void KCategoriesView::slotNewCategory()
 {
   Q_D(KCategoriesView);
   MyMoneyAccount parent;
   MyMoneyAccount account;
 
   // Preselect the parent account by looking at the current selected account/category
   if (!d->m_currentCategory.id().isEmpty() &&
       d->m_currentCategory.isIncomeExpense()) {
     try {
       parent = MyMoneyFile::instance()->account(d->m_currentCategory.id());
     } catch (const MyMoneyException &) {
     }
   }
 
   KNewAccountDlg::createCategory(account, parent);
 }
 
 void KCategoriesView::slotEditCategory()
 {
   Q_D(KCategoriesView);
   if (d->m_currentCategory.id().isEmpty())
     return;
 
   const auto file = MyMoneyFile::instance();
   if (file->isStandardAccount(d->m_currentCategory.id()))
     return;
 
   switch (d->m_currentCategory.accountType()) {
     case eMyMoney::Account::Type::Income:
     case eMyMoney::Account::Type::Expense:
       break;
     default:
       return;
   }
 
   // set a status message so that the application can't be closed until the editing is done
   //        slotStatusMsg(caption);
 
   QPointer<KNewAccountDlg> dlg =
       new KNewAccountDlg(d->m_currentCategory, true, true, 0, i18n("Edit category '%1'", d->m_currentCategory.name()));
 
   dlg->setOpeningBalanceShown(false);
   dlg->setOpeningDateShown(false);
 
   if (dlg && dlg->exec() == QDialog::Accepted) {
     try {
       MyMoneyFileTransaction ft;
 
       auto account = dlg->account();
       auto parent = dlg->parentAccount();
 
       // we need to modify first, as reparent would override all other changes
       file->modifyAccount(account);
       if (account.parentAccountId() != parent.id())
         file->reparentAccount(account, parent);
 
       ft.commit();
 
       // reload the account object as it might have changed in the meantime
       emit selectByObject(account, eView::Intent::None);
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(this, i18n("Unable to modify category '%1'. Cause: %2", d->m_currentCategory.name(), e.what()));
+      KMessageBox::error(this, i18n("Unable to modify category '%1'. Cause: %2", d->m_currentCategory.name(), QString::fromLatin1(e.what())));
     }
   }
 
   delete dlg;
   //        ready();
 }
 
 void KCategoriesView::slotDeleteCategory()
 {
     Q_D(KCategoriesView);
     if (d->m_currentCategory.id().isEmpty())
       return;  // need an account ID
 
     const auto file = MyMoneyFile::instance();
     // can't delete standard accounts or account which still have transactions assigned
     if (file->isStandardAccount(d->m_currentCategory.id()))
       return;
 
     // check if the account is referenced by a transaction or schedule
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(false);
     skip.setBit((int)eStorage::Reference::Account);
     skip.setBit((int)eStorage::Reference::Institution);
     skip.setBit((int)eStorage::Reference::Payee);
     skip.setBit((int)eStorage::Reference::Tag);
     skip.setBit((int)eStorage::Reference::Security);
     skip.setBit((int)eStorage::Reference::Currency);
     skip.setBit((int)eStorage::Reference::Price);
     const auto hasReference = file->isReferenced(d->m_currentCategory, skip);
 
     // if we get here and still have transactions referencing the account, we
     // need to check with the user to possibly re-assign them to a different account
     auto needAskUser = true;
 
     MyMoneyFileTransaction ft;
 
     if (hasReference) {
       // show transaction reassignment dialog
 
       needAskUser = false;
       auto dlg = new KCategoryReassignDlg(this);
       auto categoryId = dlg->show(d->m_currentCategory);
       delete dlg; // and kill the dialog
       if (categoryId.isEmpty())
         return; // the user aborted the dialog, so let's abort as well
 
       auto newCategory = file->account(categoryId);
       try {
         {
           //        KMSTATUS(i18n("Adjusting transactions..."));
           /*
             d->m_currentCategory.id() is the old id, categoryId the new one
             Now search all transactions and schedules that reference d->m_currentCategory.id()
             and replace that with categoryId.
           */
           // get the list of all transactions that reference the old account
           MyMoneyTransactionFilter filter(d->m_currentCategory.id());
           filter.setReportAllSplits(false);
           QList<MyMoneyTransaction> tlist;
           QList<MyMoneyTransaction>::iterator it_t;
           file->transactionList(tlist, filter);
 
           //        slotStatusProgressBar(0, tlist.count());
 //          int cnt = 0;
           for (it_t = tlist.begin(); it_t != tlist.end(); ++it_t) {
             //          slotStatusProgressBar(++cnt, 0);
             MyMoneyTransaction t = (*it_t);
             if (t.replaceId(categoryId, d->m_currentCategory.id()))
               file->modifyTransaction(t);
           }
           //        slotStatusProgressBar(tlist.count(), 0);
         }
         // now fix all schedules
         {
           //        KMSTATUS(i18n("Adjusting scheduled transactions..."));
           QList<MyMoneySchedule> slist = file->scheduleList(d->m_currentCategory.id());
           QList<MyMoneySchedule>::iterator it_s;
 
 //          int cnt = 0;
           //        slotStatusProgressBar(0, slist.count());
           for (it_s = slist.begin(); it_s != slist.end(); ++it_s) {
             //          slotStatusProgressBar(++cnt, 0);
             MyMoneySchedule sch = (*it_s);
             if (sch.replaceId(categoryId, d->m_currentCategory.id())) {
               file->modifySchedule(sch);
             }
           }
           //        slotStatusProgressBar(slist.count(), 0);
         }
         // now fix all budgets
         {
           //        KMSTATUS(i18n("Adjusting budgets..."));
           QList<MyMoneyBudget> blist = file->budgetList();
           QList<MyMoneyBudget>::const_iterator it_b;
           for (it_b = blist.constBegin(); it_b != blist.constEnd(); ++it_b) {
             if ((*it_b).hasReferenceTo(d->m_currentCategory.id())) {
               MyMoneyBudget b = (*it_b);
               MyMoneyBudget::AccountGroup fromBudget = b.account(d->m_currentCategory.id());
               MyMoneyBudget::AccountGroup toBudget = b.account(categoryId);
               toBudget += fromBudget;
               b.setAccount(toBudget, categoryId);
               b.removeReference(d->m_currentCategory.id());
               file->modifyBudget(b);
 
             }
           }
           //        slotStatusProgressBar(blist.count(), 0);
         }
       } catch (MyMoneyException &e) {
-        KMessageBox::error(this, i18n("Unable to exchange category <b>%1</b> with category <b>%2</b>. Reason: %3", d->m_currentCategory.name(), newCategory.name(), e.what()));
+        KMessageBox::error(this, i18n("Unable to exchange category <b>%1</b> with category <b>%2</b>. Reason: %3", d->m_currentCategory.name(), newCategory.name(), QString::fromLatin1(e.what())));
         //    slotStatusProgressBar(-1, -1);
         return;
       }
       //    slotStatusProgressBar(-1, -1);
     }
 
     // retain the account name for a possible later usage in the error message box
     // since the account removal notifies the views the selected account can be changed
     // so we make sure by doing this that we display the correct name in the error message
     auto selectedAccountName = d->m_currentCategory.name();
 
     // at this point, we must not have a reference to the account
     // to be deleted anymore
     // special handling for categories to allow deleting of empty subcategories
     {
       // open a compound statement here to be able to declare variables
       // which would otherwise not work within a case label.
 
       // case A - only a single, unused category without subcats selected
       if (d->m_currentCategory.accountList().isEmpty()) {
         if (!needAskUser || (KMessageBox::questionYesNo(this, i18n("<qt>Do you really want to delete category <b>%1</b>?</qt>", selectedAccountName)) == KMessageBox::Yes)) {
           try {
             file->removeAccount(d->m_currentCategory);
             d->m_currentCategory.clearId();
             emit selectByObject(d->m_currentCategory, eView::Intent::None);
             ft.commit();
           } catch (const MyMoneyException &e) {
-            KMessageBox::error(this, i18n("<qt>Unable to delete category <b>%1</b>. Cause: %2</qt>", selectedAccountName, e.what()));
+            KMessageBox::error(this, i18n("<qt>Unable to delete category <b>%1</b>. Cause: %2</qt>", selectedAccountName, QString::fromLatin1(e.what())));
           }
         }
         return;
       }
       // case B - we have some subcategories, maybe the user does not want to
       //          delete them all, but just the category itself?
       auto parentAccount = file->account(d->m_currentCategory.parentAccountId());
 
       QStringList accountsToReparent;
       int result = KMessageBox::questionYesNoCancel(this,
                                                     i18n("<qt>Do you want to delete category <b>%1</b> with all its sub-categories or only "
                                                          "the category itself? If you only delete the category itself, all its sub-categories "
                                                          "will be made sub-categories of <b>%2</b>.</qt>", selectedAccountName, parentAccount.name()),
                                                     QString(),
                                                     KGuiItem(i18n("Delete all")),
                                                     KGuiItem(i18n("Just the category")));
       if (result == KMessageBox::Cancel)
         return; // cancel pressed? ok, no delete then...
       // "No" means "Just the category" and that means we need to reparent all subaccounts
       bool need_confirmation = false;
       // case C - User only wants to delete the category itself
       if (result == KMessageBox::No)
         accountsToReparent = d->m_currentCategory.accountList();
       else {
         // case D - User wants to delete all subcategories, now check all subcats of
         //          d->m_currentCategory and remember all that cannot be deleted and
         //          must be "reparented"
         foreach (const auto accountID, d->m_currentCategory.accountList()) {
           // reparent account if a transaction is assigned
           if (file->transactionCount(accountID) != 0)
             accountsToReparent.push_back(accountID);
           else if (!file->account(accountID).accountList().isEmpty()) {
             // or if we have at least one sub-account that is used for transactions
             if (!file->hasOnlyUnusedAccounts(file->account(accountID).accountList())) {
               accountsToReparent.push_back(accountID);
               //qDebug() << "subaccount not empty";
             }
           }
         }
         if (!accountsToReparent.isEmpty())
           need_confirmation = true;
       }
       if (!accountsToReparent.isEmpty() && need_confirmation) {
         if (KMessageBox::questionYesNo(this, i18n("<p>Some sub-categories of category <b>%1</b> cannot "
                                                   "be deleted, because they are still used. They will be made sub-categories of <b>%2</b>. Proceed?</p>", selectedAccountName, parentAccount.name())) != KMessageBox::Yes) {
           return; // user gets wet feet...
         }
       }
       // all good, now first reparent selected sub-categories
       try {
         auto parent = file->account(d->m_currentCategory.parentAccountId());
         for (QStringList::const_iterator it = accountsToReparent.constBegin(); it != accountsToReparent.constEnd(); ++it) {
           auto child = file->account(*it);
           file->reparentAccount(child, parent);
         }
         // reload the account because the sub-account list might have changed
         d->m_currentCategory = file->account(d->m_currentCategory.id());
         // now recursively delete remaining sub-categories
         file->removeAccountList(d->m_currentCategory.accountList());
         // don't forget to update d->m_currentCategory, because we still have a copy of
         // the old account list, which is no longer valid
         d->m_currentCategory = file->account(d->m_currentCategory.id());
       } catch (const MyMoneyException &e) {
-        KMessageBox::error(this, i18n("<qt>Unable to delete a sub-category of category <b>%1</b>. Reason: %2</qt>", selectedAccountName, e.what()));
+        KMessageBox::error(this, i18n("<qt>Unable to delete a sub-category of category <b>%1</b>. Reason: %2</qt>", selectedAccountName, QString::fromLatin1(e.what())));
         return;
       }
     }
     // the category/account is deleted after the switch
 
 
     try {
       file->removeAccount(d->m_currentCategory);
       d->m_currentCategory.clearId();
       emit selectByObject(MyMoneyAccount(), eView::Intent::None);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::error(this, i18n("Unable to delete category '%1'. Cause: %2", selectedAccountName, e.what()));
+      KMessageBox::error(this, i18n("Unable to delete category '%1'. Cause: %2", selectedAccountName, QString::fromLatin1(e.what())));
     }
 }
 
diff --git a/kmymoney/views/kgloballedgerview.cpp b/kmymoney/views/kgloballedgerview.cpp
index 6c8b95b09..ec139b34d 100644
--- a/kmymoney/views/kgloballedgerview.cpp
+++ b/kmymoney/views/kgloballedgerview.cpp
@@ -1,2071 +1,2071 @@
 /***************************************************************************
                           kgloballedgerview.cpp  -  description
                              -------------------
     begin                : Wed Jul 26 2006
     copyright            : (C) 2006 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kgloballedgerview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFrame>
 #include <QList>
 #include <QLabel>
 #include <QEvent>
 #include <QApplication>
 #include <QTimer>
 #include <QMenu>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToolBar>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyaccount.h"
 #include "mymoneyfile.h"
 #include "kmymoneyaccountcombo.h"
 #include "kmymoneypayeecombo.h"
 #include "keditscheduledlg.h"
 #include "kendingbalancedlg.h"
 #include "register.h"
 #include "transactioneditor.h"
 #include "selectedtransactions.h"
 #include "kmymoneysettings.h"
 #include "registersearchline.h"
 #include "kfindtransactiondlg.h"
 #include "accountsmodel.h"
 #include "models.h"
 #include "mymoneyschedule.h"
 #include "mymoneysecurity.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneysplit.h"
 #include "transaction.h"
 #include "transactionform.h"
 #include "widgetenums.h"
 #include "mymoneyenums.h"
 #include "menuenums.h"
 
 using namespace eMenu;
 
 QDate KGlobalLedgerViewPrivate::m_lastPostDate;
 
 KGlobalLedgerView::KGlobalLedgerView(QWidget *parent) :
   KMyMoneyViewBase(*new KGlobalLedgerViewPrivate(this), parent)
 {
   typedef void(KGlobalLedgerView::*KGlobalLedgerViewFunc)();
   const QHash<Action, KGlobalLedgerViewFunc> actionConnections {
     {Action::NewTransaction,            &KGlobalLedgerView::slotNewTransaction},
     {Action::EditTransaction,           &KGlobalLedgerView::slotEditTransaction},
     {Action::DeleteTransaction,         &KGlobalLedgerView::slotDeleteTransaction},
     {Action::DuplicateTransaction,      &KGlobalLedgerView::slotDuplicateTransaction},
     {Action::EnterTransaction,          &KGlobalLedgerView::slotEnterTransaction},
     {Action::AcceptTransaction,         &KGlobalLedgerView::slotAcceptTransaction},
     {Action::CancelTransaction,         &KGlobalLedgerView::slotCancelTransaction},
     {Action::EditSplits,                &KGlobalLedgerView::slotEditSplits},
     {Action::CopySplits,                &KGlobalLedgerView::slotCopySplits},
     {Action::GoToPayee,                 &KGlobalLedgerView::slotGoToPayee},
     {Action::GoToAccount,               &KGlobalLedgerView::slotGoToAccount},
     {Action::MatchTransaction,          &KGlobalLedgerView::slotMatchTransactions},
     {Action::CombineTransactions,       &KGlobalLedgerView::slotCombineTransactions},
     {Action::ToggleReconciliationFlag,  &KGlobalLedgerView::slotToggleReconciliationFlag},
     {Action::MarkCleared,               &KGlobalLedgerView::slotMarkCleared},
     {Action::MarkReconciled,            &KGlobalLedgerView::slotMarkReconciled},
     {Action::MarkNotReconciled,         &KGlobalLedgerView::slotMarkNotReconciled},
     {Action::SelectAllTransactions,     &KGlobalLedgerView::slotSelectAllTransactions},
     {Action::NewScheduledTransaction,   &KGlobalLedgerView::slotCreateScheduledTransaction},
     {Action::AssignTransactionsNumber,  &KGlobalLedgerView::slotAssignNumber},
     {Action::StartReconciliation,       &KGlobalLedgerView::slotStartReconciliation},
     {Action::FinishReconciliation,      &KGlobalLedgerView::slotFinishReconciliation},
     {Action::PostponeReconciliation,    &KGlobalLedgerView::slotPostponeReconciliation},
     {Action::OpenAccount,               &KGlobalLedgerView::slotOpenAccount},
     {Action::EditFindTransaction,       &KGlobalLedgerView::slotFindTransaction},
   };
 
   for (auto a = actionConnections.cbegin(); a != actionConnections.cend(); ++a)
     connect(pActions[a.key()], &QAction::triggered, this, a.value());
 
   Q_D(KGlobalLedgerView);
   d->m_balanceWarning.reset(new KBalanceWarning(this));
 }
 
 KGlobalLedgerView::~KGlobalLedgerView()
 {
 }
 
 void KGlobalLedgerView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KGlobalLedgerView);
         QTimer::singleShot(0, d->m_registerSearchLine->searchLine(), SLOT(setFocus()));
       }
       break;
 
     default:
       break;
   }
 }
 
 void KGlobalLedgerView::refresh()
 {
   Q_D(KGlobalLedgerView);
   if (isVisible()) {
     if (!d->m_inEditMode) {
       setUpdatesEnabled(false);
       d->loadView();
       setUpdatesEnabled(true);
       d->m_needsRefresh = false;
       // force a new account if the current one is empty
       d->m_newAccountLoaded = d->m_currentAccount.id().isEmpty();
     }
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KGlobalLedgerView::showEvent(QShowEvent* event)
 {
   Q_D(KGlobalLedgerView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Ledgers, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh) {
     if (!d->m_inEditMode) {
       setUpdatesEnabled(false);
       d->loadView();
       setUpdatesEnabled(true);
       d->m_needsRefresh = false;
       d->m_newAccountLoaded = false;
     }
 
   } else {
     if (!d->m_lastSelectedAccountID.isEmpty()) {
       try {
         const auto acc = MyMoneyFile::instance()->account(d->m_lastSelectedAccountID);
         slotSelectAccount(acc.id());
       } catch (const MyMoneyException &) {
         d->m_lastSelectedAccountID.clear();                                               // account is invalid
       }
     } else {
       slotSelectAccount(d->m_accountComboBox->getSelected());
     }
 
     KMyMoneyRegister::SelectedTransactions list(d->m_register);
     updateLedgerActions(list);
     emit selectByVariant(QVariantList {QVariant::fromValue(list)}, eView::Intent::SelectRegisterTransactions);
   }
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KGlobalLedgerView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KGlobalLedgerView);
 //  if (typeid(obj) != typeid(MyMoneyAccount) &&
 //      (obj.id().isEmpty() && d->m_currentAccount.id().isEmpty())) // do not disable actions that were already disabled))
 //    return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
 
   const QVector<Action> actionsToBeDisabled {
         Action::StartReconciliation,
         Action::FinishReconciliation,
         Action::PostponeReconciliation,
         Action::OpenAccount,
         Action::NewTransaction
   };
 
   for (const auto& a : actionsToBeDisabled)
     pActions[a]->setEnabled(false);
 
   auto b = acc.isClosed() ? false : true;
   pMenus[Menu::MoveTransaction]->setEnabled(b);
 
   QString tooltip;
   pActions[Action::NewTransaction]->setEnabled(canCreateTransactions(tooltip));
   pActions[Action::NewTransaction]->setToolTip(tooltip);
 
   const auto file = MyMoneyFile::instance();
   if (!acc.id().isEmpty() && !file->isStandardAccount(acc.id())) {
     switch (acc.accountGroup()) {
       case eMyMoney::Account::Type::Asset:
       case eMyMoney::Account::Type::Liability:
       case eMyMoney::Account::Type::Equity:
         pActions[Action::OpenAccount]->setEnabled(true);
         if (acc.accountGroup() != eMyMoney::Account::Type::Equity) {
           if (d->m_reconciliationAccount.id().isEmpty()) {
             pActions[Action::StartReconciliation]->setEnabled(true);
             pActions[Action::StartReconciliation]->setToolTip(i18n("Reconcile"));
           } else {
             auto tip = i18n("Reconcile - disabled because you are currently reconciling <b>%1</b>", d->m_reconciliationAccount.name());
             pActions[Action::StartReconciliation]->setToolTip(tip);
             if (!d->m_transactionEditor) {
               pActions[Action::FinishReconciliation]->setEnabled(acc.id() == d->m_reconciliationAccount.id());
               pActions[Action::PostponeReconciliation]->setEnabled(acc.id() == d->m_reconciliationAccount.id());
             }
           }
         }
         break;
       case eMyMoney::Account::Type::Income :
       case eMyMoney::Account::Type::Expense :
         pActions[Action::OpenAccount]->setEnabled(true);
         break;
       default:
         break;
     }
   }
 
   d->m_currentAccount = acc;
 //  slotSelectAccount(acc);
 }
 
 void KGlobalLedgerView::updateLedgerActions(const KMyMoneyRegister::SelectedTransactions& list)
 {
   Q_D(KGlobalLedgerView);
 
   d->selectTransactions(list);
   updateLedgerActionsInternal();
 }
 
 void KGlobalLedgerView::updateLedgerActionsInternal()
 {
   Q_D(KGlobalLedgerView);
   const QVector<Action> actionsToBeDisabled {
     Action::EditTransaction, Action::EditSplits, Action::EnterTransaction,
     Action::CancelTransaction, Action::DeleteTransaction, Action::MatchTransaction,
     Action::AcceptTransaction, Action::DuplicateTransaction, Action::ToggleReconciliationFlag, Action::MarkCleared,
     Action::GoToAccount, Action::GoToPayee, Action::AssignTransactionsNumber, Action::NewScheduledTransaction,
     Action::CombineTransactions, Action::SelectAllTransactions, Action::CopySplits,
   };
 
   for (const auto& a : actionsToBeDisabled)
     pActions[a]->setEnabled(false);
 
   const auto file = MyMoneyFile::instance();
 
   pActions[Action::MatchTransaction]->setText(i18nc("Button text for match transaction", "Match"));
 //  pActions[Action::TransactionNew]->setToolTip(i18n("Create a new transaction"));
 
   pMenus[Menu::MoveTransaction]->setEnabled(false);
   pMenus[Menu::MarkTransaction]->setEnabled(false);
   pMenus[Menu::MarkTransactionContext]->setEnabled(false);
 
   pActions[Action::SelectAllTransactions]->setEnabled(true);
   if (!d->m_selectedTransactions.isEmpty() && !d->m_selectedTransactions.first().isScheduled()) {
     // enable 'delete transaction' only if at least one of the
     // selected transactions does not reference a closed account
     bool enable = false;
     KMyMoneyRegister::SelectedTransactions::const_iterator it_t;
     for (it_t = d->m_selectedTransactions.constBegin(); (enable == false) && (it_t != d->m_selectedTransactions.constEnd()); ++it_t) {
       enable = !(*it_t).transaction().id().isEmpty() && !file->referencesClosedAccount((*it_t).transaction());
     }
     pActions[Action::DeleteTransaction]->setEnabled(enable);
 
     if (!d->m_transactionEditor) {
       QString tooltip = i18n("Duplicate the current selected transactions");
       pActions[Action::DuplicateTransaction]->setEnabled(canDuplicateTransactions(d->m_selectedTransactions, tooltip) && !d->m_selectedTransactions[0].transaction().id().isEmpty());
       pActions[Action::DuplicateTransaction]->setToolTip(tooltip);
 
       if (canEditTransactions(d->m_selectedTransactions, tooltip)) {
         pActions[Action::EditTransaction]->setEnabled(true);
         // editing splits is allowed only if we have one transaction selected
         if (d->m_selectedTransactions.count() == 1) {
           pActions[Action::EditSplits]->setEnabled(true);
         }
         if (d->m_currentAccount.isAssetLiability() && d->m_currentAccount.accountType() != eMyMoney::Account::Type::Investment) {
           pActions[Action::NewScheduledTransaction]->setEnabled(d->m_selectedTransactions.count() == 1);
         }
       }
       pActions[Action::EditTransaction]->setToolTip(tooltip);
 
       if (!d->m_currentAccount.isClosed())
         pMenus[Menu::MoveTransaction]->setEnabled(true);
 
       pMenus[Menu::MarkTransaction]->setEnabled(true);
       pMenus[Menu::MarkTransactionContext]->setEnabled(true);
 
       // Allow marking the transaction if at least one is selected
       pActions[Action::MarkCleared]->setEnabled(true);
       pActions[Action::MarkReconciled]->setEnabled(true);
       pActions[Action::MarkNotReconciled]->setEnabled(true);
       pActions[Action::ToggleReconciliationFlag]->setEnabled(true);
 
       if (!d->m_accountGoto.isEmpty())
         pActions[Action::GoToAccount]->setEnabled(true);
       if (!d->m_payeeGoto.isEmpty())
         pActions[Action::GoToPayee]->setEnabled(true);
 
       // Matching is enabled as soon as one regular and one imported transaction is selected
       int matchedCount = 0;
       int importedCount = 0;
       KMyMoneyRegister::SelectedTransactions::const_iterator it;
       for (it = d->m_selectedTransactions.constBegin(); it != d->m_selectedTransactions.constEnd(); ++it) {
         if ((*it).transaction().isImported())
           ++importedCount;
         if ((*it).split().isMatched())
           ++matchedCount;
       }
 
       if (d->m_selectedTransactions.count() == 2 /* && pActions[Action::TransactionEdit]->isEnabled() */) {
         pActions[Action::MatchTransaction]->setEnabled(true);
       }
       if (importedCount != 0 || matchedCount != 0)
         pActions[Action::AcceptTransaction]->setEnabled(true);
       if (matchedCount != 0) {
         pActions[Action::MatchTransaction]->setEnabled(true);
         pActions[Action::MatchTransaction]->setText(i18nc("Button text for unmatch transaction", "Unmatch"));
         pActions[Action::MatchTransaction]->setIcon(QIcon("process-stop"));
       }
 
       if (d->m_selectedTransactions.count() > 1) {
         pActions[Action::CombineTransactions]->setEnabled(true);
       }
       if (d->m_selectedTransactions.count() >= 2) {
         int singleSplitTransactions = 0;
         int multipleSplitTransactions = 0;
         foreach (const KMyMoneyRegister::SelectedTransaction& st, d->m_selectedTransactions) {
           switch (st.transaction().splitCount()) {
             case 0:
               break;
             case 1:
               singleSplitTransactions++;
               break;
             default:
               multipleSplitTransactions++;
               break;
           }
         }
         if (singleSplitTransactions > 0 && multipleSplitTransactions == 1) {
           pActions[Action::CopySplits]->setEnabled(true);
         }
       }
       if (d->m_selectedTransactions.count() >= 2) {
         int singleSplitTransactions = 0;
         int multipleSplitTransactions = 0;
         foreach(const KMyMoneyRegister::SelectedTransaction& st, d->m_selectedTransactions) {
           switch(st.transaction().splitCount()) {
             case 0:
               break;
             case 1:
               singleSplitTransactions++;
               break;
             default:
               multipleSplitTransactions++;
               break;
           }
         }
         if(singleSplitTransactions > 0 && multipleSplitTransactions == 1) {
           pActions[Action::CopySplits]->setEnabled(true);
         }
       }
     } else {
       pActions[Action::AssignTransactionsNumber]->setEnabled(d->m_transactionEditor->canAssignNumber());
       pActions[Action::NewTransaction]->setEnabled(false);
       pActions[Action::DeleteTransaction]->setEnabled(false);
       QString reason;
       pActions[Action::EnterTransaction]->setEnabled(d->m_transactionEditor->isComplete(reason));
       //FIXME: Port to KDE4
       // the next line somehow worked in KDE3 but does not have
       // any influence under KDE4
       ///  Works for me when 'reason' is set. Allan
       pActions[Action::EnterTransaction]->setToolTip(reason);
       pActions[Action::CancelTransaction]->setEnabled(true);
     }
   }
 }
 
 void KGlobalLedgerView::slotAboutToSelectItem(KMyMoneyRegister::RegisterItem* item, bool& okToSelect)
 {
   Q_UNUSED(item);
   slotCancelOrEnterTransactions(okToSelect);
 }
 
 void KGlobalLedgerView::slotUpdateSummaryLine(const KMyMoneyRegister::SelectedTransactions& selection)
 {
   Q_D(KGlobalLedgerView);
   if (selection.count() > 1) {
     MyMoneyMoney balance;
     foreach (const KMyMoneyRegister::SelectedTransaction& t, selection) {
       if (!t.isScheduled()) {
         balance += t.split().shares();
       }
     }
     d->m_rightSummaryLabel->setText(QString("%1: %2").arg(QChar(0x2211), balance.formatMoney("", d->m_precision)));
 
   } else {
     if (d->isReconciliationAccount()) {
       d->m_rightSummaryLabel->setText(i18n("Difference: %1", d->m_totalBalance.formatMoney("", d->m_precision)));
 
     } else {
       if (d->m_currentAccount.accountType() != eMyMoney::Account::Type::Investment) {
         d->m_rightSummaryLabel->setText(i18n("Balance: %1", d->m_totalBalance.formatMoney("", d->m_precision)));
         bool showNegative = d->m_totalBalance.isNegative();
         if (d->m_currentAccount.accountGroup() == eMyMoney::Account::Type::Liability && !d->m_totalBalance.isZero())
           showNegative = !showNegative;
         if (showNegative) {
           QPalette palette = d->m_rightSummaryLabel->palette();
           palette.setColor(d->m_rightSummaryLabel->foregroundRole(), KMyMoneySettings::schemeColor(SchemeColor::Negative));
           d->m_rightSummaryLabel->setPalette(palette);
         }
       } else {
         d->m_rightSummaryLabel->setText(i18n("Investment value: %1%2",
                                              d->m_balanceIsApproximated ? "~" : "",
                                              d->m_totalBalance.formatMoney(MyMoneyFile::instance()->baseCurrency().tradingSymbol(), d->m_precision)));
       }
     }
   }
 }
 
 void KGlobalLedgerView::resizeEvent(QResizeEvent* ev)
 {
   Q_D(KGlobalLedgerView);
   if (d->m_needLoad)
     d->init();
 
   d->m_register->resize((int)eWidgets::eTransaction::Column::Detail);
   d->m_form->resize((int)eWidgets::eTransactionForm::Column::Value1);
   KMyMoneyViewBase::resizeEvent(ev);
 }
 
 void KGlobalLedgerView::slotSetReconcileAccount(const MyMoneyAccount& acc, const QDate& reconciliationDate, const MyMoneyMoney& endingBalance)
 {
   Q_D(KGlobalLedgerView);
   if(d->m_needLoad)
     d->init();
 
   if (d->m_reconciliationAccount.id() != acc.id()) {
     // make sure the account is selected
     if (!acc.id().isEmpty())
       slotSelectAccount(acc.id());
 
     d->m_reconciliationAccount = acc;
     d->m_reconciliationDate = reconciliationDate;
     d->m_endingBalance = endingBalance;
     if (acc.accountGroup() == eMyMoney::Account::Type::Liability)
       d->m_endingBalance = -endingBalance;
 
     d->m_newAccountLoaded = true;
 
     if (acc.id().isEmpty()) {
       d->m_buttonbar->removeAction(pActions[Action::PostponeReconciliation]);
       d->m_buttonbar->removeAction(pActions[Action::FinishReconciliation]);
     } else {
       d->m_buttonbar->addAction(pActions[Action::PostponeReconciliation]);
       d->m_buttonbar->addAction(pActions[Action::FinishReconciliation]);
       // when we start reconciliation, we need to reload the view
       // because no data has been changed. When postponing or finishing
       // reconciliation, the data change in the engine takes care of updateing
       // the view.
       refresh();
     }
   }
 }
 
 void KGlobalLedgerView::slotSetReconcileAccount(const MyMoneyAccount& acc, const QDate& reconciliationDate)
 {
   slotSetReconcileAccount(acc, reconciliationDate, MyMoneyMoney());
 }
 
 void KGlobalLedgerView::slotSetReconcileAccount(const MyMoneyAccount& acc)
 {
   slotSetReconcileAccount(acc, QDate(), MyMoneyMoney());
 }
 
 void KGlobalLedgerView::slotSetReconcileAccount()
 {
   slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 }
 
 void KGlobalLedgerView::slotShowTransactionMenu(const MyMoneySplit& sp)
 {
   Q_UNUSED(sp)
   pMenus[Menu::Transaction]->exec(QCursor::pos());
 }
 
 void KGlobalLedgerView::slotContinueReconciliation()
 {
   Q_D(KGlobalLedgerView);
   const auto file = MyMoneyFile::instance();
   MyMoneyAccount account;
 
   try {
     account = file->account(d->m_currentAccount.id());
     // get rid of previous run.
     delete d->m_endingBalanceDlg;
     d->m_endingBalanceDlg = new KEndingBalanceDlg(account, this);
     if (account.isAssetLiability()) {
 
       if (d->m_endingBalanceDlg->exec() == QDialog::Accepted) {
         if (KMyMoneySettings::autoReconciliation()) {
           MyMoneyMoney startBalance = d->m_endingBalanceDlg->previousBalance();
           MyMoneyMoney endBalance = d->m_endingBalanceDlg->endingBalance();
           QDate endDate = d->m_endingBalanceDlg->statementDate();
 
           QList<QPair<MyMoneyTransaction, MyMoneySplit> > transactionList;
           MyMoneyTransactionFilter filter(account.id());
           filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
           filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
           filter.setDateFilter(QDate(), endDate);
           filter.setConsiderCategory(false);
           filter.setReportAllSplits(true);
           file->transactionList(transactionList, filter);
           QList<QPair<MyMoneyTransaction, MyMoneySplit> > result = d->automaticReconciliation(account, transactionList, endBalance - startBalance);
 
           if (!result.empty()) {
             QString message = i18n("KMyMoney has detected transactions matching your reconciliation data.\nWould you like KMyMoney to clear these transactions for you?");
             if (KMessageBox::questionYesNo(this,
                                            message,
                                            i18n("Automatic reconciliation"),
                                            KStandardGuiItem::yes(),
                                            KStandardGuiItem::no(),
                                            "AcceptAutomaticReconciliation") == KMessageBox::Yes) {
               // mark the transactions cleared
               KMyMoneyRegister::SelectedTransactions oldSelection = d->m_selectedTransactions;
               d->m_selectedTransactions.clear();
               QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplitResult(result);
               while (itTransactionSplitResult.hasNext()) {
                 const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplitResult.next();
                 d->m_selectedTransactions.append(KMyMoneyRegister::SelectedTransaction(transactionSplit.first, transactionSplit.second, QString()));
               }
               // mark all transactions in d->m_selectedTransactions as 'Cleared'
               d->markTransaction(eMyMoney::Split::State::Cleared);
               d->m_selectedTransactions = oldSelection;
             }
           }
         }
 
         if (!file->isStandardAccount(account.id()) &&
             account.isAssetLiability()) {
           if (!isVisible())
             emit customActionRequested(View::Ledgers, eView::Action::SwitchView);
           Models::instance()->accountsModel()->slotReconcileAccount(account, d->m_endingBalanceDlg->statementDate(), d->m_endingBalanceDlg->endingBalance());
           slotSetReconcileAccount(account, d->m_endingBalanceDlg->statementDate(), d->m_endingBalanceDlg->endingBalance());
 
           // check if the user requests us to create interest
           // or charge transactions.
           auto ti = d->m_endingBalanceDlg->interestTransaction();
           auto tc = d->m_endingBalanceDlg->chargeTransaction();
           MyMoneyFileTransaction ft;
           try {
             if (ti != MyMoneyTransaction()) {
               MyMoneyFile::instance()->addTransaction(ti);
             }
             if (tc != MyMoneyTransaction()) {
               MyMoneyFile::instance()->addTransaction(tc);
             }
             ft.commit();
 
           } catch (const MyMoneyException &e) {
-            qWarning("interest transaction not stored: '%s'", qPrintable(e.what()));
+            qWarning("interest transaction not stored: '%s'", e.what());
           }
 
           // reload the account object as it might have changed in the meantime
           d->m_reconciliationAccount = file->account(account.id());
           updateActions(d->m_currentAccount);
           updateLedgerActionsInternal();
           //            slotUpdateActions();
         }
       }
     }
   } catch (const MyMoneyException &) {
   }
 }
 
 void KGlobalLedgerView::slotLedgerSelected(const QString& _accId, const QString& transaction)
 {
   auto acc = MyMoneyFile::instance()->account(_accId);
   QString accId(_accId);
 
   switch (acc.accountType()) {
     case Account::Type::Stock:
       // if a stock account is selected, we show the
       // the corresponding parent (investment) account
       acc = MyMoneyFile::instance()->account(acc.parentAccountId());
       accId = acc.id();
       // intentional fall through
 
     case Account::Type::Checkings:
     case Account::Type::Savings:
     case Account::Type::Cash:
     case Account::Type::CreditCard:
     case Account::Type::Loan:
     case Account::Type::Asset:
     case Account::Type::Liability:
     case Account::Type::AssetLoan:
     case Account::Type::Income:
     case Account::Type::Expense:
     case Account::Type::Investment:
     case Account::Type::Equity:
       if (!isVisible())
         emit customActionRequested(View::Ledgers, eView::Action::SwitchView);
       slotSelectAccount(accId, transaction);
       break;
 
     case Account::Type::CertificateDep:
     case Account::Type::MoneyMarket:
     case Account::Type::Currency:
       qDebug("No ledger view available for account type %d", (int)acc.accountType());
       break;
 
     default:
       qDebug("Unknown account type %d in KMyMoneyView::slotLedgerSelected", (int)acc.accountType());
       break;
   }
 }
 
 void KGlobalLedgerView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::FinishEnteringOverdueScheduledTransactions:
       slotContinueReconciliation();
       break;
 
     case eView::Intent::SynchronizeAccountInLedgersView:
       slotSelectAccount(obj);
       break;
 
     default:
       break;
   }
 }
 
 void KGlobalLedgerView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::ShowTransaction:
       if (variant.count() == 2)
         slotLedgerSelected(variant.at(0).toString(), variant.at(1).toString());
       break;
     default:
       break;
   }
 }
 
 void KGlobalLedgerView::slotSelectAccount(const MyMoneyObject& obj)
 {
   Q_D(KGlobalLedgerView);
   if (typeid(obj) != typeid(MyMoneyAccount))
     return/* false */;
 
   d->m_lastSelectedAccountID = obj.id();
 }
 
 void KGlobalLedgerView::slotSelectAccount(const QString& id)
 {
   slotSelectAccount(id, QString());
 }
 
 bool KGlobalLedgerView::slotSelectAccount(const QString& id, const QString& transactionId)
 {
   Q_D(KGlobalLedgerView);
   auto rc = true;
 
   if (!id.isEmpty()) {
     if (d->m_currentAccount.id() != id) {
       try {
         d->m_currentAccount = MyMoneyFile::instance()->account(id);
         // if a stock account is selected, we show the
         // the corresponding parent (investment) account
         if (d->m_currentAccount.isInvest()) {
           d->m_currentAccount = MyMoneyFile::instance()->account(d->m_currentAccount.parentAccountId());
         }
         d->m_lastSelectedAccountID = d->m_currentAccount.id();
         d->m_newAccountLoaded = true;
         refresh();
       } catch (const MyMoneyException &) {
         qDebug("Unable to retrieve account %s", qPrintable(id));
         rc = false;
       }
     } else {
       // we need to refresh m_account.m_accountList, a child could have been deleted
       d->m_currentAccount = MyMoneyFile::instance()->account(id);
 
       emit selectByObject(d->m_currentAccount, eView::Intent::None);
       emit selectByObject(d->m_currentAccount, eView::Intent::SynchronizeAccountInInvestmentView);
     }
     d->selectTransaction(transactionId);
   }
   return rc;
 }
 
 bool KGlobalLedgerView::selectEmptyTransaction()
 {
   Q_D(KGlobalLedgerView);
   bool rc = false;
 
   if (!d->m_inEditMode) {
     // in case we don't know the type of transaction to be created,
     // have at least one selected transaction and the id of
     // this transaction is not empty, we take it as template for the
     // transaction to be created
     KMyMoneyRegister::SelectedTransactions list(d->m_register);
     if ((d->m_action == eWidgets::eRegister::Action::None) && (!list.isEmpty()) && (!list[0].transaction().id().isEmpty())) {
       // the new transaction to be created will have the same type
       // as the one that currently has the focus
       KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(d->m_register->focusItem());
       if (t)
         d->m_action = t->actionType();
       d->m_register->clearSelection();
     }
 
     // if we still don't have an idea which type of transaction
     // to create, we use the default.
     if (d->m_action == eWidgets::eRegister::Action::None) {
       d->setupDefaultAction();
     }
 
     d->m_register->selectItem(d->m_register->lastItem());
     d->m_register->updateRegister();
     rc = true;
   }
   return rc;
 }
 
 TransactionEditor* KGlobalLedgerView::startEdit(const KMyMoneyRegister::SelectedTransactions& list)
 {
   Q_D(KGlobalLedgerView);
   // we use the warnlevel to keep track, if we have to warn the
   // user that some or all splits have been reconciled or if the
   // user cannot modify the transaction if at least one split
   // has the status frozen. The following value are used:
   //
   // 0 - no sweat, user can modify
   // 1 - user should be warned that at least one split has been reconciled
   //     already
   // 2 - user will be informed, that this transaction cannot be changed anymore
 
   int warnLevel = list.warnLevel();
   Q_ASSERT(warnLevel < 2);  // otherwise the edit action should not be enabled
 
   switch (warnLevel) {
     case 0:
       break;
 
     case 1:
       if (KMessageBox::warningContinueCancel(this,
                                              i18n(
                                                "At least one split of the selected transactions has been reconciled. "
                                                "Do you wish to continue to edit the transactions anyway?"
                                                ),
                                              i18n("Transaction already reconciled"), KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
                                              "EditReconciledTransaction") == KMessageBox::Cancel) {
         warnLevel = 2;
       }
       break;
 
     case 2:
       KMessageBox::sorry(this,
                          i18n("At least one split of the selected transactions has been frozen. "
                               "Editing the transactions is therefore prohibited."),
                          i18n("Transaction already frozen"));
       break;
 
     case 3:
       KMessageBox::sorry(this,
                          i18n("At least one split of the selected transaction references an account that has been closed. "
                               "Editing the transactions is therefore prohibited."),
                          i18n("Account closed"));
       break;
   }
 
   if (warnLevel > 1)
     return 0;
 
 
   TransactionEditor* editor = 0;
   KMyMoneyRegister::Transaction* item = dynamic_cast<KMyMoneyRegister::Transaction*>(d->m_register->focusItem());
 
   if (item) {
     // in case the current focus item is not selected, we move the focus to the first selected transaction
     if (!item->isSelected()) {
       KMyMoneyRegister::RegisterItem* p;
       for (p = d->m_register->firstItem(); p; p = p->nextItem()) {
         KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
         if (t && t->isSelected()) {
           d->m_register->setFocusItem(t);
           item = t;
           break;
         }
       }
     }
 
     // decide, if we edit in the register or in the form
     TransactionEditorContainer* parent;
     if (d->m_formFrame->isVisible())
       parent = d->m_form;
     else {
       parent = d->m_register;
     }
 
     editor = item->createEditor(parent, list, KGlobalLedgerViewPrivate::m_lastPostDate);
 
     // check that we use the same transaction commodity in all selected transactions
     // if not, we need to update this in the editor's list. The user can also bail out
     // of this operation which means that we have to stop editing here.
     if (editor) {
       if (!editor->fixTransactionCommodity(d->m_currentAccount)) {
         // if the user wants to quit, we need to destroy the editor
         // and bail out
         delete editor;
         editor = 0;
       }
     }
 
     if (editor) {
       if (parent == d->m_register) {
         // make sure, the height of the table is correct
         d->m_register->updateRegister(KMyMoneySettings::ledgerLens() | !KMyMoneySettings::transactionForm());
       }
 
       d->m_inEditMode = true;
       connect(editor, &TransactionEditor::transactionDataSufficient, pActions[Action::EnterTransaction], &QAction::setEnabled);
       connect(editor, &TransactionEditor::returnPressed, pActions[Action::EnterTransaction], &QAction::trigger);
       connect(editor, &TransactionEditor::escapePressed, pActions[Action::CancelTransaction], &QAction::trigger);
 
       connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, editor, &TransactionEditor::slotReloadEditWidgets);
       connect(editor, &TransactionEditor::finishEdit, this, &KGlobalLedgerView::slotLeaveEditMode);
       connect(editor, &TransactionEditor::objectCreation, d->m_mousePressFilter, &MousePressFilter::setFilterDeactive);
       connect(editor, &TransactionEditor::assignNumber, this, &KGlobalLedgerView::slotAssignNumber);
       connect(editor, &TransactionEditor::lastPostDateUsed, this, &KGlobalLedgerView::slotKeepPostDate);
 
       // create the widgets, place them in the parent and load them with data
       // setup tab order
       d->m_tabOrderWidgets.clear();
       editor->setup(d->m_tabOrderWidgets, d->m_currentAccount, d->m_action);
 
       Q_ASSERT(!d->m_tabOrderWidgets.isEmpty());
 
       // install event filter in all taborder widgets
       QWidgetList::const_iterator it_w = d->m_tabOrderWidgets.constBegin();
       for (; it_w != d->m_tabOrderWidgets.constEnd(); ++it_w) {
         (*it_w)->installEventFilter(this);
       }
       // Install a filter that checks if a mouse press happened outside
       // of one of our own widgets.
       qApp->installEventFilter(d->m_mousePressFilter);
 
       // Check if the editor has some preference on where to set the focus
       // If not, set the focus to the first widget in the tab order
       QWidget* focusWidget = editor->firstWidget();
       if (!focusWidget)
         focusWidget = d->m_tabOrderWidgets.first();
 
       // for some reason, this only works reliably if delayed a bit
       QTimer::singleShot(10, focusWidget, SLOT(setFocus()));
 
       // preset to 'I have no idea which type to create' for the next round.
       d->m_action = eWidgets::eRegister::Action::None;
     }
   }
   return editor;
 }
 
 void KGlobalLedgerView::slotTransactionsContextMenuRequested()
 {
   Q_D(KGlobalLedgerView);
   auto transactions = d->m_selectedTransactions;
   updateLedgerActionsInternal();
 //  emit transactionsSelected(d->m_selectedTransactions); // that should select MyMoneySchedule in KScheduledView
   if (!transactions.isEmpty() && transactions.first().isScheduled())
     emit selectByObject(MyMoneyFile::instance()->schedule(transactions.first().scheduleId()), eView::Intent::OpenContextMenu);
   else
     slotShowTransactionMenu(MyMoneySplit());
 }
 
 void KGlobalLedgerView::slotLeaveEditMode(const KMyMoneyRegister::SelectedTransactions& list)
 {
   Q_D(KGlobalLedgerView);
   d->m_inEditMode = false;
   qApp->removeEventFilter(d->m_mousePressFilter);
 
   // a possible focusOut event may have removed the focus, so we
   // install it back again.
   d->m_register->focusItem()->setFocus(true);
 
   // if we come back from editing a new item, we make sure that
   // we always select the very last known transaction entry no
   // matter if the transaction has been created or not.
 
   if (list.count() && list[0].transaction().id().isEmpty()) {
     // block signals to prevent some infinite loops that might occur here.
     d->m_register->blockSignals(true);
     d->m_register->clearSelection();
     KMyMoneyRegister::RegisterItem* p = d->m_register->lastItem();
     if (p && p->prevItem())
       p = p->prevItem();
     d->m_register->selectItem(p);
     d->m_register->updateRegister(true);
     d->m_register->blockSignals(false);
     // we need to update the form manually as sending signals was blocked
     KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
     if (t)
       d->m_form->slotSetTransaction(t);
   } else {
     if (!KMyMoneySettings::transactionForm()) {
       // update the row height of the transactions because it might differ between viewing/editing mode when not using the transaction form
       d->m_register->blockSignals(true);
       d->m_register->updateRegister(true);
       d->m_register->blockSignals(false);
     }
   }
   d->m_needsRefresh = true; // TODO: Why transaction in view doesn't update without this?
   if (d->m_needsRefresh)
     refresh();
 
   d->m_register->setFocus();
 }
 
 bool KGlobalLedgerView::focusNextPrevChild(bool next)
 {
   Q_D(KGlobalLedgerView);
   bool  rc = false;
   // qDebug("KGlobalLedgerView::focusNextPrevChild(editmode=%s)", m_inEditMode ? "true" : "false");
   if (d->m_inEditMode) {
     QWidget *w = 0;
 
     w = qApp->focusWidget();
     // qDebug("w = %p", w);
     int currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
     while (w && currentWidgetIndex == -1) {
       // qDebug("'%s' not in list, use parent", qPrintable(w->objectName()));
       w = w->parentWidget();
       currentWidgetIndex = d->m_tabOrderWidgets.indexOf(w);
     }
 
     if (currentWidgetIndex != -1) {
       // if(w) qDebug("tab order is at '%s'", qPrintable(w->objectName()));
       currentWidgetIndex += next ? 1 : -1;
       if (currentWidgetIndex < 0)
         currentWidgetIndex = d->m_tabOrderWidgets.size() - 1;
       else if (currentWidgetIndex >= d->m_tabOrderWidgets.size())
         currentWidgetIndex = 0;
 
       w = d->m_tabOrderWidgets[currentWidgetIndex];
       // qDebug("currentWidgetIndex = %d, w = %p", currentWidgetIndex, w);
 
       if (((w->focusPolicy() & Qt::TabFocus) == Qt::TabFocus) && w->isVisible() && w->isEnabled()) {
         // qDebug("Selecting '%s' (%p) as focus", qPrintable(w->objectName()), w);
         w->setFocus();
         rc = true;
       }
     }
   } else
     rc = KMyMoneyViewBase::focusNextPrevChild(next);
   return rc;
 }
 
 bool KGlobalLedgerView::eventFilter(QObject* o, QEvent* e)
 {
   Q_D(KGlobalLedgerView);
   bool rc = false;
   //  Need to capture mouse position here as QEvent::ToolTip is too slow
   d->m_tooltipPosn = QCursor::pos();
 
   if (e->type() == QEvent::KeyPress) {
     if (d->m_inEditMode) {
       // qDebug("object = %s, key = %d", o->className(), k->key());
       if (o == d->m_register) {
         // we hide all key press events from the register
         // while editing a transaction
         rc = true;
       }
     }
   }
 
   if (!rc)
     rc = KMyMoneyViewBase::eventFilter(o, e);
 
   return rc;
 }
 
 void KGlobalLedgerView::slotSortOptions()
 {
   Q_D(KGlobalLedgerView);
   QPointer<KSortOptionDlg> dlg = new KSortOptionDlg(this);
 
   QString key;
   QString sortOrder, def;
   if (d->isReconciliationAccount()) {
     key = "kmm-sort-reconcile";
     def = KMyMoneySettings::sortReconcileView();
   } else {
     key = "kmm-sort-std";
     def = KMyMoneySettings::sortNormalView();
   }
 
   // check if we have an account override of the sort order
   if (!d->m_currentAccount.value(key).isEmpty())
     sortOrder = d->m_currentAccount.value(key);
 
   QString oldOrder = sortOrder;
 
   dlg->setSortOption(sortOrder, def);
 
   if (dlg->exec() == QDialog::Accepted) {
     if (dlg != 0) {
       sortOrder = dlg->sortOption();
       if (sortOrder != oldOrder) {
         if (sortOrder.isEmpty()) {
           d->m_currentAccount.deletePair(key);
         } else {
           d->m_currentAccount.setValue(key, sortOrder);
         }
         MyMoneyFileTransaction ft;
         try {
           MyMoneyFile::instance()->modifyAccount(d->m_currentAccount);
           ft.commit();
         } catch (const MyMoneyException &e) {
-          qDebug("Unable to update sort order for account '%s': %s", qPrintable(d->m_currentAccount.name()), qPrintable(e.what()));
+          qDebug("Unable to update sort order for account '%s': %s", qPrintable(d->m_currentAccount.name()), e.what());
         }
       }
     }
   }
   delete dlg;
 }
 
 void KGlobalLedgerView::slotToggleTransactionMark(KMyMoneyRegister::Transaction* /* t */)
 {
   Q_D(KGlobalLedgerView);
   if (!d->m_inEditMode) {
     slotToggleReconciliationFlag();
   }
 }
 
 void KGlobalLedgerView::slotKeepPostDate(const QDate& date)
 {
   KGlobalLedgerViewPrivate::m_lastPostDate = date;
 }
 
 QString KGlobalLedgerView::accountId() const
 {
   Q_D(const KGlobalLedgerView);
   return d->m_currentAccount.id();
 }
 
 bool KGlobalLedgerView::canCreateTransactions(QString& tooltip) const
 {
   Q_D(const KGlobalLedgerView);
   bool rc = true;
   // we can only create transactions in the ledger view so
   // we check that this is the active page
   if(!isVisible()) {
     tooltip = i18n("Creating transactions can only be performed in the ledger view");
     rc = false;
   }
   if (d->m_currentAccount.id().isEmpty()) {
     tooltip = i18n("Cannot create transactions when no account is selected.");
     rc = false;
   }
   if (d->m_currentAccount.accountGroup() == eMyMoney::Account::Type::Income
       || d->m_currentAccount.accountGroup() == eMyMoney::Account::Type::Expense) {
     tooltip = i18n("Cannot create transactions in the context of a category.");
     d->showTooltip(tooltip);
     rc = false;
   }
   if (d->m_currentAccount.isClosed()) {
     tooltip = i18n("Cannot create transactions in a closed account.");
     d->showTooltip(tooltip);
     rc = false;
   }
   return rc;
 }
 
 bool KGlobalLedgerView::canModifyTransactions(const KMyMoneyRegister::SelectedTransactions& list, QString& tooltip) const
 {
   Q_D(const KGlobalLedgerView);
   return d->canProcessTransactions(list, tooltip) && list.canModify();
 }
 
 bool KGlobalLedgerView::canDuplicateTransactions(const KMyMoneyRegister::SelectedTransactions& list, QString& tooltip) const
 {
   Q_D(const KGlobalLedgerView);
   return d->canProcessTransactions(list, tooltip) && list.canDuplicate();
 }
 
 bool KGlobalLedgerView::canEditTransactions(const KMyMoneyRegister::SelectedTransactions& list, QString& tooltip) const
 {
   Q_D(const KGlobalLedgerView);
   // check if we can edit the list of transactions. We can edit, if
   //
   //   a) no mix of standard and investment transactions exist
   //   b) if a split transaction is selected, this is the only selection
   //   c) none of the splits is frozen
   //   d) the transaction having the current focus is selected
 
   // check for d)
   if (!d->canProcessTransactions(list, tooltip))
     return false;
   // check for c)
   if (list.warnLevel() == 2) {
     tooltip = i18n("Cannot edit transactions with frozen splits.");
     d->showTooltip(tooltip);
     return false;
   }
 
   bool rc = true;
   int investmentTransactions = 0;
   int normalTransactions = 0;
 
   if (d->m_currentAccount.accountGroup() == eMyMoney::Account::Type::Income
       || d->m_currentAccount.accountGroup() == eMyMoney::Account::Type::Expense) {
     tooltip = i18n("Cannot edit transactions in the context of a category.");
     d->showTooltip(tooltip);
     rc = false;
   }
 
   if (d->m_currentAccount.isClosed()) {
     tooltip = i18n("Cannot create or edit any transactions in Account %1 as it is closed", d->m_currentAccount.name());
     d->showTooltip(tooltip);
     rc = false;
   }
 
   KMyMoneyRegister::SelectedTransactions::const_iterator it_t;
   QString action;
   for (it_t = list.begin(); rc && it_t != list.end(); ++it_t) {
     if ((*it_t).transaction().id().isEmpty()) {
       tooltip.clear();
       rc = false;
       continue;
     }
 
     if (KMyMoneyUtils::transactionType((*it_t).transaction()) == KMyMoneyUtils::InvestmentTransaction) {
       if (action.isEmpty()) {
         action = (*it_t).split().action();
         continue;
       }
       if (action == (*it_t).split().action()) {
         continue;
       } else {
         tooltip = (i18n("Cannot edit mixed investment action/type transactions together."));
         d->showTooltip(tooltip);
         rc = false;
         break;
       }
     }
 
     if (KMyMoneyUtils::transactionType((*it_t).transaction()) == KMyMoneyUtils::InvestmentTransaction)
       ++investmentTransactions;
     else
       ++normalTransactions;
 
     // check for a)
     if (investmentTransactions != 0 && normalTransactions != 0) {
       tooltip = i18n("Cannot edit investment transactions and non-investment transactions together.");
       d->showTooltip(tooltip);
       rc = false;
       break;
     }
 
     // check for b) but only for normalTransactions
     if ((*it_t).transaction().splitCount() > 2 && normalTransactions != 0) {
       if (list.count() > 1) {
         tooltip = i18n("Cannot edit multiple split transactions at once.");
         d->showTooltip(tooltip);
         rc = false;
         break;
       }
     }
   }
 
   // check for multiple transactions being selected in an investment account
   // we do not allow editing in this case: https://bugs.kde.org/show_bug.cgi?id=240816
   // later on, we might allow to edit investment transactions of the same type
   ///  Can now disable the following check.
 
   /*  if (rc == true && investmentTransactions > 1) {
       tooltip = i18n("Cannot edit multiple investment transactions at once");
       rc = false;
     }*/
 
   // now check that we have the correct account type for investment transactions
   if (rc == true && investmentTransactions != 0) {
     if (d->m_currentAccount.accountType() != eMyMoney::Account::Type::Investment) {
       tooltip = i18n("Cannot edit investment transactions in the context of this account.");
       rc = false;
     }
   }
   return rc;
 }
 
 void KGlobalLedgerView::slotMoveToAccount(const QString& id)
 {
   Q_D(KGlobalLedgerView);
   // close the menu, if it is still open
   if (pMenus[Menu::Transaction]->isVisible())
     pMenus[Menu::Transaction]->close();
 
   if (!d->m_selectedTransactions.isEmpty()) {
     MyMoneyFileTransaction ft;
     try {
       foreach (const auto selection, d->m_selectedTransactions) {
         if (d->m_currentAccount.accountType() == eMyMoney::Account::Type::Investment) {
           d->moveInvestmentTransaction(d->m_currentAccount.id(), id, selection.transaction());
         } else {
           auto changed = false;
           auto t = selection.transaction();
 
           foreach (const auto split, selection.transaction().splits()) {
             if (split.accountId() == d->m_currentAccount.id()) {
               MyMoneySplit s = split;
               s.setAccountId(id);
               t.modifySplit(s);
               changed = true;
             }
           }
           if (changed) {
             MyMoneyFile::instance()->modifyTransaction(t);
           }
         }
       }
       ft.commit();
     } catch (const MyMoneyException &) {
     }
   }
 }
 
 void KGlobalLedgerView::slotUpdateMoveToAccountMenu()
 {
   Q_D(KGlobalLedgerView);
   d->createTransactionMoveMenu();
 
   // in case we were not able to create the selector, we
   // better get out of here. Anything else would cause
   // a crash later on (accountSet.load)
   if (!d->m_moveToAccountSelector)
     return;
 
   if (!d->m_currentAccount.id().isEmpty()) {
     AccountSet accountSet;
     if (d->m_currentAccount.accountType() == eMyMoney::Account::Type::Investment) {
       accountSet.addAccountType(eMyMoney::Account::Type::Investment);
     } else if (d->m_currentAccount.isAssetLiability()) {
 
       accountSet.addAccountType(eMyMoney::Account::Type::Checkings);
       accountSet.addAccountType(eMyMoney::Account::Type::Savings);
       accountSet.addAccountType(eMyMoney::Account::Type::Cash);
       accountSet.addAccountType(eMyMoney::Account::Type::AssetLoan);
       accountSet.addAccountType(eMyMoney::Account::Type::CertificateDep);
       accountSet.addAccountType(eMyMoney::Account::Type::MoneyMarket);
       accountSet.addAccountType(eMyMoney::Account::Type::Asset);
       accountSet.addAccountType(eMyMoney::Account::Type::Currency);
       accountSet.addAccountType(eMyMoney::Account::Type::CreditCard);
       accountSet.addAccountType(eMyMoney::Account::Type::Loan);
       accountSet.addAccountType(eMyMoney::Account::Type::Liability);
     } else if (d->m_currentAccount.isIncomeExpense()) {
       accountSet.addAccountType(eMyMoney::Account::Type::Income);
       accountSet.addAccountType(eMyMoney::Account::Type::Expense);
     }
 
     accountSet.load(d->m_moveToAccountSelector);
     // remove those accounts that we currently reference
     foreach (const auto selection, d->m_selectedTransactions) {
       foreach (const auto split, selection.transaction().splits()) {
         d->m_moveToAccountSelector->removeItem(split.accountId());
       }
     }
     // remove those accounts from the list that are denominated
     // in a different currency
     auto list = d->m_moveToAccountSelector->accountList();
     QList<QString>::const_iterator it_a;
     for (it_a = list.constBegin(); it_a != list.constEnd(); ++it_a) {
       auto acc = MyMoneyFile::instance()->account(*it_a);
       if (acc.currencyId() != d->m_currentAccount.currencyId())
         d->m_moveToAccountSelector->removeItem((*it_a));
     }
   }
 }
 
 void KGlobalLedgerView::slotObjectDestroyed(QObject* o)
 {
   Q_D(KGlobalLedgerView);
   if (o == d->m_moveToAccountSelector) {
     d->m_moveToAccountSelector = nullptr;
   }
 }
 
 void KGlobalLedgerView::slotCancelOrEnterTransactions(bool& okToSelect)
 {
   Q_D(KGlobalLedgerView);
   static bool oneTime = false;
   if (!oneTime) {
     oneTime = true;
     auto dontShowAgain = "CancelOrEditTransaction";
     // qDebug("KMyMoneyApp::slotCancelOrEndEdit");
     if (d->m_transactionEditor) {
       if (KMyMoneySettings::focusChangeIsEnter() && pActions[Action::EnterTransaction]->isEnabled()) {
         slotEnterTransaction();
         if (d->m_transactionEditor) {
           // if at this stage the editor is still there that means that entering the transaction was cancelled
           // for example by pressing cancel on the exchange rate editor so we must stay in edit mode
           okToSelect = false;
         }
       } else {
         // okToSelect is preset to true if a cancel of the dialog is useful and false if it is not
         int rc;
         KGuiItem noGuiItem = KStandardGuiItem::save();
         KGuiItem yesGuiItem = KStandardGuiItem::discard();
         KGuiItem cancelGuiItem = KStandardGuiItem::cont();
 
         // if the transaction can't be entered make sure that it can't be entered by pressing no either
         if (!pActions[Action::EnterTransaction]->isEnabled()) {
           noGuiItem.setEnabled(false);
           noGuiItem.setToolTip(pActions[Action::EnterTransaction]->toolTip());
         }
         if (okToSelect == true) {
           rc = KMessageBox::warningYesNoCancel(this, i18n("<p>Please select what you want to do: discard the changes, save the changes or continue to edit the transaction.</p><p>You can also set an option to save the transaction automatically when e.g. selecting another transaction.</p>"), i18n("End transaction edit"), yesGuiItem, noGuiItem, cancelGuiItem, dontShowAgain);
 
         } else {
           rc = KMessageBox::warningYesNo(this, i18n("<p>Please select what you want to do: discard the changes, save the changes or continue to edit the transaction.</p><p>You can also set an option to save the transaction automatically when e.g. selecting another transaction.</p>"), i18n("End transaction edit"), yesGuiItem, noGuiItem, dontShowAgain);
         }
 
         switch (rc) {
           case KMessageBox::Yes:
             slotCancelTransaction();
             break;
           case KMessageBox::No:
             slotEnterTransaction();
             // make sure that we'll see this message the next time no matter
             // if the user has chosen the 'Don't show again' checkbox
             KMessageBox::enableMessage(dontShowAgain);
             if (d->m_transactionEditor) {
               // if at this stage the editor is still there that means that entering the transaction was cancelled
               // for example by pressing cancel on the exchange rate editor so we must stay in edit mode
               okToSelect = false;
             }
             break;
           case KMessageBox::Cancel:
             // make sure that we'll see this message the next time no matter
             // if the user has chosen the 'Don't show again' checkbox
             KMessageBox::enableMessage(dontShowAgain);
             okToSelect = false;
             break;
         }
       }
     }
     oneTime = false;
   }
 }
 
 void KGlobalLedgerView::slotNewSchedule(const MyMoneyTransaction& _t, eMyMoney::Schedule::Occurrence occurrence)
 {
   KEditScheduleDlg::newSchedule(_t, occurrence);
 }
 
 void KGlobalLedgerView::slotNewTransactionForm(eWidgets::eRegister::Action id)
 {
   Q_D(KGlobalLedgerView);
   if (!d->m_inEditMode) {
     d->m_action = id;
     // since we jump here via code, we have to make sure to react only
     // if the action is enabled
     if (pActions[Action::NewTransaction]->isEnabled()) {
       if (d->createNewTransaction()) {
         d->m_transactionEditor = d->startEdit(d->m_selectedTransactions);
         if (d->m_transactionEditor) {
           KMyMoneyMVCCombo::setSubstringSearchForChildren(this/*d->m_myMoneyView*/, !KMyMoneySettings::stringMatchFromStart());
           KMyMoneyPayeeCombo* payeeEdit = dynamic_cast<KMyMoneyPayeeCombo*>(d->m_transactionEditor->haveWidget("payee"));
           if (payeeEdit && !d->m_lastPayeeEnteredId.isEmpty()) {
             // in case we entered a new transaction before and used a payee,
             // we reuse it here. Save the text to the edit widget, select it
             // so that hitting any character will start entering another payee.
             payeeEdit->setSelectedItem(d->m_lastPayeeEnteredId);
             payeeEdit->lineEdit()->selectAll();
           }
           if (d->m_transactionEditor) {
             connect(d->m_transactionEditor.data(), &TransactionEditor::statusProgress, this, &KGlobalLedgerView::slotStatusProgress);
             connect(d->m_transactionEditor.data(), &TransactionEditor::statusMsg, this, &KGlobalLedgerView::slotStatusMsg);
             connect(d->m_transactionEditor.data(), &TransactionEditor::scheduleTransaction, this, &KGlobalLedgerView::slotNewSchedule);
           }
           updateLedgerActionsInternal();
 //          emit transactionsSelected(d->m_selectedTransactions);
         }
       }
     }
   }
 }
 
 void KGlobalLedgerView::slotNewTransaction()
 {
   slotNewTransactionForm(eWidgets::eRegister::Action::None);
 }
 
 void KGlobalLedgerView::slotEditTransaction()
 {
   Q_D(KGlobalLedgerView);
   // qDebug("KMyMoneyApp::slotTransactionsEdit()");
   // since we jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[Action::EditTransaction]->isEnabled()) {
     // as soon as we edit a transaction, we don't remember the last payee entered
     d->m_lastPayeeEnteredId.clear();
     d->m_transactionEditor = d->startEdit(d->m_selectedTransactions);
     KMyMoneyMVCCombo::setSubstringSearchForChildren(this/*d->m_myMoneyView*/, !KMyMoneySettings::stringMatchFromStart());
     updateLedgerActionsInternal();
   }
 }
 
 void KGlobalLedgerView::slotDeleteTransaction()
 {
   Q_D(KGlobalLedgerView);
   // since we may jump here via code, we have to make sure to react only
   // if the action is enabled
   if (!pActions[Action::DeleteTransaction]->isEnabled())
     return;
   if (d->m_selectedTransactions.isEmpty())
     return;
   if (d->m_selectedTransactions.warnLevel() == 1) {
     if (KMessageBox::warningContinueCancel(this,
                                            i18n("At least one split of the selected transactions has been reconciled. "
                                                 "Do you wish to delete the transactions anyway?"),
                                            i18n("Transaction already reconciled")) == KMessageBox::Cancel)
       return;
   }
   auto msg =
       i18np("Do you really want to delete the selected transaction?",
             "Do you really want to delete all %1 selected transactions?",
             d->m_selectedTransactions.count());
 
   if (KMessageBox::questionYesNo(this, msg, i18n("Delete transaction")) == KMessageBox::Yes) {
     //KMSTATUS(i18n("Deleting transactions"));
     d->doDeleteTransactions();
   }
 }
 
 void KGlobalLedgerView::slotDuplicateTransaction()
 {
   Q_D(KGlobalLedgerView);
   // since we may jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[Action::DuplicateTransaction]->isEnabled()) {
     KMyMoneyRegister::SelectedTransactions selectionList = d->m_selectedTransactions;
     KMyMoneyRegister::SelectedTransactions::iterator it_t;
 
     int i = 0;
     int cnt = d->m_selectedTransactions.count();
     //    KMSTATUS(i18n("Duplicating transactions"));
     emit selectByVariant(QVariantList {QVariant(0), QVariant(cnt)}, eView::Intent::ReportProgress);
     MyMoneyFileTransaction ft;
     MyMoneyTransaction lt;
     try {
       foreach (const auto selection, selectionList) {
         auto t = selection.transaction();
         // wipe out any reconciliation information
         for (auto& split : t.splits()) {
           split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
           split.setReconcileDate(QDate());
           split.setBankID(QString());
         }
         // clear invalid data
         t.setEntryDate(QDate());
         t.clearId();
         // and set the post date to today
         t.setPostDate(QDate::currentDate());
 
         MyMoneyFile::instance()->addTransaction(t);
         lt = t;
         emit selectByVariant(QVariantList {QVariant(i++), QVariant(0)}, eView::Intent::ReportProgress);
       }
       ft.commit();
 
       // select the new transaction in the ledger
       if (!d->m_currentAccount.id().isEmpty())
         slotLedgerSelected(d->m_currentAccount.id(), lt.id());
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to duplicate transaction(s): %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to duplicate transaction(s)"), QString::fromLatin1(e.what()));
     }
     // switch off the progress bar
     emit selectByVariant(QVariantList {QVariant(-1), QVariant(-1)}, eView::Intent::ReportProgress);
   }
 }
 
 void KGlobalLedgerView::slotEnterTransaction()
 {
   Q_D(KGlobalLedgerView);
   // since we jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[Action::EnterTransaction]->isEnabled()) {
     // disable the action while we process it to make sure it's processed only once since
     // d->m_transactionEditor->enterTransactions(newId) will run QCoreApplication::processEvents
     // we could end up here twice which will cause a crash slotUpdateActions() will enable the action again
     pActions[Action::EnterTransaction]->setEnabled(false);
     if (d->m_transactionEditor) {
       QString accountId = d->m_currentAccount.id();
       QString newId;
       connect(d->m_transactionEditor.data(), &TransactionEditor::balanceWarning, d->m_balanceWarning.data(), &KBalanceWarning::slotShowMessage);
       if (d->m_transactionEditor->enterTransactions(newId)) {
         KMyMoneyPayeeCombo* payeeEdit = dynamic_cast<KMyMoneyPayeeCombo*>(d->m_transactionEditor->haveWidget("payee"));
         if (payeeEdit && !newId.isEmpty()) {
           d->m_lastPayeeEnteredId = payeeEdit->selectedItem();
         }
         d->deleteTransactionEditor();
       }
       if (!newId.isEmpty()) {
         slotLedgerSelected(accountId, newId);
       }
     }
     updateLedgerActionsInternal();
   }
 }
 
 void KGlobalLedgerView::slotAcceptTransaction()
 {
   Q_D(KGlobalLedgerView);
   KMyMoneyRegister::SelectedTransactions list = d->m_selectedTransactions;
   KMyMoneyRegister::SelectedTransactions::const_iterator it_t;
   int cnt = list.count();
   int i = 0;
   emit selectByVariant(QVariantList {QVariant(0), QVariant(cnt)}, eView::Intent::ReportProgress);
   MyMoneyFileTransaction ft;
   try {
     for (it_t = list.constBegin(); it_t != list.constEnd(); ++it_t) {
       // reload transaction in case it got changed during the course of this loop
       MyMoneyTransaction t = MyMoneyFile::instance()->transaction((*it_t).transaction().id());
       if (t.isImported()) {
         t.setImported(false);
         if (!d->m_currentAccount.id().isEmpty()) {
           foreach (const auto split, t.splits()) {
             if (split.accountId() == d->m_currentAccount.id()) {
               if (split.reconcileFlag() == eMyMoney::Split::State::NotReconciled) {
                 MyMoneySplit s = split;
                 s.setReconcileFlag(eMyMoney::Split::State::Cleared);
                 t.modifySplit(s);
               }
             }
           }
         }
         MyMoneyFile::instance()->modifyTransaction(t);
       }
       if ((*it_t).split().isMatched()) {
         // reload split in case it got changed during the course of this loop
         MyMoneySplit s = t.splitById((*it_t).split().id());
         TransactionMatcher matcher(d->m_currentAccount);
         matcher.accept(t, s);
       }
       emit selectByVariant(QVariantList {QVariant(i++), QVariant(0)}, eView::Intent::ReportProgress);
     }
     emit selectByVariant(QVariantList {QVariant(-1), QVariant(-1)}, eView::Intent::ReportProgress);
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to accept transaction: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to accept transaction"), QString::fromLatin1(e.what()));
   }
 }
 
 void KGlobalLedgerView::slotCancelTransaction()
 {
   Q_D(KGlobalLedgerView);
   // since we jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[Action::CancelTransaction]->isEnabled()) {
     // make sure, we block the enter function
     pActions[Action::EnterTransaction]->setEnabled(false);
     // qDebug("KMyMoneyApp::slotTransactionsCancel");
     d->deleteTransactionEditor();
     updateLedgerActions(d->m_selectedTransactions);
     emit selectByVariant(QVariantList {QVariant::fromValue(d->m_selectedTransactions)}, eView::Intent::SelectRegisterTransactions);
   }
 }
 
 void KGlobalLedgerView::slotEditSplits()
 {
   Q_D(KGlobalLedgerView);
   // since we jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[Action::EditSplits]->isEnabled()) {
     // as soon as we edit a transaction, we don't remember the last payee entered
     d->m_lastPayeeEnteredId.clear();
     d->m_transactionEditor = d->startEdit(d->m_selectedTransactions);
     updateLedgerActions(d->m_selectedTransactions);
     emit selectByVariant(QVariantList {QVariant::fromValue(d->m_selectedTransactions)}, eView::Intent::SelectRegisterTransactions);
 
     if (d->m_transactionEditor) {
       KMyMoneyMVCCombo::setSubstringSearchForChildren(this/*d->m_myMoneyView*/, !KMyMoneySettings::stringMatchFromStart());
       if (d->m_transactionEditor->slotEditSplits() == QDialog::Accepted) {
         MyMoneyFileTransaction ft;
         try {
           QString id;
           connect(d->m_transactionEditor.data(), &TransactionEditor::balanceWarning, d->m_balanceWarning.data(), &KBalanceWarning::slotShowMessage);
           d->m_transactionEditor->enterTransactions(id);
           ft.commit();
         } catch (const MyMoneyException &e) {
-          KMessageBox::detailedSorry(this, i18n("Error"), i18n("Unable to modify transaction: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+          KMessageBox::detailedSorry(this, i18n("nable to modify transaction"), QString::fromLatin1(e.what()));
         }
       }
     }
     d->deleteTransactionEditor();
     updateLedgerActions(d->m_selectedTransactions);
     emit selectByVariant(QVariantList {QVariant::fromValue(d->m_selectedTransactions)}, eView::Intent::SelectRegisterTransactions);
   }
 }
 
 void KGlobalLedgerView::slotCopySplits()
 {
   Q_D(KGlobalLedgerView);
   const auto file = MyMoneyFile::instance();
 
   if (d->m_selectedTransactions.count() >= 2) {
     int singleSplitTransactions = 0;
     int multipleSplitTransactions = 0;
     KMyMoneyRegister::SelectedTransaction selectedSourceTransaction;
     foreach (const auto& st, d->m_selectedTransactions) {
       switch (st.transaction().splitCount()) {
         case 0:
           break;
         case 1:
           singleSplitTransactions++;
           break;
         default:
           selectedSourceTransaction = st;
           multipleSplitTransactions++;
           break;
       }
     }
     if (singleSplitTransactions > 0 && multipleSplitTransactions == 1) {
       MyMoneyFileTransaction ft;
       try {
         const auto& sourceTransaction = selectedSourceTransaction.transaction();
         const auto& sourceSplit = selectedSourceTransaction.split();
         foreach (const KMyMoneyRegister::SelectedTransaction& st, d->m_selectedTransactions) {
           auto t = st.transaction();
 
           // don't process the source transaction
           if (sourceTransaction.id() == t.id()) {
             continue;
           }
 
           const auto& baseSplit = st.split();
 
           if (t.splitCount() == 1) {
             foreach (const auto& split, sourceTransaction.splits()) {
               // Don't copy the source split, as we already have that
               // as part of the destination transaction
               if (split.id() == sourceSplit.id()) {
                 continue;
               }
 
               MyMoneySplit sp(split);
               // clear the ID and reconciliation state
               sp.clearId();
               sp.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
               sp.setReconcileDate(QDate());
 
               // in case it is a simple transaction consisting of two splits,
               // we can adjust the share and value part of the second split we
               // just created. We need to keep a possible price in mind in case
               // of different currencies
               if (sourceTransaction.splitCount() == 2) {
                 sp.setValue(-baseSplit.value());
                 sp.setShares(-(baseSplit.shares() * baseSplit.price()));
               }
               t.addSplit(sp);
             }
             file->modifyTransaction(t);
           }
         }
         ft.commit();
       } catch (const MyMoneyException &) {
         qDebug() << "transactionCopySplits() failed";
       }
     }
   }
 }
 
 void KGlobalLedgerView::slotGoToPayee()
 {
   Q_D(KGlobalLedgerView);
   if (!d->m_payeeGoto.isEmpty()) {
     try {
       QString transactionId;
       if (d->m_selectedTransactions.count() == 1) {
         transactionId = d->m_selectedTransactions[0].transaction().id();
       }
       // make sure to pass copies, as d->myMoneyView->slotPayeeSelected() overrides
       // d->m_payeeGoto and d->m_currentAccount while calling slotUpdateActions()
       QString payeeId = d->m_payeeGoto;
       QString accountId = d->m_currentAccount.id();
       emit selectByVariant(QVariantList {QVariant(payeeId), QVariant(accountId), QVariant(transactionId)}, eView::Intent::ShowPayee);
 //      emit openPayeeRequested(payeeId, accountId, transactionId);
     } catch (const MyMoneyException &) {
     }
   }
 }
 
 void KGlobalLedgerView::slotGoToAccount()
 {
   Q_D(KGlobalLedgerView);
   if (!d->m_accountGoto.isEmpty()) {
     try {
       QString transactionId;
       if (d->m_selectedTransactions.count() == 1) {
         transactionId = d->m_selectedTransactions[0].transaction().id();
       }
       // make sure to pass a copy, as d->myMoneyView->slotLedgerSelected() overrides
       // d->m_accountGoto while calling slotUpdateActions()
       slotLedgerSelected(d->m_accountGoto, transactionId);
     } catch (const MyMoneyException &) {
     }
   }
 }
 
 void KGlobalLedgerView::slotMatchTransactions()
 {
   Q_D(KGlobalLedgerView);
   // if the menu action is retrieved it can contain an '&' character for the accelerator causing the comparison to fail if not removed
   QString transactionActionText = pActions[Action::MatchTransaction]->text();
   transactionActionText.remove('&');
   if (transactionActionText == i18nc("Button text for match transaction", "Match"))
     d->transactionMatch();
   else
     d->transactionUnmatch();
 }
 
 void KGlobalLedgerView::slotCombineTransactions()
 {
   qDebug("slotTransactionCombine() not implemented yet");
 }
 
 void KGlobalLedgerView::slotToggleReconciliationFlag()
 {
   Q_D(KGlobalLedgerView);
   d->markTransaction(eMyMoney::Split::State::Unknown);
 }
 
 void KGlobalLedgerView::slotMarkCleared()
 {
   Q_D(KGlobalLedgerView);
   d->markTransaction(eMyMoney::Split::State::Cleared);
 }
 
 void KGlobalLedgerView::slotMarkReconciled()
 {
   Q_D(KGlobalLedgerView);
   d->markTransaction(eMyMoney::Split::State::Reconciled);
 }
 
 void KGlobalLedgerView::slotMarkNotReconciled()
 {
   Q_D(KGlobalLedgerView);
   d->markTransaction(eMyMoney::Split::State::NotReconciled);
 }
 
 void KGlobalLedgerView::slotSelectAllTransactions()
 {
   Q_D(KGlobalLedgerView);
   if(d->m_needLoad)
     d->init();
 
   d->m_register->clearSelection();
   KMyMoneyRegister::RegisterItem* p = d->m_register->firstItem();
   while (p) {
     KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
     if (t) {
       if (t->isVisible() && t->isSelectable() && !t->isScheduled() && !t->id().isEmpty()) {
         t->setSelected(true);
       }
     }
     p = p->nextItem();
   }
   // this is here only to re-paint the items without selecting anything because the data (including the selection) is not really held in the model right now
   d->m_register->selectAll();
 
   // inform everyone else about the selected items
   KMyMoneyRegister::SelectedTransactions list(d->m_register);
   updateLedgerActions(list);
   emit selectByVariant(QVariantList {QVariant::fromValue(list)}, eView::Intent::SelectRegisterTransactions);
 }
 
 void KGlobalLedgerView::slotCreateScheduledTransaction()
 {
    Q_D(KGlobalLedgerView);
   if (d->m_selectedTransactions.count() == 1) {
     // make sure to have the current selected split as first split in the schedule
     MyMoneyTransaction t = d->m_selectedTransactions[0].transaction();
     MyMoneySplit s = d->m_selectedTransactions[0].split();
     QString splitId = s.id();
     s.clearId();
     s.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
     s.setReconcileDate(QDate());
     t.removeSplits();
     t.addSplit(s);
     foreach (const auto split, d->m_selectedTransactions[0].transaction().splits()) {
       if (split.id() != splitId) {
         MyMoneySplit s0 = split;
         s0.clearId();
         s0.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
         s0.setReconcileDate(QDate());
         t.addSplit(s0);
       }
     }
     KEditScheduleDlg::newSchedule(t, eMyMoney::Schedule::Occurrence::Monthly);
   }
 }
 
 void KGlobalLedgerView::slotAssignNumber()
 {
   Q_D(KGlobalLedgerView);
   if (d->m_transactionEditor)
     d->m_transactionEditor->assignNextNumber();
 }
 
 void KGlobalLedgerView::slotStartReconciliation()
 {
   Q_D(KGlobalLedgerView);
 
   // we cannot reconcile standard accounts
   if (!MyMoneyFile::instance()->isStandardAccount(d->m_currentAccount.id()))
     emit selectByObject(d->m_currentAccount, eView::Intent::StartEnteringOverdueScheduledTransactions);
   // asynchronous call to KScheduledView::slotEnterOverdueSchedules is made here
   // after that all activity should be continued in KGlobalLedgerView::slotContinueReconciliation()
 }
 
 void KGlobalLedgerView::slotFinishReconciliation()
 {
   Q_D(KGlobalLedgerView);
   const auto file = MyMoneyFile::instance();
 
   if (!d->m_reconciliationAccount.id().isEmpty()) {
     // retrieve list of all transactions that are not reconciled or cleared
     QList<QPair<MyMoneyTransaction, MyMoneySplit> > transactionList;
     MyMoneyTransactionFilter filter(d->m_reconciliationAccount.id());
     filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
     filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
     filter.setDateFilter(QDate(), d->m_endingBalanceDlg->statementDate());
     filter.setConsiderCategory(false);
     filter.setReportAllSplits(true);
     file->transactionList(transactionList, filter);
 
     auto balance = MyMoneyFile::instance()->balance(d->m_reconciliationAccount.id(), d->m_endingBalanceDlg->statementDate());
     MyMoneyMoney actBalance, clearedBalance;
     actBalance = clearedBalance = balance;
 
     // walk the list of transactions to figure out the balance(s)
     for (auto it = transactionList.constBegin(); it != transactionList.constEnd(); ++it) {
       if ((*it).second.reconcileFlag() == eMyMoney::Split::State::NotReconciled) {
         clearedBalance -= (*it).second.shares();
       }
     }
 
     if (d->m_endingBalanceDlg->endingBalance() != clearedBalance) {
       auto message = i18n("You are about to finish the reconciliation of this account with a difference between your bank statement and the transactions marked as cleared.\n"
                              "Are you sure you want to finish the reconciliation?");
       if (KMessageBox::questionYesNo(this, message, i18n("Confirm end of reconciliation"), KStandardGuiItem::yes(), KStandardGuiItem::no()) == KMessageBox::No)
         return;
     }
 
     MyMoneyFileTransaction ft;
 
     // refresh object
     d->m_reconciliationAccount = file->account(d->m_reconciliationAccount.id());
 
     // Turn off reconciliation mode
 //    Models::instance()->accountsModel()->slotReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 //    slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 //    d->m_myMoneyView->finishReconciliation(d->m_reconciliationAccount);
 
     // only update the last statement balance here, if we haven't a newer one due
     // to download of online statements.
     if (d->m_reconciliationAccount.value("lastImportedTransactionDate").isEmpty()
         || QDate::fromString(d->m_reconciliationAccount.value("lastImportedTransactionDate"), Qt::ISODate) < d->m_endingBalanceDlg->statementDate()) {
       d->m_reconciliationAccount.setValue("lastStatementBalance", d->m_endingBalanceDlg->endingBalance().toString());
       // in case we override the last statement balance here, we have to make sure
       // that we don't show the online balance anymore, as it might be different
       d->m_reconciliationAccount.deletePair("lastImportedTransactionDate");
     }
     d->m_reconciliationAccount.setLastReconciliationDate(d->m_endingBalanceDlg->statementDate());
 
     // keep a record of this reconciliation
     d->m_reconciliationAccount.addReconciliation(d->m_endingBalanceDlg->statementDate(), d->m_endingBalanceDlg->endingBalance());
 
     d->m_reconciliationAccount.deletePair("lastReconciledBalance");
     d->m_reconciliationAccount.deletePair("statementBalance");
     d->m_reconciliationAccount.deletePair("statementDate");
 
     try {
       // update the account data
       file->modifyAccount(d->m_reconciliationAccount);
 
       /*
       // collect the list of cleared splits for this account
       filter.clear();
       filter.addAccount(d->m_reconciliationAccount.id());
       filter.addState(eMyMoney::TransactionFilter::Cleared);
       filter.setConsiderCategory(false);
       filter.setReportAllSplits(true);
       file->transactionList(transactionList, filter);
       */
 
       // walk the list of transactions/splits and mark the cleared ones as reconciled
 
       for (auto it = transactionList.begin(); it != transactionList.end(); ++it) {
         MyMoneySplit sp = (*it).second;
         // skip the ones that are not marked cleared
         if (sp.reconcileFlag() != eMyMoney::Split::State::Cleared)
           continue;
 
         // always retrieve a fresh copy of the transaction because we
         // might have changed it already with another split
         MyMoneyTransaction t = file->transaction((*it).first.id());
         sp.setReconcileFlag(eMyMoney::Split::State::Reconciled);
         sp.setReconcileDate(d->m_endingBalanceDlg->statementDate());
         t.modifySplit(sp);
 
         // update the engine ...
         file->modifyTransaction(t);
 
         // ... and the list
         (*it) = qMakePair(t, sp);
       }
       ft.commit();
 
       // reload account data from engine as the data might have changed in the meantime
       d->m_reconciliationAccount = file->account(d->m_reconciliationAccount.id());
 
       /**
         * This signal is emitted when an account has been successfully reconciled
         * and all transactions are updated in the engine. It can be used by plugins
         * to create reconciliation reports.
         *
         * @param account the account data
         * @param date the reconciliation date as provided through the dialog
         * @param startingBalance the starting balance as provided through the dialog
         * @param endingBalance the ending balance as provided through the dialog
         * @param transactionList reference to QList of QPair containing all
         *        transaction/split pairs processed by the reconciliation.
         */
       emit selectByVariant(QVariantList {
                              QVariant::fromValue(d->m_reconciliationAccount),
                              QVariant::fromValue(d->m_endingBalanceDlg->statementDate()),
                              QVariant::fromValue(d->m_endingBalanceDlg->previousBalance()),
                              QVariant::fromValue(d->m_endingBalanceDlg->endingBalance()),
                              QVariant::fromValue(transactionList)
                            }, eView::Intent::AccountReconciled);
 
     } catch (const MyMoneyException &) {
       qDebug("Unexpected exception when setting cleared to reconcile");
     }
     // Turn off reconciliation mode
     Models::instance()->accountsModel()->slotReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
     slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
   }
   // Turn off reconciliation mode
   d->m_reconciliationAccount = MyMoneyAccount();
   updateActions(d->m_currentAccount);
   updateLedgerActionsInternal();
   d->loadView();
 //  slotUpdateActions();
 }
 
 void KGlobalLedgerView::slotPostponeReconciliation()
 {
   Q_D(KGlobalLedgerView);
   MyMoneyFileTransaction ft;
   const auto file = MyMoneyFile::instance();
 
   if (!d->m_reconciliationAccount.id().isEmpty()) {
     // refresh object
     d->m_reconciliationAccount = file->account(d->m_reconciliationAccount.id());
 
     // Turn off reconciliation mode
 //    Models::instance()->accountsModel()->slotReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 //    slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 //    d->m_myMoneyView->finishReconciliation(d->m_reconciliationAccount);
 
     d->m_reconciliationAccount.setValue("lastReconciledBalance", d->m_endingBalanceDlg->previousBalance().toString());
     d->m_reconciliationAccount.setValue("statementBalance", d->m_endingBalanceDlg->endingBalance().toString());
     d->m_reconciliationAccount.setValue("statementDate", d->m_endingBalanceDlg->statementDate().toString(Qt::ISODate));
 
     try {
       file->modifyAccount(d->m_reconciliationAccount);
       ft.commit();
       d->m_reconciliationAccount = MyMoneyAccount();
       updateActions(d->m_currentAccount);
       updateLedgerActionsInternal();
 //      slotUpdateActions();
     } catch (const MyMoneyException &) {
       qDebug("Unexpected exception when setting last reconcile info into account");
       ft.rollback();
       d->m_reconciliationAccount = file->account(d->m_reconciliationAccount.id());
     }
     // Turn off reconciliation mode
     Models::instance()->accountsModel()->slotReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
     slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
     d->loadView();
   }
 }
 
 void KGlobalLedgerView::slotOpenAccount()
 {
   Q_D(KGlobalLedgerView);
   if (!MyMoneyFile::instance()->isStandardAccount(d->m_currentAccount.id()))
     slotLedgerSelected(d->m_currentAccount.id(), QString());
 }
 
 void KGlobalLedgerView::slotFindTransaction()
 {
   Q_D(KGlobalLedgerView);
   if (!d->m_searchDlg) {
     d->m_searchDlg = new KFindTransactionDlg(this);
     connect(d->m_searchDlg, &QObject::destroyed, this, &KGlobalLedgerView::slotCloseSearchDialog);
     connect(d->m_searchDlg, &KFindTransactionDlg::transactionSelected,
             this, &KGlobalLedgerView::slotLedgerSelected);
   }
   d->m_searchDlg->show();
   d->m_searchDlg->raise();
   d->m_searchDlg->activateWindow();
 }
 
 void KGlobalLedgerView::slotCloseSearchDialog()
 {
   Q_D(KGlobalLedgerView);
   if (d->m_searchDlg)
     d->m_searchDlg->deleteLater();
   d->m_searchDlg = nullptr;
 }
 
 void KGlobalLedgerView::slotStatusMsg(const QString& txt)
 {
   emit selectByVariant(QVariantList {QVariant(txt)}, eView::Intent::ReportProgressMessage);
 }
 
 void KGlobalLedgerView::slotStatusProgress(int cnt, int base)
 {
   emit selectByVariant(QVariantList {QVariant(cnt), QVariant(base)}, eView::Intent::ReportProgress);
 }
 
 void KGlobalLedgerView::slotTransactionsSelected(const KMyMoneyRegister::SelectedTransactions& list)
 {
   updateLedgerActions(list);
   emit selectByVariant(QVariantList {QVariant::fromValue(list)}, eView::Intent::SelectRegisterTransactions);
 }
diff --git a/kmymoney/views/kgloballedgerview_p.h b/kmymoney/views/kgloballedgerview_p.h
index eb492057d..fb2c4d404 100644
--- a/kmymoney/views/kgloballedgerview_p.h
+++ b/kmymoney/views/kgloballedgerview_p.h
@@ -1,1649 +1,1649 @@
 /***************************************************************************
                           kgloballedgerview_p.h  -  description
                              -------------------
     begin                : Wed Jul 26 2006
     copyright            : (C) 2006 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KGLOBALLEDGERVIEW_P_H
 #define KGLOBALLEDGERVIEW_P_H
 
 #include "kgloballedgerview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QList>
 #include <QLabel>
 #include <QEvent>
 #include <QVBoxLayout>
 #include <QHeaderView>
 #include <QToolTip>
 #include <QMenu>
 #include <QWidgetAction>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KToolBar>
 #include <KPassivePopup>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneyviewbase_p.h"
 #include "kendingbalancedlg.h"
 #include "kfindtransactiondlg.h"
 #include "kmymoneyaccountselector.h"
 #include "kmymoneyutils.h"
 #include "mymoneyexception.h"
 #include "mymoneymoney.h"
 #include "mymoneyaccount.h"
 #include "mymoneyfile.h"
 #include "kmymoneyaccountcombo.h"
 #include "kbalancewarning.h"
 #include "transactionmatcher.h"
 #include "tabbar.h"
 #include "register.h"
 #include "transactioneditor.h"
 #include "selectedtransactions.h"
 #include "kmymoneysettings.h"
 #include "registersearchline.h"
 #include "scheduledtransaction.h"
 #include "accountsmodel.h"
 #include "models.h"
 #include "mymoneyprice.h"
 #include "mymoneyschedule.h"
 #include "mymoneysecurity.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "mymoneysplit.h"
 #include "mymoneypayee.h"
 #include "mymoneytracer.h"
 #include "transaction.h"
 #include "transactionform.h"
 #include "fancydategroupmarkers.h"
 #include "widgetenums.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 #include "menuenums.h"
 
 #include <config-kmymoney.h>
 #ifdef KMM_DEBUG
 #include "mymoneyutils.h"
 #endif
 
 using namespace eMenu;
 using namespace eMyMoney;
 
 /**
   * helper class implementing an event filter to detect mouse button press
   * events on widgets outside a given set of widgets. This is used internally
   * to detect when to leave the edit mode.
   */
 class MousePressFilter : public QObject
 {
   Q_OBJECT
 public:
   explicit MousePressFilter(QWidget* parent = nullptr) :
     QObject(parent),
     m_lastMousePressEvent(0),
     m_filterActive(true)
   {
   }
 
   /**
     * Add widget @p w to the list of possible parent objects. See eventFilter() how
     * they will be used.
     */
   void addWidget(QWidget* w)
   {
     m_parents.append(w);
   }
 
 public Q_SLOTS:
   /**
     * This slot allows to activate/deactivate the filter. By default the
     * filter is active.
     *
     * @param state Allows to activate (@a true) or deactivate (@a false) the filter
     */
   void setFilterActive(bool state = true)
   {
     m_filterActive = state;
   }
 
   /**
     * This slot allows to activate/deactivate the filter. By default the
     * filter is active.
     *
     * @param state Allows to deactivate (@a true) or activate (@a false) the filter
     */
   void setFilterDeactive(bool state = false) {
     setFilterActive(!state);
   }
 
 protected:
   /**
     * This method checks if the widget @p child is a child of
     * the widget @p parent and returns either @a true or @a false.
     *
     * @param child pointer to child widget
     * @param parent pointer to parent widget
     * @retval true @p child points to widget which has @p parent as parent or grand-parent
     * @retval false @p child points to a widget which is not related to @p parent
     */
   bool isChildOf(QWidget* child, QWidget* parent)
   {
     // QDialogs cannot be detected directly, but it can be assumed,
     // that events on a widget that do not have a parent widget within
     // our application are dialogs.
     if (!child->parentWidget())
       return true;
 
     while (child) {
       // if we are a child of the given parent, we have a match
       if (child == parent)
         return true;
       // if we are at the application level, we don't have a match
       if (child->inherits("KMyMoneyApp"))
         return false;
       // If one of the ancestors is a KPassivePopup or a KDialog or a popup widget then
       // it's as if it is a child of our own because these widgets could
       // appear during transaction entry (message boxes, completer widgets)
       if (dynamic_cast<KPassivePopup*>(child) ||
           ((child->windowFlags() & Qt::Popup) && /*child != kmymoney*/
            !child->parentWidget())) // has no parent, then it must be top-level window
         return true;
       child = child->parentWidget();
     }
     return false;
   }
 
   /**
     * Reimplemented from base class. Sends out the mousePressedOnExternalWidget() signal
     * if object @p o points to an object which is not a child widget of any added previously
     * using the addWidget() method. The signal is sent out only once for each event @p e.
     *
     * @param o pointer to QObject
     * @param e pointer to QEvent
     * @return always returns @a false
     */
   bool eventFilter(QObject* o, QEvent* e) final override
   {
     if (m_filterActive) {
       if (e->type() == QEvent::MouseButtonPress && !m_lastMousePressEvent) {
         QWidget* w = qobject_cast<QWidget*>(o);
         if (!w) {
           return QObject::eventFilter(o, e);
         }
         QList<QWidget*>::const_iterator it_w;
         for (it_w = m_parents.constBegin(); it_w != m_parents.constEnd(); ++it_w) {
           if (isChildOf(w, (*it_w))) {
             m_lastMousePressEvent = e;
             break;
           }
         }
         if (it_w == m_parents.constEnd()) {
           m_lastMousePressEvent = e;
           bool rc = false;
           emit mousePressedOnExternalWidget(rc);
         }
       }
 
       if (e->type() != QEvent::MouseButtonPress) {
         m_lastMousePressEvent = 0;
       }
     }
     return false;
   }
 
 Q_SIGNALS:
   void mousePressedOnExternalWidget(bool&);
 
 private:
   QList<QWidget*>      m_parents;
   QEvent*              m_lastMousePressEvent;
   bool                 m_filterActive;
 };
 
 class KGlobalLedgerViewPrivate : public KMyMoneyViewBasePrivate
 {
   Q_DECLARE_PUBLIC(KGlobalLedgerView)
 
 public:
   explicit KGlobalLedgerViewPrivate(KGlobalLedgerView *qq) :
     q_ptr(qq),
     m_mousePressFilter(0),
     m_registerSearchLine(0),
     m_precision(2),
     m_recursion(false),
     m_showDetails(false),
     m_action(eWidgets::eRegister::Action::None),
     m_filterProxyModel(0),
     m_accountComboBox(0),
     m_balanceIsApproximated(false),
     m_toolbarFrame(nullptr),
     m_registerFrame(nullptr),
     m_buttonFrame(nullptr),
     m_formFrame(nullptr),
     m_summaryFrame(nullptr),
     m_register(nullptr),
     m_buttonbar(nullptr),
     m_leftSummaryLabel(nullptr),
     m_centerSummaryLabel(nullptr),
     m_rightSummaryLabel(nullptr),
     m_form(nullptr),
     m_needLoad(true),
     m_newAccountLoaded(true),
     m_inEditMode(false),
     m_transactionEditor(nullptr),
     m_balanceWarning(nullptr),
     m_moveToAccountSelector(nullptr),
     m_endingBalanceDlg(nullptr),
     m_searchDlg(nullptr)
   {
   }
 
   ~KGlobalLedgerViewPrivate()
   {
     delete m_moveToAccountSelector;
     delete m_endingBalanceDlg;
     delete m_searchDlg;
   }
 
   void init()
   {
     Q_Q(KGlobalLedgerView);
     m_needLoad = false;
     auto vbox = new QVBoxLayout(q);
     q->setLayout(vbox);
     vbox->setSpacing(6);
     vbox->setMargin(0);
 
     m_mousePressFilter = new MousePressFilter((QWidget*)q);
     m_action = eWidgets::eRegister::Action::None;
 
     // the proxy filter model
     m_filterProxyModel = new AccountNamesFilterProxyModel(q);
     m_filterProxyModel->addAccountGroup(QVector<eMyMoney::Account::Type> {eMyMoney::Account::Type::Asset, eMyMoney::Account::Type::Liability, eMyMoney::Account::Type::Equity});
     auto const model = Models::instance()->accountsModel();
     m_filterProxyModel->setSourceModel(model);
     m_filterProxyModel->setSourceColumns(model->getColumns());
     m_filterProxyModel->sort((int)eAccountsModel::Column::Account);
 
     // create the toolbar frame at the top of the view
     m_toolbarFrame = new QFrame();
     QHBoxLayout* toolbarLayout = new QHBoxLayout(m_toolbarFrame);
     toolbarLayout->setContentsMargins(0, 0, 0, 0);
     toolbarLayout->setSpacing(6);
 
     // the account selector widget
     m_accountComboBox = new KMyMoneyAccountCombo();
     m_accountComboBox->setModel(m_filterProxyModel);
     toolbarLayout->addWidget(m_accountComboBox);
 
     vbox->addWidget(m_toolbarFrame);
     toolbarLayout->setStretchFactor(m_accountComboBox, 60);
     // create the register frame
     m_registerFrame = new QFrame();
     QVBoxLayout* registerFrameLayout = new QVBoxLayout(m_registerFrame);
     registerFrameLayout->setContentsMargins(0, 0, 0, 0);
     registerFrameLayout->setSpacing(0);
     vbox->addWidget(m_registerFrame);
     vbox->setStretchFactor(m_registerFrame, 2);
     m_register = new KMyMoneyRegister::Register(m_registerFrame);
     m_register->setUsedWithEditor(true);
     registerFrameLayout->addWidget(m_register);
     m_register->installEventFilter(q);
     q->connect(m_register, &KMyMoneyRegister::Register::openContextMenu, q, &KGlobalLedgerView::slotTransactionsContextMenuRequested);
     q->connect(m_register, &KMyMoneyRegister::Register::transactionsSelected, q, &KGlobalLedgerView::slotUpdateSummaryLine);
     q->connect(m_register->horizontalHeader(), &QWidget::customContextMenuRequested, q, &KGlobalLedgerView::slotSortOptions);
     q->connect(m_register, &KMyMoneyRegister::Register::reconcileStateColumnClicked, q, &KGlobalLedgerView::slotToggleTransactionMark);
 
     // insert search line widget
 
     m_registerSearchLine = new KMyMoneyRegister::RegisterSearchLineWidget(m_register, m_toolbarFrame);
     toolbarLayout->addWidget(m_registerSearchLine);
     toolbarLayout->setStretchFactor(m_registerSearchLine, 100);
     // create the summary frame
     m_summaryFrame = new QFrame();
     QHBoxLayout* summaryFrameLayout = new QHBoxLayout(m_summaryFrame);
     summaryFrameLayout->setContentsMargins(0, 0, 0, 0);
     summaryFrameLayout->setSpacing(0);
     m_leftSummaryLabel = new QLabel(m_summaryFrame);
     m_centerSummaryLabel = new QLabel(m_summaryFrame);
     m_rightSummaryLabel = new QLabel(m_summaryFrame);
     summaryFrameLayout->addWidget(m_leftSummaryLabel);
     QSpacerItem* spacer = new QSpacerItem(20, 1, QSizePolicy::Expanding, QSizePolicy::Minimum);
     summaryFrameLayout->addItem(spacer);
     summaryFrameLayout->addWidget(m_centerSummaryLabel);
     spacer = new QSpacerItem(20, 1, QSizePolicy::Expanding, QSizePolicy::Minimum);
     summaryFrameLayout->addItem(spacer);
     summaryFrameLayout->addWidget(m_rightSummaryLabel);
     vbox->addWidget(m_summaryFrame);
 
     // create the button frame
     m_buttonFrame = new QFrame(q);
     QVBoxLayout* buttonLayout = new QVBoxLayout(m_buttonFrame);
     buttonLayout->setContentsMargins(0, 0, 0, 0);
     buttonLayout->setSpacing(0);
     vbox->addWidget(m_buttonFrame);
     m_buttonbar = new KToolBar(m_buttonFrame, 0, true);
     m_buttonbar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     buttonLayout->addWidget(m_buttonbar);
 
     m_buttonbar->addAction(pActions[eMenu::Action::NewTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::DeleteTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::EditTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::EnterTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::CancelTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::AcceptTransaction]);
     m_buttonbar->addAction(pActions[eMenu::Action::MatchTransaction]);
 
     // create the transaction form frame
     m_formFrame = new QFrame(q);
     QVBoxLayout* frameLayout = new QVBoxLayout(m_formFrame);
     frameLayout->setContentsMargins(5, 5, 5, 5);
     frameLayout->setSpacing(0);
     m_form = new KMyMoneyTransactionForm::TransactionForm(m_formFrame);
     frameLayout->addWidget(m_form->getTabBar(m_formFrame));
     frameLayout->addWidget(m_form);
     m_formFrame->setFrameShape(QFrame::Panel);
     m_formFrame->setFrameShadow(QFrame::Raised);
     vbox->addWidget(m_formFrame);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KGlobalLedgerView::refresh);
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KGlobalLedgerView::slotUpdateMoveToAccountMenu);
     q->connect(m_register, static_cast<void (KMyMoneyRegister::Register::*)(KMyMoneyRegister::Transaction *)>(&KMyMoneyRegister::Register::focusChanged), m_form, &KMyMoneyTransactionForm::TransactionForm::slotSetTransaction);
     q->connect(m_register, static_cast<void (KMyMoneyRegister::Register::*)()>(&KMyMoneyRegister::Register::focusChanged), q, &KGlobalLedgerView::updateLedgerActionsInternal);
 //    q->connect(m_accountComboBox, &KMyMoneyAccountCombo::accountSelected, q, &KGlobalLedgerView::slotAccountSelected);
     q->connect(m_accountComboBox, &KMyMoneyAccountCombo::accountSelected, q, static_cast<void (KGlobalLedgerView::*)(const QString&)>(&KGlobalLedgerView::slotSelectAccount));
     q->connect(m_accountComboBox, &KMyMoneyAccountCombo::accountSelected, q, &KGlobalLedgerView::slotUpdateMoveToAccountMenu);
     q->connect(m_register, &KMyMoneyRegister::Register::transactionsSelected, q, &KGlobalLedgerView::slotTransactionsSelected);
     q->connect(m_register, &KMyMoneyRegister::Register::transactionsSelected, q, &KGlobalLedgerView::slotUpdateMoveToAccountMenu);
     q->connect(m_register, &KMyMoneyRegister::Register::editTransaction, q, &KGlobalLedgerView::slotEditTransaction);
     q->connect(m_register, &KMyMoneyRegister::Register::emptyItemSelected, q, &KGlobalLedgerView::slotNewTransaction);
     q->connect(m_register, &KMyMoneyRegister::Register::aboutToSelectItem, q, &KGlobalLedgerView::slotAboutToSelectItem);
     q->connect(m_mousePressFilter, &MousePressFilter::mousePressedOnExternalWidget, q, &KGlobalLedgerView::slotCancelOrEnterTransactions);
 
     q->connect(m_form, &KMyMoneyTransactionForm::TransactionForm::newTransaction, q, static_cast<void (KGlobalLedgerView::*)(eWidgets::eRegister::Action)>(&KGlobalLedgerView::slotNewTransactionForm));
 
     // setup mouse press filter
     m_mousePressFilter->addWidget(m_formFrame);
     m_mousePressFilter->addWidget(m_buttonFrame);
     m_mousePressFilter->addWidget(m_summaryFrame);
     m_mousePressFilter->addWidget(m_registerFrame);
 
     m_tooltipPosn = QPoint();
   }
 
   /**
     * This method reloads the account selection combo box of the
     * view with all asset and liability accounts from the engine.
     * If the account id of the current account held in @p m_accountId is
     * empty or if the referenced account does not exist in the engine,
     * the first account found in the list will be made the current account.
     */
   void loadAccounts()
   {
     const auto file = MyMoneyFile::instance();
 
     // check if the current account still exists and make it the
     // current account
     if (!m_lastSelectedAccountID.isEmpty()) {
       try {
         m_currentAccount = file->account(m_lastSelectedAccountID);
       } catch (const MyMoneyException &) {
         m_lastSelectedAccountID.clear();
         m_currentAccount = MyMoneyAccount();
         return;
       }
     }
 
     // TODO: check why the invalidate is needed here
     m_filterProxyModel->invalidate();
     m_filterProxyModel->sort((int)eAccountsModel::Column::Account);
     m_filterProxyModel->setHideClosedAccounts(KMyMoneySettings::hideClosedAccounts() && !KMyMoneySettings::showAllAccounts());
     m_filterProxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
     m_accountComboBox->expandAll();
 
     if (m_currentAccount.id().isEmpty()) {
       // find the first favorite account
       QModelIndexList list = m_filterProxyModel->match(m_filterProxyModel->index(0, 0),
                              (int)eAccountsModel::Role::Favorite,
                              QVariant(true),
                              1,
                              Qt::MatchFlags(Qt::MatchExactly | Qt::MatchCaseSensitive | Qt::MatchRecursive));
       if (list.count() > 0) {
         QVariant accountId = list.front().data((int)eAccountsModel::Role::ID);
         if (accountId.isValid()) {
           m_currentAccount = file->account(accountId.toString());
         }
       }
 
       if (m_currentAccount.id().isEmpty()) {
         // there are no favorite accounts find any account
         list = m_filterProxyModel->match(m_filterProxyModel->index(0, 0),
                                Qt::DisplayRole,
                                QVariant(QString("*")),
                                -1,
                                Qt::MatchFlags(Qt::MatchWildcard | Qt::MatchRecursive));
         for (QModelIndexList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it) {
           if (!it->parent().isValid())
             continue; // skip the top level accounts
           QVariant accountId = (*it).data((int)eAccountsModel::Role::ID);
           if (accountId.isValid()) {
             MyMoneyAccount a = file->account(accountId.toString());
             if (!a.isInvest() && !a.isClosed()) {
               m_currentAccount = a;
               break;
             }
           }
         }
       }
     }
 
     if (!m_currentAccount.id().isEmpty()) {
       m_accountComboBox->setSelected(m_currentAccount.id());
       try {
         m_precision = MyMoneyMoney::denomToPrec(m_currentAccount.fraction());
       } catch (const MyMoneyException &) {
         qDebug("Security %s for account %s not found", qPrintable(m_currentAccount.currencyId()), qPrintable(m_currentAccount.name()));
         m_precision = 2;
       }
     }
   }
 
   /**
     * This method clears the register, form, transaction list. See @sa m_register,
     * @sa m_transactionList
     */
   void clear()
   {
     // clear current register contents
     m_register->clear();
 
     // setup header font
     QFont font = KMyMoneySettings::listHeaderFontEx();
     QFontMetrics fm(font);
     int height = fm.lineSpacing() + 6;
     m_register->horizontalHeader()->setMinimumHeight(height);
     m_register->horizontalHeader()->setMaximumHeight(height);
     m_register->horizontalHeader()->setFont(font);
 
     // setup cell font
     font = KMyMoneySettings::listCellFontEx();
     m_register->setFont(font);
 
     // clear the form
     m_form->clear();
 
     // the selected transactions list
     m_transactionList.clear();
 
     // and the selected account in the combo box
     m_accountComboBox->setSelected(QString());
 
     // fraction defaults to two digits
     m_precision = 2;
   }
 
   void loadView()
   {
     MYMONEYTRACER(tracer);
     Q_Q(KGlobalLedgerView);
 
     // setup form visibility
     m_formFrame->setVisible(KMyMoneySettings::transactionForm());
 
     // no account selected
 //    emit q->objectSelected(MyMoneyAccount());
     // no transaction selected
     KMyMoneyRegister::SelectedTransactions list;
     emit q->selectByVariant(QVariantList {QVariant::fromValue(list)}, eView::Intent::SelectRegisterTransactions);
 
     QMap<QString, bool> isSelected;
     QString focusItemId;
     QString backUpFocusItemId;  // in case the focus item is removed
     QString anchorItemId;
     QString backUpAnchorItemId; // in case the anchor item is removed
 
     if (!m_newAccountLoaded) {
       // remember the current selected transactions
       KMyMoneyRegister::RegisterItem* item = m_register->firstItem();
       for (; item; item = item->nextItem()) {
         if (item->isSelected()) {
           isSelected[item->id()] = true;
         }
       }
       // remember the item that has the focus
       storeId(m_register->focusItem(), focusItemId, backUpFocusItemId);
       // and the one that has the selection anchor
       storeId(m_register->anchorItem(), anchorItemId, backUpAnchorItemId);
     } else {
       m_registerSearchLine->searchLine()->clear();
     }
 
     // clear the current contents ...
     clear();
 
     // ... load the combobox widget and select current account ...
     loadAccounts();
 
     // ... setup the register columns ...
     m_register->setupRegister(m_currentAccount);
 
     // ... setup the form ...
     m_form->setupForm(m_currentAccount);
 
     if (m_currentAccount.id().isEmpty()) {
       // if we don't have an account we bail out
       q->setEnabled(false);
       return;
     }
     q->setEnabled(true);
 
     m_register->setUpdatesEnabled(false);
 
     // ... and recreate it
     KMyMoneyRegister::RegisterItem* focusItem = 0;
     KMyMoneyRegister::RegisterItem* anchorItem = 0;
     QMap<QString, MyMoneyMoney> actBalance, clearedBalance, futureBalance;
     QMap<QString, MyMoneyMoney>::iterator it_b;
     try {
       // setup the filter to select the transactions we want to display
       // and update the sort order
       QString sortOrder;
       QString key;
       QDate reconciliationDate = m_reconciliationDate;
 
       MyMoneyTransactionFilter filter(m_currentAccount.id());
       // if it's an investment account, we also take care of
       // the sub-accounts (stock accounts)
       if (m_currentAccount.accountType() == eMyMoney::Account::Type::Investment)
         filter.addAccount(m_currentAccount.accountList());
 
       if (isReconciliationAccount()) {
         key = "kmm-sort-reconcile";
         sortOrder = KMyMoneySettings::sortReconcileView();
         filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
         filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
       } else {
         filter.setDateFilter(KMyMoneySettings::startDate().date(), QDate());
         key = "kmm-sort-std";
         sortOrder = KMyMoneySettings::sortNormalView();
         if (KMyMoneySettings::hideReconciledTransactions()
             && !m_currentAccount.isIncomeExpense()) {
           filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
           filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
         }
       }
       filter.setReportAllSplits(true);
 
       // check if we have an account override of the sort order
       if (!m_currentAccount.value(key).isEmpty())
         sortOrder = m_currentAccount.value(key);
 
       // setup sort order
       m_register->setSortOrder(sortOrder);
 
       // retrieve the list from the engine
       MyMoneyFile::instance()->transactionList(m_transactionList, filter);
 
       emit q->slotStatusProgress(0, m_transactionList.count());
 
       // create the elements for the register
       QList<QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
       QMap<QString, int>uniqueMap;
       int i = 0;
       for (it = m_transactionList.constBegin(); it != m_transactionList.constEnd(); ++it) {
         uniqueMap[(*it).first.id()]++;
         KMyMoneyRegister::Transaction* t = KMyMoneyRegister::Register::transactionFactory(m_register, (*it).first, (*it).second, uniqueMap[(*it).first.id()]);
         actBalance[t->split().accountId()] = MyMoneyMoney();
         emit q->slotStatusProgress(++i, 0);
         // if we're in reconciliation and the state is cleared, we
         // force the item to show in dimmed intensity to get a visual focus
         // on those items, that we need to work on
         if (isReconciliationAccount() && (*it).second.reconcileFlag() == eMyMoney::Split::State::Cleared) {
           t->setReducedIntensity(true);
         }
       }
 
       // create dummy entries for the scheduled transactions if sorted by postdate
       int period = KMyMoneySettings::schedulePreview();
       if (m_register->primarySortKey() == eWidgets::SortField::PostDate) {
         // show scheduled transactions which have a scheduled postdate
         // within the next 'period' days. In reconciliation mode, the
         // period starts on the statement date.
         QDate endDate = QDate::currentDate().addDays(period);
         if (isReconciliationAccount())
           endDate = reconciliationDate.addDays(period);
         QList<MyMoneySchedule> scheduleList = MyMoneyFile::instance()->scheduleList(m_currentAccount.id());
         while (!scheduleList.isEmpty()) {
           MyMoneySchedule& s = scheduleList.first();
           for (;;) {
             if (s.isFinished() || s.adjustedNextDueDate() > endDate) {
               break;
             }
 
             MyMoneyTransaction t(s.id(), KMyMoneyUtils::scheduledTransaction(s));
             // if the transaction is scheduled and overdue, it can't
             // certainly be posted in the past. So we take today's date
             // as the alternative
             if (s.isOverdue()) {
               t.setPostDate(s.adjustedDate(QDate::currentDate(), s.weekendOption()));
             } else {
               t.setPostDate(s.adjustedNextDueDate());
             }
             foreach (const auto split, t.splits()) {
               if (split.accountId() == m_currentAccount.id()) {
                 new KMyMoneyRegister::StdTransactionScheduled(m_register, t, split, uniqueMap[t.id()]);
               }
             }
             // keep track of this payment locally (not in the engine)
             if (s.isOverdue()) {
               s.setLastPayment(QDate::currentDate());
             } else {
               s.setLastPayment(s.nextDueDate());
             }
 
             // if this is a one time schedule, we can bail out here as we're done
             if (s.occurrence() == eMyMoney::Schedule::Occurrence::Once)
               break;
 
             // for all others, we check if the next payment date is still 'in range'
             QDate nextDueDate = s.nextPayment(s.nextDueDate());
             if (nextDueDate.isValid()) {
               s.setNextDueDate(nextDueDate);
             } else {
               break;
             }
           }
           scheduleList.pop_front();
         }
       }
 
       // add the group markers
       m_register->addGroupMarkers();
 
       // sort the transactions according to the sort setting
       m_register->sortItems();
 
       // remove trailing and adjacent markers
       m_register->removeUnwantedGroupMarkers();
 
       // add special markers for reconciliation now so that they do not get
       // removed by m_register->removeUnwantedGroupMarkers(). Needs resorting
       // of items but that's ok.
 
       KMyMoneyRegister::StatementGroupMarker* statement = 0;
       KMyMoneyRegister::StatementGroupMarker* dStatement = 0;
       KMyMoneyRegister::StatementGroupMarker* pStatement = 0;
 
       if (isReconciliationAccount()) {
         switch (m_register->primarySortKey()) {
           case eWidgets::SortField::PostDate:
             statement = new KMyMoneyRegister::StatementGroupMarker(m_register, eWidgets::eRegister::CashFlowDirection::Deposit, reconciliationDate, i18n("Statement Details"));
             m_register->sortItems();
             break;
           case eWidgets::SortField::Type:
             dStatement = new KMyMoneyRegister::StatementGroupMarker(m_register, eWidgets::eRegister::CashFlowDirection::Deposit, reconciliationDate, i18n("Statement Deposit Details"));
             pStatement = new KMyMoneyRegister::StatementGroupMarker(m_register, eWidgets::eRegister::CashFlowDirection::Payment, reconciliationDate, i18n("Statement Payment Details"));
             m_register->sortItems();
             break;
           default:
             break;
         }
       }
 
       // we need at least the balance for the account we currently show
       actBalance[m_currentAccount.id()] = MyMoneyMoney();
 
       if (m_currentAccount.accountType() == eMyMoney::Account::Type::Investment)
         foreach (const auto accountID, m_currentAccount.accountList())
           actBalance[accountID] = MyMoneyMoney();
 
       // determine balances (actual, cleared). We do this by getting the actual
       // balance of all entered transactions from the engine and walk the list
       // of transactions backward. Also re-select a transaction if it was
       // selected before and setup the focus item.
 
       MyMoneyMoney factor(1, 1);
       if (m_currentAccount.accountGroup() == eMyMoney::Account::Type::Liability
           || m_currentAccount.accountGroup() == eMyMoney::Account::Type::Equity)
         factor = -factor;
 
       QMap<QString, int> deposits;
       QMap<QString, int> payments;
       QMap<QString, MyMoneyMoney> depositAmount;
       QMap<QString, MyMoneyMoney> paymentAmount;
       for (it_b = actBalance.begin(); it_b != actBalance.end(); ++it_b) {
         MyMoneyMoney balance = MyMoneyFile::instance()->balance(it_b.key());
         balance = balance * factor;
         clearedBalance[it_b.key()] =
           futureBalance[it_b.key()] =
             (*it_b) = balance;
         deposits[it_b.key()] = payments[it_b.key()] = 0;
         depositAmount[it_b.key()] = MyMoneyMoney();
         paymentAmount[it_b.key()] = MyMoneyMoney();
       }
 
       tracer.printf("total balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(actBalance[m_currentAccount.id()].formatMoney("", 2)));
       tracer.printf("future balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(futureBalance[m_currentAccount.id()].formatMoney("", 2)));
       tracer.printf("cleared balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(clearedBalance[m_currentAccount.id()].formatMoney("", 2)));
 
       KMyMoneyRegister::RegisterItem* p = m_register->lastItem();
       focusItem = 0;
 
       // take care of possibly trailing scheduled transactions (bump up the future balance)
       while (p) {
         if (p->isSelectable()) {
           KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
           if (t && t->isScheduled()) {
             MyMoneyMoney balance = futureBalance[t->split().accountId()];
             const MyMoneySplit& split = t->split();
             // if this split is a stock split, we can't just add the amount of shares
             if (t->transaction().isStockSplit()) {
               balance = balance * split.shares();
             } else {
               balance += split.shares() * factor;
             }
             futureBalance[split.accountId()] = balance;
           } else if (t && !focusItem)
             focusItem = p;
         }
         p = p->prevItem();
       }
 
       p = m_register->lastItem();
       while (p) {
         KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
         if (t) {
           if (isSelected.contains(t->id()))
             t->setSelected(true);
 
           matchItemById(&focusItem, t, focusItemId, backUpFocusItemId);
           matchItemById(&anchorItem, t, anchorItemId, backUpAnchorItemId);
 
           const MyMoneySplit& split = t->split();
           MyMoneyMoney balance = futureBalance[split.accountId()];
           t->setBalance(balance);
 
           // if this split is a stock split, we can't just add the amount of shares
           if (t->transaction().isStockSplit()) {
             balance /= split.shares();
           } else {
             balance -= split.shares() * factor;
           }
 
           if (!t->isScheduled()) {
             if (isReconciliationAccount() && t->transaction().postDate() <= reconciliationDate && split.reconcileFlag() == eMyMoney::Split::State::Cleared) {
               if (split.shares().isNegative()) {
                 payments[split.accountId()]++;
                 paymentAmount[split.accountId()] += split.shares();
               } else {
                 deposits[split.accountId()]++;
                 depositAmount[split.accountId()] += split.shares();
               }
             }
 
             if (t->transaction().postDate() > QDate::currentDate()) {
               tracer.printf("Reducing actual balance by %s because %s/%s(%s) is in the future", qPrintable((split.shares() * factor).formatMoney("", 2)), qPrintable(t->transaction().id()), qPrintable(split.id()), qPrintable(t->transaction().postDate().toString(Qt::ISODate)));
               actBalance[split.accountId()] -= split.shares() * factor;
             }
           }
           futureBalance[split.accountId()] = balance;
         }
         p = p->prevItem();
       }
 
       clearedBalance[m_currentAccount.id()] = MyMoneyFile::instance()->clearedBalance(m_currentAccount.id(), reconciliationDate);
 
       tracer.printf("total balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(actBalance[m_currentAccount.id()].formatMoney("", 2)));
       tracer.printf("future balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(futureBalance[m_currentAccount.id()].formatMoney("", 2)));
       tracer.printf("cleared balance of %s = %s", qPrintable(m_currentAccount.name()), qPrintable(clearedBalance[m_currentAccount.id()].formatMoney("", 2)));
 
       // update statement information
       if (statement) {
         const QString aboutDeposits = i18np("%1 deposit (%2)", "%1 deposits (%2)",
                                             deposits[m_currentAccount.id()], depositAmount[m_currentAccount.id()].abs().formatMoney(m_currentAccount.fraction()));
         const QString aboutPayments = i18np("%1 payment (%2)", "%1 payments (%2)",
                                             payments[m_currentAccount.id()], paymentAmount[m_currentAccount.id()].abs().formatMoney(m_currentAccount.fraction()));
 
         statement->setText(i18nc("%1 is a string, e.g. 7 deposits; %2 is a string, e.g. 4 payments", "%1, %2", aboutDeposits, aboutPayments));
       }
       if (pStatement) {
         pStatement->setText(i18np("%1 payment (%2)", "%1 payments (%2)", payments[m_currentAccount.id()]
                                   , paymentAmount[m_currentAccount.id()].abs().formatMoney(m_currentAccount.fraction())));
       }
       if (dStatement) {
         dStatement->setText(i18np("%1 deposit (%2)", "%1 deposits (%2)", deposits[m_currentAccount.id()]
                                   , depositAmount[m_currentAccount.id()].abs().formatMoney(m_currentAccount.fraction())));
       }
 
       // add a last empty entry for new transactions
       // leave some information about the current account
       MyMoneySplit split;
       split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
       // make sure to use the value specified in the option during reconciliation
       if (isReconciliationAccount())
         split.setReconcileFlag(static_cast<eMyMoney::Split::State>(KMyMoneySettings::defaultReconciliationState()));
       KMyMoneyRegister::Register::transactionFactory(m_register, MyMoneyTransaction(), split, 0);
 
       m_register->updateRegister(true);
 
       if (focusItem) {
         // in case we have some selected items we just set the focus item
         // in other cases, we make the focusitem also the selected item
         if (anchorItem && (anchorItem != focusItem)) {
           m_register->setFocusItem(focusItem);
           m_register->setAnchorItem(anchorItem);
         } else
           m_register->selectItem(focusItem, true);
       } else {
         // just use the empty line at the end if nothing else exists in the ledger
         p = m_register->lastItem();
         m_register->setFocusItem(p);
         m_register->selectItem(p);
         focusItem = p;
       }
 
       updateSummaryLine(actBalance, clearedBalance);
       emit q->slotStatusProgress(-1, -1);
 
     } catch (const MyMoneyException &) {
       m_currentAccount = MyMoneyAccount();
       clear();
     }
 
     m_showDetails = KMyMoneySettings::showRegisterDetailed();
 
     // and tell everyone what's selected
     emit q->selectByObject(m_currentAccount, eView::Intent::None);
     KMyMoneyRegister::SelectedTransactions actualSelection(m_register);
     emit q->selectByVariant(QVariantList {QVariant::fromValue(actualSelection)}, eView::Intent::SelectRegisterTransactions);
   }
 
   void selectTransaction(const QString& id)
   {
     if (!id.isEmpty()) {
       KMyMoneyRegister::RegisterItem* p = m_register->lastItem();
       while (p) {
         KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
         if (t) {
           if (t->transaction().id() == id) {
             m_register->selectItem(t);
             m_register->ensureItemVisible(t);
             break;
           }
         }
         p = p->prevItem();
       }
     }
   }
 
   /**
    * @brief selects transactions for processing with slots
    * @param list of transactions
    * @return false if only schedule is to be selected
    */
   bool selectTransactions(const KMyMoneyRegister::SelectedTransactions& list)
   {
     Q_Q(KGlobalLedgerView);
     // list can either contain a list of transactions or a single selected scheduled transaction
     // in the latter case, the transaction id is actually the one of the schedule. In order
     // to differentiate between the two, we just ask for the schedule. If we don't find one - because
     // we passed the id of a real transaction - then we know that fact.  We use the schedule here,
     // because the list of schedules is kept in a cache by MyMoneyFile. This way, we save some trips
     // to the backend which we would have to do if we check for the transaction.
     m_selectedTransactions.clear();
     auto sch = MyMoneySchedule();
     auto ret = true;
 
     m_accountGoto.clear();
     m_payeeGoto.clear();
     if (!list.isEmpty() && !list.first().isScheduled()) {
         m_selectedTransactions = list;
         if (list.count() == 1) {
             const MyMoneySplit& sp = m_selectedTransactions[0].split();
             if (!sp.payeeId().isEmpty()) {
                 try {
                   auto payee = MyMoneyFile::instance()->payee(sp.payeeId());
                   if (!payee.name().isEmpty()) {
                       m_payeeGoto = payee.id();
                       auto name = payee.name();
                       name.replace(QRegExp("&(?!&)"), "&&");
                       pActions[Action::GoToPayee]->setText(i18n("Go to '%1'", name));
                     }
                 } catch (const MyMoneyException &) {
                 }
               }
             try {
               const auto& t = m_selectedTransactions[0].transaction();
               // search the first non-income/non-expense accunt and use it for the 'goto account'
               const auto& selectedTransactionSplit = m_selectedTransactions[0].split();
               foreach (const auto split, t.splits()) {
                   if (split.id() != selectedTransactionSplit.id()) {
                       auto acc = MyMoneyFile::instance()->account(split.accountId());
                       if (!acc.isIncomeExpense()) {
                           // for stock accounts we show the portfolio account
                           if (acc.isInvest()) {
                               acc = MyMoneyFile::instance()->account(acc.parentAccountId());
                             }
                           m_accountGoto = acc.id();
                           auto name = acc.name();
                           name.replace(QRegExp("&(?!&)"), "&&");
                           pActions[Action::GoToAccount]->setText(i18n("Go to '%1'", name));
                           break;
                         }
                     }
                 }
             } catch (const MyMoneyException &) {
             }
           }
       } else if (!list.isEmpty()) {
         sch = MyMoneyFile::instance()->schedule(list.first().scheduleId());
         m_selectedTransactions.append(list.first());
         ret = false;
       }
 
     emit q->selectByObject(sch, eView::Intent::None);
 
     // make sure, we show some neutral menu entry if we don't have an object
     if (m_payeeGoto.isEmpty())
       pActions[Action::GoToPayee]->setText(i18n("Go to payee"));
     if (m_accountGoto.isEmpty())
       pActions[Action::GoToAccount]->setText(i18n("Go to account"));
     return ret;
   }
 
   /**
     * Returns @a true if setReconciliationAccount() has been called for
     * the current loaded account.
     *
     * @retval true current account is in reconciliation mode
     * @retval false current account is not in reconciliation mode
     */
   bool isReconciliationAccount() const
   {
     return m_currentAccount.id() == m_reconciliationAccount.id();
   }
 
   /**
     * Updates the values on the summary line beneath the register with
     * the given values. The contents shown differs between reconciliation
     * mode and normal mode.
     *
     * @param actBalance map of account indexed values to be used as actual balance
     * @param clearedBalance map of account indexed values to be used as cleared balance
     */
   void updateSummaryLine(const QMap<QString, MyMoneyMoney>& actBalance, const QMap<QString, MyMoneyMoney>& clearedBalance)
   {
     Q_Q(KGlobalLedgerView);
     const auto file = MyMoneyFile::instance();
     m_leftSummaryLabel->show();
     m_centerSummaryLabel->show();
     m_rightSummaryLabel->show();
 
     if (isReconciliationAccount()) {
       if (m_currentAccount.accountType() != eMyMoney::Account::Type::Investment) {
         m_leftSummaryLabel->setText(i18n("Statement: %1", m_endingBalance.formatMoney("", m_precision)));
         m_centerSummaryLabel->setText(i18nc("Cleared balance", "Cleared: %1", clearedBalance[m_currentAccount.id()].formatMoney("", m_precision)));
         m_totalBalance = clearedBalance[m_currentAccount.id()] - m_endingBalance;
       }
     } else {
       // update summary line in normal mode
       QDate reconcileDate = m_currentAccount.lastReconciliationDate();
 
       if (reconcileDate.isValid()) {
         m_leftSummaryLabel->setText(i18n("Last reconciled: %1", QLocale().toString(reconcileDate, QLocale::ShortFormat)));
       } else {
         m_leftSummaryLabel->setText(i18n("Never reconciled"));
       }
 
       QPalette palette = m_rightSummaryLabel->palette();
       palette.setColor(m_rightSummaryLabel->foregroundRole(), m_leftSummaryLabel->palette().color(q->foregroundRole()));
       if (m_currentAccount.accountType() != eMyMoney::Account::Type::Investment) {
         m_centerSummaryLabel->setText(i18nc("Cleared balance", "Cleared: %1", clearedBalance[m_currentAccount.id()].formatMoney("", m_precision)));
         m_totalBalance = actBalance[m_currentAccount.id()];
       } else {
         m_centerSummaryLabel->hide();
         MyMoneyMoney balance;
         MyMoneySecurity base = file->baseCurrency();
         QMap<QString, MyMoneyMoney>::const_iterator it_b;
         // reset the approximated flag
         m_balanceIsApproximated = false;
         for (it_b = actBalance.begin(); it_b != actBalance.end(); ++it_b) {
           MyMoneyAccount stock = file->account(it_b.key());
           QString currencyId = stock.currencyId();
           MyMoneySecurity sec = file->security(currencyId);
           MyMoneyMoney rate(1, 1);
 
           if (stock.isInvest()) {
             currencyId = sec.tradingCurrency();
             const MyMoneyPrice &priceInfo = file->price(sec.id(), currencyId);
             m_balanceIsApproximated |= !priceInfo.isValid();
             rate = priceInfo.rate(sec.tradingCurrency());
           }
 
           if (currencyId != base.id()) {
             const MyMoneyPrice &priceInfo = file->price(sec.tradingCurrency(), base.id());
             m_balanceIsApproximated |= !priceInfo.isValid();
             rate = (rate * priceInfo.rate(base.id())).convertPrecision(sec.pricePrecision());
           }
           balance += ((*it_b) * rate).convert(base.smallestAccountFraction());
         }
         m_totalBalance = balance;
       }
       m_rightSummaryLabel->setPalette(palette);
     }
     // determine the number of selected transactions
     KMyMoneyRegister::SelectedTransactions selection;
     m_register->selectedTransactions(selection);
     q->slotUpdateSummaryLine(selection);
   }
 
   /**
     * setup the default action according to the current account type
     */
   void setupDefaultAction()
   {
     switch (m_currentAccount.accountType()) {
       case eMyMoney::Account::Type::Asset:
       case eMyMoney::Account::Type::AssetLoan:
       case eMyMoney::Account::Type::Savings:
         m_action = eWidgets::eRegister::Action::Deposit;
         break;
       default:
         m_action = eWidgets::eRegister::Action::Withdrawal;
         break;
     }
   }
 
   // used to store the id of an item and the id of an immeadiate unselected sibling
   void storeId(KMyMoneyRegister::RegisterItem *item, QString &id, QString &backupId) {
     if (item) {
       // the id of the item
       id = item->id();
       // the id of the item's previous/next unselected item
       for (KMyMoneyRegister::RegisterItem *it = item->prevItem(); it != 0 && backupId.isEmpty(); it = it->prevItem()) {
         if (!it->isSelected()) {
           backupId = it->id();
         }
       }
       // if we didn't found previous unselected items search trough the next items
       for (KMyMoneyRegister::RegisterItem *it = item->nextItem(); it != 0 && backupId.isEmpty(); it = it->nextItem()) {
         if (!it->isSelected()) {
           backupId = it->id();
         }
       }
     }
   }
 
   // use to match an item by it's id or a backup id which has a lower precedence
   void matchItemById(KMyMoneyRegister::RegisterItem **item, KMyMoneyRegister::Transaction* t, QString &id, QString &backupId) {
     if (!backupId.isEmpty() && t->id() == backupId)
       *item = t;
     if (!id.isEmpty() && t->id() == id) {
       // we found the real thing there's no need for the backup anymore
       backupId.clear();
       *item = t;
     }
   }
 
   bool canProcessTransactions(const KMyMoneyRegister::SelectedTransactions& list, QString& tooltip) const
   {
     MyMoneyAccount acc;
     QString closedAccount;
     if (m_register->focusItem() == 0)
       return false;
 
 //    bool rc = true;
     if (list.warnLevel() == 3) {  //Closed account somewhere
       auto it_t = list.first();
 //      for (auto it_t = list.cbegin(); rc && it_t != list.cend(); ++it_t) {
         auto splitList = it_t.transaction().splits();
         auto id = splitList.first().accountId();
         acc = MyMoneyFile::instance()->account(id);
         if (!acc.isClosed()) {  //wrong split, try other
           id = splitList.last().accountId();
           acc = MyMoneyFile::instance()->account(id);
         }
         closedAccount = acc.name();
 //        break;
 //      }
       tooltip = i18n("Cannot process transactions in account %1, which is closed.", closedAccount);
       showTooltip(tooltip);
       return false;
     }
 
     if (!m_register->focusItem()->isSelected()) {
       tooltip = i18n("Cannot process transaction with focus if it is not selected.");
       showTooltip(tooltip);
       return false;
     }
     tooltip.clear();
     return !list.isEmpty();
   }
 
   void showTooltip(const QString msg) const
   {
     QToolTip::showText(m_tooltipPosn, msg);
   }
 
   bool createNewTransaction()
   {
     Q_Q(KGlobalLedgerView);
     auto rc = false;
     QString txt;
     if (q->canCreateTransactions(txt)) {
       rc = q->selectEmptyTransaction();
     }
     return rc;
   }
 
   TransactionEditor* startEdit(const KMyMoneyRegister::SelectedTransactions& list)
   {
     Q_Q(KGlobalLedgerView);
     TransactionEditor* editor = 0;
     QString txt;
     if (q->canEditTransactions(list, txt) || q->canCreateTransactions(txt)) {
       editor = q->startEdit(list);
     }
     return editor;
   }
 
   void doDeleteTransactions()
   {
     Q_Q(KGlobalLedgerView);
     KMyMoneyRegister::SelectedTransactions list = m_selectedTransactions;
     KMyMoneyRegister::SelectedTransactions::iterator it_t;
     int cnt = list.count();
     int i = 0;
     emit q->slotStatusProgress(0, cnt);
     MyMoneyFileTransaction ft;
     const auto file = MyMoneyFile::instance();
     try {
       it_t = list.begin();
       while (it_t != list.end()) {
         // only remove those transactions that do not reference a closed account
         if (!file->referencesClosedAccount((*it_t).transaction())) {
           file->removeTransaction((*it_t).transaction());
           // remove all those references in the list of selected transactions
           // that refer to the same transaction we just removed so that we
           // will not be caught by an exception later on (see bko #285310)
           KMyMoneyRegister::SelectedTransactions::iterator it_td = it_t;
           ++it_td;
           while (it_td != list.end()) {
             if ((*it_t).transaction().id() == (*it_td).transaction().id()) {
               it_td = list.erase(it_td);
               i++; // bump count of deleted transactions
             } else {
               ++it_td;
             }
           }
         }
         // need to ensure "nextCheckNumber" is still correct
         auto acc = file->account((*it_t).split().accountId());
         // the "lastNumberUsed" might have been the txn number deleted
         // so adjust it
         QString deletedNum = (*it_t).split().number();
         // decrement deletedNum and set new "lastNumberUsed"
         QString num = KMyMoneyUtils::getAdjacentNumber(deletedNum, -1);
         acc.setValue("lastNumberUsed", num);
 
         file->modifyAccount(acc);
         list.erase(it_t);
         it_t = list.begin();
         emit q->slotStatusProgress(i++, 0);
       }
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(q, i18n("Error"), i18n("Unable to delete transaction(s): %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(q, i18n("Unable to delete transaction(s)"), e.what());
     }
     emit q->slotStatusProgress(-1, -1);
   }
 
   void deleteTransactionEditor()
   {
     // make sure, we don't use the transaction editor pointer
     // anymore from now on
     auto p = m_transactionEditor;
     m_transactionEditor = nullptr;
     delete p;
   }
 
   void transactionUnmatch()
   {
     Q_Q(KGlobalLedgerView);
     KMyMoneyRegister::SelectedTransactions::const_iterator it;
     MyMoneyFileTransaction ft;
     try {
       for (it = m_selectedTransactions.constBegin(); it != m_selectedTransactions.constEnd(); ++it) {
         if ((*it).split().isMatched()) {
           TransactionMatcher matcher(m_currentAccount);
           matcher.unmatch((*it).transaction(), (*it).split());
         }
       }
       ft.commit();
 
     } catch (const MyMoneyException &e) {
       KMessageBox::detailedSorry(q, i18n("Unable to unmatch the selected transactions"), e.what());
     }
   }
 
   void transactionMatch()
   {
     Q_Q(KGlobalLedgerView);
     if (m_selectedTransactions.count() != 2)
       return;
 
     MyMoneyTransaction startMatchTransaction;
     MyMoneyTransaction endMatchTransaction;
     MyMoneySplit startSplit;
     MyMoneySplit endSplit;
 
     KMyMoneyRegister::SelectedTransactions::const_iterator it;
     KMyMoneyRegister::SelectedTransactions toBeDeleted;
     for (it = m_selectedTransactions.constBegin(); it != m_selectedTransactions.constEnd(); ++it) {
       if ((*it).transaction().isImported()) {
         if (endMatchTransaction.id().isEmpty()) {
           endMatchTransaction = (*it).transaction();
           endSplit = (*it).split();
           toBeDeleted << *it;
         } else {
           //This is a second imported transaction, we still want to merge
           startMatchTransaction = (*it).transaction();
           startSplit = (*it).split();
         }
       } else if (!(*it).split().isMatched()) {
         if (startMatchTransaction.id().isEmpty()) {
           startMatchTransaction = (*it).transaction();
           startSplit = (*it).split();
         } else {
           endMatchTransaction = (*it).transaction();
           endSplit = (*it).split();
           toBeDeleted << *it;
         }
       }
     }
 
   #if 0
     KMergeTransactionsDlg dlg(m_selectedAccount);
     dlg.addTransaction(startMatchTransaction);
     dlg.addTransaction(endMatchTransaction);
     if (dlg.exec() == QDialog::Accepted)
   #endif
     {
       MyMoneyFileTransaction ft;
       try {
         if (startMatchTransaction.id().isEmpty())
-          throw MYMONEYEXCEPTION(i18n("No manually entered transaction selected for matching"));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("No manually entered transaction selected for matching"));
         if (endMatchTransaction.id().isEmpty())
-          throw MYMONEYEXCEPTION(i18n("No imported transaction selected for matching"));
+          throw MYMONEYEXCEPTION(QString::fromLatin1("No imported transaction selected for matching"));
 
         TransactionMatcher matcher(m_currentAccount);
         matcher.match(startMatchTransaction, startSplit, endMatchTransaction, endSplit, true);
         ft.commit();
       } catch (const MyMoneyException &e) {
         KMessageBox::detailedSorry(q, i18n("Unable to match the selected transactions"), e.what());
       }
     }
   }
 
   /**
     * Mark the selected transactions as provided by @a flag. If
     * flag is @a MyMoneySplit::Unknown, the future state depends
     * on the current stat of the split's flag accoring to the
     * following table:
     *
     * - NotReconciled --> Cleared
     * - Cleared --> Reconciled
     * - Reconciled --> NotReconciled
     */
   void markTransaction(eMyMoney::Split::State flag)
   {
     Q_Q(KGlobalLedgerView);
     auto list = m_selectedTransactions;
     KMyMoneyRegister::SelectedTransactions::const_iterator it_t;
     auto cnt = list.count();
     auto i = 0;
     emit q->slotStatusProgress(0, cnt);
     MyMoneyFileTransaction ft;
     try {
       for (it_t = list.constBegin(); it_t != list.constEnd(); ++it_t) {
         // turn on signals before we modify the last entry in the list
         cnt--;
         MyMoneyFile::instance()->blockSignals(cnt != 0);
 
         // get a fresh copy
         auto t = MyMoneyFile::instance()->transaction((*it_t).transaction().id());
         auto sp = t.splitById((*it_t).split().id());
         if (sp.reconcileFlag() != flag) {
           if (flag == eMyMoney::Split::State::Unknown) {
             if (m_reconciliationAccount.id().isEmpty()) {
               // in normal mode we cycle through all states
               switch (sp.reconcileFlag()) {
                 case eMyMoney::Split::State::NotReconciled:
                   sp.setReconcileFlag(eMyMoney::Split::State::Cleared);
                   break;
                 case eMyMoney::Split::State::Cleared:
                   sp.setReconcileFlag(eMyMoney::Split::State::Reconciled);
                   break;
                 case eMyMoney::Split::State::Reconciled:
                   sp.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
                   break;
                 default:
                   break;
               }
             } else {
               // in reconciliation mode we skip the reconciled state
               switch (sp.reconcileFlag()) {
                 case eMyMoney::Split::State::NotReconciled:
                   sp.setReconcileFlag(eMyMoney::Split::State::Cleared);
                   break;
                 case eMyMoney::Split::State::Cleared:
                   sp.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
                   break;
                 default:
                   break;
               }
             }
           } else {
             sp.setReconcileFlag(flag);
           }
 
           t.modifySplit(sp);
           MyMoneyFile::instance()->modifyTransaction(t);
         }
         emit q->slotStatusProgress(i++, 0);
       }
       emit q->slotStatusProgress(-1, -1);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(q, i18n("Error"), i18n("Unable to modify transaction: %1, thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(q, i18n("Unable to modify transaction"), e.what());
     }
   }
 
   // move a stock transaction from one investment account to another
   void moveInvestmentTransaction(const QString& /*fromId*/,
       const QString& toId,
       const MyMoneyTransaction& tx)
   {
     MyMoneyAccount toInvAcc = MyMoneyFile::instance()->account(toId);
     MyMoneyTransaction t(tx);
     // first determine which stock we are dealing with.
     // fortunately, investment transactions have only one stock involved
     QString stockAccountId;
     QString stockSecurityId;
     MyMoneySplit s;
     foreach (const auto split, t.splits()) {
       stockAccountId = split.accountId();
       stockSecurityId =
         MyMoneyFile::instance()->account(stockAccountId).currencyId();
       if (!MyMoneyFile::instance()->security(stockSecurityId).isCurrency()) {
         s = split;
         break;
       }
     }
     // Now check the target investment account to see if it
     // contains a stock with this id
     QString newStockAccountId;
     foreach (const auto sAccount, toInvAcc.accountList()) {
       if (MyMoneyFile::instance()->account(sAccount).currencyId() ==
           stockSecurityId) {
         newStockAccountId = sAccount;
         break;
       }
     }
     // if it doesn't exist, we need to add it as a copy of the old one
     // no 'copyAccount()' function??
     if (newStockAccountId.isEmpty()) {
       MyMoneyAccount stockAccount =
         MyMoneyFile::instance()->account(stockAccountId);
       MyMoneyAccount newStock;
       newStock.setName(stockAccount.name());
       newStock.setNumber(stockAccount.number());
       newStock.setDescription(stockAccount.description());
       newStock.setInstitutionId(stockAccount.institutionId());
       newStock.setOpeningDate(stockAccount.openingDate());
       newStock.setAccountType(stockAccount.accountType());
       newStock.setCurrencyId(stockAccount.currencyId());
       newStock.setClosed(stockAccount.isClosed());
       MyMoneyFile::instance()->addAccount(newStock, toInvAcc);
       newStockAccountId = newStock.id();
     }
     // now update the split and the transaction
     s.setAccountId(newStockAccountId);
     t.modifySplit(s);
     MyMoneyFile::instance()->modifyTransaction(t);
   }
 
   void createTransactionMoveMenu()
   {
     Q_Q(KGlobalLedgerView);
     if (!m_moveToAccountSelector) {
       auto menu = pMenus[eMenu::Menu::MoveTransaction];
       if (menu ) {
         auto accountSelectorAction = new QWidgetAction(menu);
         m_moveToAccountSelector = new KMyMoneyAccountSelector(menu, 0, false);
         m_moveToAccountSelector->setObjectName("transaction_move_menu_selector");
         accountSelectorAction->setDefaultWidget(m_moveToAccountSelector);
         menu->addAction(accountSelectorAction);
         q->connect(m_moveToAccountSelector, &QObject::destroyed, q, &KGlobalLedgerView::slotObjectDestroyed);
         q->connect(m_moveToAccountSelector, &KMyMoneySelector::itemSelected, q, &KGlobalLedgerView::slotMoveToAccount);
       }
     }
   }
 
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > automaticReconciliation(const MyMoneyAccount &account,
       const QList<QPair<MyMoneyTransaction, MyMoneySplit> > &transactions,
       const MyMoneyMoney &amount)
   {
     Q_Q(KGlobalLedgerView);
     static const int NR_OF_STEPS_LIMIT = 300000;
     static const int PROGRESSBAR_STEPS = 1000;
     QList<QPair<MyMoneyTransaction, MyMoneySplit> > result = transactions;
 
 //    KMSTATUS(i18n("Running automatic reconciliation"));
     auto progressBarIndex = 0;
     q->slotStatusProgress(progressBarIndex, NR_OF_STEPS_LIMIT / PROGRESSBAR_STEPS);
 
     // optimize the most common case - all transactions should be cleared
     QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplitResult(result);
     MyMoneyMoney transactionsBalance;
     while (itTransactionSplitResult.hasNext()) {
       const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplitResult.next();
       transactionsBalance += transactionSplit.second.shares();
     }
     if (amount == transactionsBalance) {
       result = transactions;
       return result;
     }
     q->slotStatusProgress(progressBarIndex++, 0);
     // only one transaction is uncleared
     itTransactionSplitResult.toFront();
     int index = 0;
     while (itTransactionSplitResult.hasNext()) {
       const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplitResult.next();
       if (transactionsBalance - transactionSplit.second.shares() == amount) {
         result.removeAt(index);
         return result;
       }
       index++;
     }
     q->slotStatusProgress(progressBarIndex++, 0);
 
     // more than one transaction is uncleared - apply the algorithm
     result.clear();
 
     const auto& security = MyMoneyFile::instance()->security(account.currencyId());
     double precision = 0.1 / account.fraction(security);
 
     QList<MyMoneyMoney> sumList;
     sumList << MyMoneyMoney();
 
     QMap<MyMoneyMoney, QList<QPair<QString, QString> > > sumToComponentsMap;
 
     // compute the possible matches
     QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > it_ts(transactions);
     while (it_ts.hasNext()) {
       const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = it_ts.next();
       QListIterator<MyMoneyMoney> itSum(sumList);
       QList<MyMoneyMoney> tempList;
       while (itSum.hasNext()) {
         const MyMoneyMoney &sum = itSum.next();
         QList<QPair<QString, QString> > splitIds;
         splitIds << qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id());
         if (sumToComponentsMap.contains(sum)) {
           if (sumToComponentsMap.value(sum).contains(qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id()))) {
             continue;
           }
           splitIds.append(sumToComponentsMap.value(sum));
         }
         tempList << transactionSplit.second.shares() + sum;
         sumToComponentsMap[transactionSplit.second.shares() + sum] = splitIds;
         int size = sumToComponentsMap.size();
         if (size % PROGRESSBAR_STEPS == 0) {
           q->slotStatusProgress(progressBarIndex++, 0);
         }
         if (size > NR_OF_STEPS_LIMIT) {
           return result; // it's taking too much resources abort the algorithm
         }
       }
       QList<MyMoneyMoney> unionList;
       unionList.append(tempList);
       unionList.append(sumList);
       qSort(unionList);
       sumList.clear();
       MyMoneyMoney smallestSumFromUnion = unionList.first();
       sumList.append(smallestSumFromUnion);
       QListIterator<MyMoneyMoney> itUnion(unionList);
       while (itUnion.hasNext()) {
         MyMoneyMoney sumFromUnion = itUnion.next();
         if (smallestSumFromUnion < MyMoneyMoney(1 - precision / transactions.size())*sumFromUnion) {
           smallestSumFromUnion = sumFromUnion;
           sumList.append(sumFromUnion);
         }
       }
     }
 
     q->slotStatusProgress(NR_OF_STEPS_LIMIT / PROGRESSBAR_STEPS, 0);
     if (sumToComponentsMap.contains(amount)) {
       QListIterator<QPair<MyMoneyTransaction, MyMoneySplit> > itTransactionSplit(transactions);
       while (itTransactionSplit.hasNext()) {
         const QPair<MyMoneyTransaction, MyMoneySplit> &transactionSplit = itTransactionSplit.next();
         const QList<QPair<QString, QString> > &splitIds = sumToComponentsMap.value(amount);
         if (splitIds.contains(qMakePair<QString, QString>(transactionSplit.first.id(), transactionSplit.second.id()))) {
           result.append(transactionSplit);
         }
       }
     }
 
   #ifdef KMM_DEBUG
     qDebug("For the amount %s a number of %d possible sums where computed from the set of %d transactions: ",
            qPrintable(MyMoneyUtils::formatMoney(amount, security)), sumToComponentsMap.size(), transactions.size());
   #endif
 
     q->slotStatusProgress(-1, -1);
     return result;
   }
 
   KGlobalLedgerView   *q_ptr;
   MousePressFilter    *m_mousePressFilter;
   KMyMoneyRegister::RegisterSearchLineWidget* m_registerSearchLine;
 //  QString              m_reconciliationAccount;
   QDate                m_reconciliationDate;
   MyMoneyMoney         m_endingBalance;
   int                  m_precision;
   bool                 m_recursion;
   bool                 m_showDetails;
   eWidgets::eRegister::Action m_action;
 
   // models
   AccountNamesFilterProxyModel *m_filterProxyModel;
 
   // widgets
   KMyMoneyAccountCombo* m_accountComboBox;
 
   MyMoneyMoney         m_totalBalance;
   bool                 m_balanceIsApproximated;
   // frames
   QFrame*                       m_toolbarFrame;
   QFrame*                       m_registerFrame;
   QFrame*                       m_buttonFrame;
   QFrame*                       m_formFrame;
   QFrame*                       m_summaryFrame;
 
   // widgets
   KMyMoneyRegister::Register*   m_register;
   KToolBar*                     m_buttonbar;
 
   /**
     * This member holds the currently selected account
     */
   MyMoneyAccount m_currentAccount;
   QString m_lastSelectedAccountID;
 
   MyMoneyAccount m_reconciliationAccount;
 
   /**
     * This member holds the transaction list
     */
   QList<QPair<MyMoneyTransaction, MyMoneySplit> >  m_transactionList;
 
   QLabel*                         m_leftSummaryLabel;
   QLabel*                         m_centerSummaryLabel;
   QLabel*                         m_rightSummaryLabel;
 
   KMyMoneyTransactionForm::TransactionForm* m_form;
 
   /**
     * This member holds the load state of page
     */
   bool                            m_needLoad;
 
   bool                            m_newAccountLoaded;
   bool                            m_inEditMode;
 
   QWidgetList                     m_tabOrderWidgets;
   QPoint                          m_tooltipPosn;
   KMyMoneyRegister::SelectedTransactions m_selectedTransactions;
   /**
     * This member keeps the date that was used as the last posting date.
     * It will be updated whenever the user modifies the post date
     * and is used to preset the posting date when new transactions are created.
     * This member is initialised to the current date when the program is started.
     */
   static QDate         m_lastPostDate;
   // pointer to the current transaction editor
   QPointer<TransactionEditor> m_transactionEditor;
 
   // id's that need to be remembered
   QString  m_accountGoto, m_payeeGoto;
   QString  m_lastPayeeEnteredId;
   QScopedPointer<KBalanceWarning> m_balanceWarning;
   KMyMoneyAccountSelector* m_moveToAccountSelector;
 
   // Reconciliation dialog
   KEndingBalanceDlg*    m_endingBalanceDlg;
   KFindTransactionDlg*  m_searchDlg;
 };
 
 #endif
diff --git a/kmymoney/views/khomeview_p.h b/kmymoney/views/khomeview_p.h
index b2799c194..2b7f15184 100644
--- a/kmymoney/views/khomeview_p.h
+++ b/kmymoney/views/khomeview_p.h
@@ -1,1983 +1,1983 @@
 /***************************************************************************
                           khomeview_p.h  -  description
                              -------------------
     begin                : Tue Jan 22 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KHOMEVIEW_P_H
 #define KHOMEVIEW_P_H
 
 #include "khomeview.h"
 
 #include <config-kmymoney.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QPixmap>
 #include <QTimer>
 #include <QBuffer>
 #include <QStandardPaths>
 #include <QDesktopServices>
 #include <QUrlQuery>
 #include <QWheelEvent>
 #include <QPrintDialog>
 #include <QPrinter>
 #include <QPointer>
 #ifdef ENABLE_WEBENGINE
 #include <QWebEngineView>
 #else
 #include <KWebView>
 #endif
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KChartAbstractCoordinatePlane>
 #include <KChartChart>
 #include <KLocalizedString>
 #include <KXmlGuiWindow>
 #include <KActionCollection>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneyviewbase_p.h"
 #include "mymoneyutils.h"
 #include "kmymoneyutils.h"
 #include "kwelcomepage.h"
 #include "kmymoneysettings.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneyprice.h"
 #include "mymoneyforecast.h"
 #include "kreportchartview.h"
 #include "pivottable.h"
 #include "pivotgrid.h"
 #include "reportaccount.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "icons.h"
 #include "kmymoneywebpage.h"
 #include "mymoneyschedule.h"
 #include "mymoneysecurity.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 #include "menuenums.h"
 
 #define VIEW_LEDGER         "ledger"
 #define VIEW_SCHEDULE       "schedule"
 #define VIEW_WELCOME        "welcome"
 #define VIEW_HOME           "home"
 #define VIEW_REPORTS        "reports"
 
 using namespace Icons;
 using namespace eMyMoney;
 
 /**
  * @brief Converts a QPixmap to an data URI scheme
  *
  * According to RFC 2397
  *
  * @param pixmap Source to convert
  * @return full data URI
  */
 QString QPixmapToDataUri(const QPixmap& pixmap)
 {
   QImage image(pixmap.toImage());
   QByteArray byteArray;
   QBuffer buffer(&byteArray);
   buffer.open(QIODevice::WriteOnly);
   image.save(&buffer, "PNG"); // writes the image in PNG format inside the buffer
   return QLatin1String("data:image/png;base64,") + QString(byteArray.toBase64());
 }
 
 bool accountNameLess(const MyMoneyAccount &acc1, const MyMoneyAccount &acc2)
 {
   return acc1.name().localeAwareCompare(acc2.name()) < 0;
 }
 
 using namespace reports;
 
 class KHomeViewPrivate : public KMyMoneyViewBasePrivate
 {
   Q_DECLARE_PUBLIC(KHomeView)
 
 public:
   explicit KHomeViewPrivate(KHomeView *qq) :
     KMyMoneyViewBasePrivate(),
     q_ptr(qq),
     m_view(nullptr),
     m_showAllSchedules(false),
     m_needLoad(true),
     m_netWorthGraphLastValidSize(400, 300),
     m_currentPrinter(nullptr)
   {
   }
 
   ~KHomeViewPrivate() {
     // if user wants to remember the font size, store it here
     if (KMyMoneySettings::rememberZoomFactor() && m_view) {
         KMyMoneySettings::setZoomFactor(m_view->zoomFactor());
         KMyMoneySettings::self()->save();
       }
   }
 
   /**
     * Definition of bitmap used as argument for showAccounts().
     */
   enum paymentTypeE {
     Preferred = 1,          ///< show preferred accounts
     Payment = 2             ///< show payment accounts
   };
 
   void init()
   {
     Q_Q(KHomeView);
     m_needLoad = false;
 
     auto vbox = new QVBoxLayout(q);
     q->setLayout(vbox);
     vbox->setSpacing(6);
     vbox->setMargin(0);
 
   #ifdef ENABLE_WEBENGINE
     m_view = new QWebEngineView(q);
   #else
     m_view = new KWebView(q);
   #endif
     m_view->setPage(new MyQWebEnginePage(m_view));
 
     vbox->addWidget(m_view);
 
     m_view->setHtml(KWelcomePage::welcomePage(), QUrl("file://"));
   #ifdef ENABLE_WEBENGINE
     q->connect(m_view->page(), &QWebEnginePage::urlChanged,
             q, &KHomeView::slotOpenUrl);
   #else
     m_view->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
     q->connect(m_view->page(), &KWebPage::linkClicked,
             q, &KHomeView::slotOpenUrl);
   #endif
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KHomeView::refresh);
   }
 
   /**
     * Print an account and its balance and limit
     */
   void showAccountEntry(const MyMoneyAccount& acc, const MyMoneyMoney& value, const MyMoneyMoney& valueToMinBal, const bool showMinBal)
   {
     MyMoneyFile* file = MyMoneyFile::instance();
     QString tmp;
     MyMoneySecurity currency = file->currency(acc.currencyId());
     QString amount;
     QString amountToMinBal;
 
     //format amounts
     amount = MyMoneyUtils::formatMoney(value, acc, currency);
     amount.replace(QChar(' '), "&nbsp;");
     if (showMinBal) {
       amountToMinBal = MyMoneyUtils::formatMoney(valueToMinBal, acc, currency);
       amountToMinBal.replace(QChar(' '), "&nbsp;");
     }
 
     QString cellStatus, cellCounts, pathOK, pathTODO, pathNotOK;
 
     if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) {
       //show account's online-status
       pathOK = QPixmapToDataUri(Icons::get(Icon::DialogOKApply).pixmap(QSize(16,16)));
       pathTODO = QPixmapToDataUri(Icons::get(Icon::MailReceive).pixmap(QSize(16,16)));
       pathNotOK = QPixmapToDataUri(Icons::get(Icon::DialogCancel).pixmap(QSize(16,16)));
 
       if (acc.value("lastImportedTransactionDate").isEmpty() || acc.value("lastStatementBalance").isEmpty())
         cellStatus = '-';
       else if (file->hasMatchingOnlineBalance(acc)) {
         if (file->hasNewerTransaction(acc.id(), QDate::fromString(acc.value("lastImportedTransactionDate"), Qt::ISODate)))
           cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathTODO);
         else
           cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathOK);
       } else
         cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathNotOK);
 
       tmp = QString("<td class=\"center\">%1</td>").arg(cellStatus);
     }
 
     tmp += QString("<td>") +
            link(VIEW_LEDGER, QString("?id=%1").arg(acc.id())) + acc.name() + linkend() + "</td>";
 
     int countNotMarked = 0, countCleared = 0, countNotReconciled = 0;
     QString countStr;
 
     if (KMyMoneySettings::showCountOfUnmarkedTransactions() || KMyMoneySettings::showCountOfNotReconciledTransactions())
       countNotMarked = file->countTransactionsWithSpecificReconciliationState(acc.id(), TransactionFilter::State::NotReconciled);
 
     if (KMyMoneySettings::showCountOfClearedTransactions() || KMyMoneySettings::showCountOfNotReconciledTransactions())
       countCleared = file->countTransactionsWithSpecificReconciliationState(acc.id(), TransactionFilter::State::Cleared);
 
     if (KMyMoneySettings::showCountOfNotReconciledTransactions())
       countNotReconciled = countNotMarked + countCleared;
 
     if (KMyMoneySettings::showCountOfUnmarkedTransactions()) {
       if (countNotMarked)
         countStr = QString("%1").arg(countNotMarked);
       else
         countStr = '-';
       tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
     }
 
     if (KMyMoneySettings::showCountOfClearedTransactions()) {
       if (countCleared)
         countStr = QString("%1").arg(countCleared);
       else
         countStr = '-';
       tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
     }
 
     if (KMyMoneySettings::showCountOfNotReconciledTransactions()) {
       if (countNotReconciled)
         countStr = QString("%1").arg(countNotReconciled);
       else
         countStr = '-';
       tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
     }
 
     if (KMyMoneySettings::showDateOfLastReconciliation()) {
       const auto lastReconciliationDate = acc.lastReconciliationDate().toString(Qt::SystemLocaleShortDate).replace(QChar(' '), "&nbsp;");
       tmp += QString("<td>%1</d>").arg(lastReconciliationDate);
     }
 
     //show account balance
     tmp += QString("<td class=\"right\">%1</td>").arg(showColoredAmount(amount, value.isNegative()));
 
     //show minimum balance column if requested
     if (showMinBal) {
       //if it is an investment, show minimum balance empty
       if (acc.accountType() == Account::Type::Investment) {
         tmp += QString("<td class=\"right\">&nbsp;</td>");
       } else {
         //show minimum balance entry
         tmp += QString("<td class=\"right\">%1</td>").arg(showColoredAmount(amountToMinBal, valueToMinBal.isNegative()));
       }
     }
     // qDebug("accountEntry = '%s'", tmp.toLatin1());
     m_html += tmp;
   }
 
   void showAccountEntry(const MyMoneyAccount& acc)
   {
     MyMoneyFile* file = MyMoneyFile::instance();
     MyMoneySecurity currency = file->currency(acc.currencyId());
     MyMoneyMoney value;
 
     bool showLimit = KMyMoneySettings::showLimitInfo();
 
     if (acc.accountType() == Account::Type::Investment) {
       //investment accounts show the balances of all its subaccounts
       value = investmentBalance(acc);
 
       //investment accounts have no minimum balance
       showAccountEntry(acc, value, MyMoneyMoney(), showLimit);
     } else {
       //get balance for normal accounts
       value = file->balance(acc.id(), QDate::currentDate());
       if (acc.currencyId() != file->baseCurrency().id()) {
         ReportAccount repAcc = ReportAccount(acc.id());
         MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
         MyMoneyMoney baseValue = value * curPrice;
         baseValue = baseValue.convert(file->baseCurrency().smallestAccountFraction());
         m_total += baseValue;
       } else {
         m_total += value;
       }
       //if credit card or checkings account, show maximum credit
       if (acc.accountType() == Account::Type::CreditCard ||
           acc.accountType() == Account::Type::Checkings) {
         QString maximumCredit = acc.value("maxCreditAbsolute");
         if (maximumCredit.isEmpty()) {
           maximumCredit = acc.value("minBalanceAbsolute");
         }
         MyMoneyMoney maxCredit = MyMoneyMoney(maximumCredit);
         showAccountEntry(acc, value, value - maxCredit, showLimit);
       } else {
         //otherwise use minimum balance
         QString minimumBalance = acc.value("minBalanceAbsolute");
         MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
         showAccountEntry(acc, value, value - minBalance, showLimit);
       }
     }
   }
 
   /**
     * @param acc the investment account
     * @return the balance in the currency of the investment account
     */
   MyMoneyMoney investmentBalance(const MyMoneyAccount& acc)
   {
     auto file = MyMoneyFile::instance();
     auto value = file->balance(acc.id(), QDate::currentDate());
     foreach (const auto accountID, acc.accountList()) {
       auto stock = file->account(accountID);
       if (!stock.isClosed()) {
         try {
           MyMoneyMoney val;
           MyMoneyMoney balance = file->balance(stock.id(), QDate::currentDate());
           MyMoneySecurity security = file->security(stock.currencyId());
           const MyMoneyPrice &price = file->price(stock.currencyId(), security.tradingCurrency());
           val = (balance * price.rate(security.tradingCurrency())).convertPrecision(security.pricePrecision());
           // adjust value of security to the currency of the account
           MyMoneySecurity accountCurrency = file->currency(acc.currencyId());
           val = val * file->price(security.tradingCurrency(), accountCurrency.id()).rate(accountCurrency.id());
           val = val.convert(acc.fraction());
           value += val;
         } catch (const MyMoneyException &e) {
           qWarning("%s", qPrintable(QString("cannot convert stock balance of %1 to base currency: %2").arg(stock.name(), e.what())));
         }
       }
     }
     return value;
   }
 
   /**
    * Print text in the color set for negative numbers, if @p amount is negative
    * abd @p isNegative is true
    */
   QString showColoredAmount(const QString& amount, bool isNegative)
   {
     if (isNegative) {
       //if negative, get the settings for negative numbers
       return QString("<font color=\"%1\">%2</font>").arg(KMyMoneySettings::schemeColor(SchemeColor::Negative).name(), amount);
     }
 
     //if positive, return the same string
     return amount;
   }
 
   /**
    * Run the forecast
    */
   void doForecast()
   {
     //clear m_accountList because forecast is about to changed
     m_accountList.clear();
 
     //reinitialize the object
     m_forecast = KMyMoneyUtils::forecast();
 
     //If forecastDays lower than accountsCycle, adjust to the first cycle
     if (m_forecast.accountsCycle() > m_forecast.forecastDays())
       m_forecast.setForecastDays(m_forecast.accountsCycle());
 
     //Get all accounts of the right type to calculate forecast
     m_forecast.doForecast();
   }
 
   /**
    * Calculate the forecast balance after a payment has been made
    */
   MyMoneyMoney forecastPaymentBalance(const MyMoneyAccount& acc, const MyMoneyMoney& payment, QDate& paymentDate)
   {
     //if paymentDate before or equal to currentDate set it to current date plus 1
     //so we get to accumulate forecast balance correctly
     if (paymentDate <= QDate::currentDate())
       paymentDate = QDate::currentDate().addDays(1);
 
     //check if the account is already there
     if (m_accountList.find(acc.id()) == m_accountList.end()
         || m_accountList[acc.id()].find(paymentDate) == m_accountList[acc.id()].end()) {
       if (paymentDate == QDate::currentDate()) {
         m_accountList[acc.id()][paymentDate] = m_forecast.forecastBalance(acc, paymentDate);
       } else {
         m_accountList[acc.id()][paymentDate] = m_forecast.forecastBalance(acc, paymentDate.addDays(-1));
       }
     }
     m_accountList[acc.id()][paymentDate] = m_accountList[acc.id()][paymentDate] + payment;
     return m_accountList[acc.id()][paymentDate];
   }
 
   void loadView()
   {
     m_view->setZoomFactor(KMyMoneySettings::zoomFactor());
 
     QList<MyMoneyAccount> list;
     MyMoneyFile::instance()->accountList(list);
     if (list.count() == 0) {
       m_view->setHtml(KWelcomePage::welcomePage(), QUrl("file://"));
     } else {
       //clear the forecast flag so it will be reloaded
       m_forecast.setForecastDone(false);
 
       const QString filename = QStandardPaths::locate(QStandardPaths::AppConfigLocation, "html/kmymoney.css");
       QString header = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\">\n<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"%1\">\n").arg(QUrl::fromLocalFile(filename).url());
 
       header += KMyMoneyUtils::variableCSS();
 
       header += "</head><body id=\"summaryview\">\n";
 
       QString footer = "</body></html>\n";
 
       m_html.clear();
       m_html += header;
 
       m_html += QString("<div id=\"summarytitle\">%1</div>").arg(i18n("Your Financial Summary"));
 
       QStringList settings = KMyMoneySettings::listOfItems();
 
       QStringList::ConstIterator it;
 
       for (it = settings.constBegin(); it != settings.constEnd(); ++it) {
         int option = (*it).toInt();
         if (option > 0) {
           switch (option) {
             case 1:         // payments
               showPayments();
               break;
 
             case 2:         // preferred accounts
               showAccounts(Preferred, i18n("Preferred Accounts"));
               break;
 
             case 3:         // payment accounts
               // Check if preferred accounts are shown separately
               if (settings.contains("2")) {
                 showAccounts(static_cast<paymentTypeE>(Payment | Preferred),
                              i18n("Payment Accounts"));
               } else {
                 showAccounts(Payment, i18n("Payment Accounts"));
               }
               break;
             case 4:         // favorite reports
               showFavoriteReports();
               break;
             case 5:         // forecast
               showForecast();
               break;
             case 6:         // net worth graph over all accounts
               showNetWorthGraph();
               break;
             case 8:         // assets and liabilities
               showAssetsLiabilities();
               break;
             case 9:         // budget
               showBudget();
               break;
             case 10:         // cash flow summary
               showCashFlowSummary();
               break;
 
 
           }
           m_html += "<div class=\"gap\">&nbsp;</div>\n";
         }
       }
 
       m_html += "<div id=\"returnlink\">";
       m_html += link(VIEW_WELCOME, QString()) + i18n("Show KMyMoney welcome page") + linkend();
       m_html += "</div>";
       m_html += "<div id=\"vieweffect\"></div>";
       m_html += footer;
 
       m_view->setHtml(m_html, QUrl("file://"));
     }
   }
 
   void showNetWorthGraph()
   {
     Q_Q(KHomeView);
     m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("Net Worth Forecast"));
 
     MyMoneyReport reportCfg = MyMoneyReport(
                                 MyMoneyReport::eAssetLiability,
                                 MyMoneyReport::eMonths,
                                 TransactionFilter::Date::UserDefined, // overridden by the setDateFilter() call below
                                 MyMoneyReport::eDetailTotal,
                                 i18n("Net Worth Forecast"),
                                 i18n("Generated Report"));
 
     reportCfg.setChartByDefault(true);
     reportCfg.setChartCHGridLines(false);
     reportCfg.setChartSVGridLines(false);
     reportCfg.setChartDataLabels(false);
     reportCfg.setChartType(MyMoneyReport::eChartLine);
     reportCfg.setIncludingSchedules(false);
     reportCfg.addAccountGroup(Account::Type::Asset);
     reportCfg.addAccountGroup(Account::Type::Liability);
     reportCfg.setColumnsAreDays(true);
     reportCfg.setConvertCurrency(true);
     reportCfg.setIncludingForecast(true);
     reportCfg.setDateFilter(QDate::currentDate(), QDate::currentDate().addDays(+ 90));
     reports::PivotTable table(reportCfg);
 
     reports::KReportChartView* chartWidget = new reports::KReportChartView(0);
 
     table.drawChart(*chartWidget);
 
     // Adjust the size
     QSize netWorthGraphSize = q->size();
     netWorthGraphSize -= QSize(80, 30);
     // consider the computed size valid only if it's smaller on both axes that the applications size
 //    if (netWorthGraphSize.width() < kmymoney->width() || netWorthGraphSize.height() < kmymoney->height()) {
       m_netWorthGraphLastValidSize = netWorthGraphSize;
 //    }
     chartWidget->resize(m_netWorthGraphLastValidSize);
 
     //save the chart to an image
     QString chart = QPixmapToDataUri(chartWidget->coordinatePlane()->parent()->grab());
 
     m_html += QString("<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >");
     m_html += QString("<tr>");
     m_html += QString("<td><center><img src=\"%1\" ALT=\"Networth\" width=\"100%\" ></center></td>").arg(chart);
     m_html += QString("</tr>");
     m_html += QString("</table></div></div>");
 
     //delete the widget since we no longer need it
     delete chartWidget;
   }
 
   void showPayments()
   {
     MyMoneyFile* file = MyMoneyFile::instance();
     QList<MyMoneySchedule> overdues;
     QList<MyMoneySchedule> schedule;
     int i = 0;
 
     //if forecast has not been executed yet, do it.
     if (!m_forecast.isForecastDone())
       doForecast();
 
     schedule = file->scheduleList(QString(), Schedule::Type::Any,
                                   Schedule::Occurrence::Any,
                                   Schedule::PaymentType::Any,
                                   QDate::currentDate(),
                                   QDate::currentDate().addMonths(1), false);
     overdues = file->scheduleList(QString(), Schedule::Type::Any,
                                   Schedule::Occurrence::Any,
                                   Schedule::PaymentType::Any,
                                   QDate(), QDate(), true);
 
     if (schedule.empty() && overdues.empty())
       return;
 
     // HACK
     // Remove the finished schedules
     QList<MyMoneySchedule>::Iterator d_it;
     //regular schedules
     d_it = schedule.begin();
     while (d_it != schedule.end()) {
       if ((*d_it).isFinished()) {
         d_it = schedule.erase(d_it);
         continue;
       }
       ++d_it;
     }
     //overdue schedules
     d_it = overdues.begin();
     while (d_it != overdues.end()) {
       if ((*d_it).isFinished()) {
         d_it = overdues.erase(d_it);
         continue;
       }
       ++d_it;
     }
 
     m_html += "<div class=\"shadow\"><div class=\"displayblock\">";
     m_html += QString("<div class=\"summaryheader\">%1</div>\n").arg(i18n("Payments"));
 
     if (!overdues.isEmpty()) {
       m_html += "<div class=\"gap\">&nbsp;</div>\n";
 
       qSort(overdues);
       QList<MyMoneySchedule>::Iterator it;
       QList<MyMoneySchedule>::Iterator it_f;
 
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       m_html += QString("<tr class=\"itemtitle warningtitle\" ><td colspan=\"5\">%1</td></tr>\n").arg(showColoredAmount(i18n("Overdue payments"), true));
       m_html += "<tr class=\"item warning\">";
       m_html += "<td class=\"left\" width=\"10%\">";
       m_html += i18n("Date");
       m_html += "</td>";
       m_html += "<td class=\"left\" width=\"40%\">";
       m_html += i18n("Schedule");
       m_html += "</td>";
       m_html += "<td class=\"left\" width=\"20%\">";
       m_html += i18n("Account");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"15%\">";
       m_html += i18n("Amount");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"15%\">";
       m_html += i18n("Balance after");
       m_html += "</td>";
       m_html += "</tr>";
 
       for (it = overdues.begin(); it != overdues.end(); ++it) {
         // determine number of overdue payments
         int cnt =
           (*it).transactionsRemainingUntil(QDate::currentDate().addDays(-1));
 
         m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         showPaymentEntry(*it, cnt);
         m_html += "</tr>";
       }
       m_html += "</table>";
     }
 
     if (!schedule.isEmpty()) {
       qSort(schedule);
 
       // Extract todays payments if any
       QList<MyMoneySchedule> todays;
       QList<MyMoneySchedule>::Iterator t_it;
       for (t_it = schedule.begin(); t_it != schedule.end();) {
         if ((*t_it).adjustedNextDueDate() == QDate::currentDate()) {
           todays.append(*t_it);
           (*t_it).setNextDueDate((*t_it).nextPayment(QDate::currentDate()));
 
           // if adjustedNextDueDate is still currentDate then remove it from
           // scheduled payments
           if ((*t_it).adjustedNextDueDate() == QDate::currentDate()) {
             t_it = schedule.erase(t_it);
             continue;
           }
         }
         ++t_it;
       }
 
       if (todays.count() > 0) {
         m_html += "<div class=\"gap\">&nbsp;</div>\n";
         m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
         m_html += QString("<tr class=\"itemtitle\"><td class=\"left\" colspan=\"5\">%1</td></tr>\n").arg(i18n("Today's due payments"));
         m_html += "<tr class=\"item\">";
         m_html += "<td class=\"left\" width=\"10%\">";
         m_html += i18n("Date");
         m_html += "</td>";
         m_html += "<td class=\"left\" width=\"40%\">";
         m_html += i18n("Schedule");
         m_html += "</td>";
         m_html += "<td class=\"left\" width=\"20%\">";
         m_html += i18n("Account");
         m_html += "</td>";
         m_html += "<td class=\"right\" width=\"15%\">";
         m_html += i18n("Amount");
         m_html += "</td>";
         m_html += "<td class=\"right\" width=\"15%\">";
         m_html += i18n("Balance after");
         m_html += "</td>";
         m_html += "</tr>";
 
         for (t_it = todays.begin(); t_it != todays.end(); ++t_it) {
           m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
           showPaymentEntry(*t_it);
           m_html += "</tr>";
         }
         m_html += "</table>";
       }
 
       if (!schedule.isEmpty()) {
         m_html += "<div class=\"gap\">&nbsp;</div>\n";
 
         QList<MyMoneySchedule>::Iterator it;
 
         m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
         m_html += QString("<tr class=\"itemtitle\"><td class=\"left\" colspan=\"5\">%1</td></tr>\n").arg(i18n("Future payments"));
         m_html += "<tr class=\"item\">";
         m_html += "<td class=\"left\" width=\"10%\">";
         m_html += i18n("Date");
         m_html += "</td>";
         m_html += "<td class=\"left\" width=\"40%\">";
         m_html += i18n("Schedule");
         m_html += "</td>";
         m_html += "<td class=\"left\" width=\"20%\">";
         m_html += i18n("Account");
         m_html += "</td>";
         m_html += "<td class=\"right\" width=\"15%\">";
         m_html += i18n("Amount");
         m_html += "</td>";
         m_html += "<td class=\"right\" width=\"15%\">";
         m_html += i18n("Balance after");
         m_html += "</td>";
         m_html += "</tr>";
 
         // show all or the first 6 entries
         int cnt;
         cnt = (m_showAllSchedules) ? -1 : 6;
         bool needMoreLess = m_showAllSchedules;
 
         QDate lastDate = QDate::currentDate().addMonths(1);
         qSort(schedule);
         do {
           it = schedule.begin();
           if (it == schedule.end())
             break;
 
           // if the next due date is invalid (schedule is finished)
           // we remove it from the list
           QDate nextDate = (*it).nextDueDate();
           if (!nextDate.isValid()) {
             schedule.erase(it);
             continue;
           }
 
           if (nextDate > lastDate)
             break;
 
           if (cnt == 0) {
             needMoreLess = true;
             break;
           }
 
           // in case we've shown the current recurrence as overdue,
           // we don't show it here again, but keep the schedule
           // as it might show up later in the list again
           if (!(*it).isOverdue()) {
             if (cnt > 0)
               --cnt;
 
             m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
             showPaymentEntry(*it);
             m_html += "</tr>";
 
             // for single occurrence we have reported everything so we
             // better get out of here.
             if ((*it).occurrence() == Schedule::Occurrence::Once) {
               schedule.erase(it);
               continue;
             }
           }
 
           // if nextPayment returns an invalid date, setNextDueDate will
           // just skip it, resulting in a loop
           // we check the resulting date and erase the schedule if invalid
           if (!((*it).nextPayment((*it).nextDueDate())).isValid()) {
             schedule.erase(it);
             continue;
           }
 
           (*it).setNextDueDate((*it).nextPayment((*it).nextDueDate()));
           qSort(schedule);
         } while (1);
 
         if (needMoreLess) {
           m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
           m_html += "<td colspan=\"5\">";
           if (m_showAllSchedules) {
             m_html += link(VIEW_SCHEDULE,  QString("?mode=%1").arg("reduced")) + i18nc("Less...", "Show fewer schedules on the list") + linkend();
           } else {
             m_html += link(VIEW_SCHEDULE,  QString("?mode=%1").arg("full")) + i18nc("More...", "Show more schedules on the list") + linkend();
           }
           m_html += "</td>";
           m_html += "</tr>";
         }
         m_html += "</table>";
       }
     }
     m_html += "</div></div>";
   }
 
   void showPaymentEntry(const MyMoneySchedule& sched, int cnt = 1)
   {
     QString tmp;
     MyMoneyFile* file = MyMoneyFile::instance();
 
     try {
       MyMoneyAccount acc = sched.account();
       if (!acc.id().isEmpty()) {
         MyMoneyTransaction t = sched.transaction();
         // only show the entry, if it is still active
         if (!sched.isFinished()) {
           MyMoneySplit sp = t.splitByAccount(acc.id(), true);
 
           QString pathEnter = QPixmapToDataUri(Icons::get(Icon::KeyEnter).pixmap(QSize(16,16)));
           QString pathSkip = QPixmapToDataUri(Icons::get(Icon::MediaSkipForward).pixmap(QSize(16,16)));
 
           //show payment date
           tmp = QString("<td>") +
                 QLocale().toString(sched.adjustedNextDueDate(), QLocale::ShortFormat) +
                 "</td><td>";
           if (!pathEnter.isEmpty())
             tmp += link(VIEW_SCHEDULE, QString("?id=%1&amp;mode=enter").arg(sched.id()), i18n("Enter schedule")) + QString("<img src=\"%1\" border=\"0\"></a>").arg(pathEnter) + linkend();
           if (!pathSkip.isEmpty())
             tmp += "&nbsp;" + link(VIEW_SCHEDULE, QString("?id=%1&amp;mode=skip").arg(sched.id()), i18n("Skip schedule")) + QString("<img src=\"%1\" border=\"0\"></a>").arg(pathSkip) + linkend();
 
           tmp += QString("&nbsp;");
           tmp += link(VIEW_SCHEDULE, QString("?id=%1&amp;mode=edit").arg(sched.id()), i18n("Edit schedule")) + sched.name() + linkend();
 
           //show quantity of payments overdue if any
           if (cnt > 1)
             tmp += i18np(" (%1 payment)", " (%1 payments)", cnt);
 
           //show account of the main split
           tmp += "</td><td>";
           tmp += QString(file->account(acc.id()).name());
 
           //show amount of the schedule
           tmp += "</td><td align=\"right\">";
 
           const MyMoneySecurity& currency = MyMoneyFile::instance()->currency(acc.currencyId());
           MyMoneyMoney payment = MyMoneyMoney(sp.value(t.commodity(), acc.currencyId()) * cnt);
           QString amount = MyMoneyUtils::formatMoney(payment, acc, currency);
           amount.replace(QChar(' '), "&nbsp;");
           tmp += showColoredAmount(amount, payment.isNegative());
           tmp += "</td>";
           //show balance after payments
           tmp += "<td align=\"right\">";
           QDate paymentDate = QDate(sched.adjustedNextDueDate());
           MyMoneyMoney balanceAfter = forecastPaymentBalance(acc, payment, paymentDate);
           QString balance = MyMoneyUtils::formatMoney(balanceAfter, acc, currency);
           balance.replace(QChar(' '), "&nbsp;");
           tmp += showColoredAmount(balance, balanceAfter.isNegative());
           tmp += "</td>";
 
           // qDebug("paymentEntry = '%s'", tmp.toLatin1());
           m_html += tmp;
         }
       }
     } catch (const MyMoneyException &e) {
-      qDebug("Unable to display schedule entry: %s", qPrintable(e.what()));
+      qDebug("Unable to display schedule entry: %s", e.what());
     }
   }
 
   void showAccounts(paymentTypeE type, const QString& header)
   {
     MyMoneyFile* file = MyMoneyFile::instance();
     int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
     QList<MyMoneyAccount> accounts;
 
     auto showClosedAccounts = KMyMoneySettings::showAllAccounts();
 
     // get list of all accounts
     file->accountList(accounts);
     for (QList<MyMoneyAccount>::Iterator it = accounts.begin(); it != accounts.end();) {
       bool removeAccount = false;
       if (!(*it).isClosed() || showClosedAccounts) {
         switch ((*it).accountType()) {
           case Account::Type::Expense:
           case Account::Type::Income:
             // never show a category account
             // Note: This might be different in a future version when
             //       the homepage also shows category based information
             removeAccount = true;
             break;
 
             // Asset and Liability accounts are only shown if they
             // have the preferred flag set
           case Account::Type::Asset:
           case Account::Type::Liability:
           case Account::Type::Investment:
             // if preferred accounts are requested, then keep in list
             if ((*it).value("PreferredAccount") != "Yes"
                 || (type & Preferred) == 0) {
               removeAccount = true;
             }
             break;
 
             // Check payment accounts. If payment and preferred is selected,
             // then always show them. If only payment is selected, then
             // show only if preferred flag is not set.
           case Account::Type::Checkings:
           case Account::Type::Savings:
           case Account::Type::Cash:
           case Account::Type::CreditCard:
             switch (type & (Payment | Preferred)) {
               case Payment:
                 if ((*it).value("PreferredAccount") == "Yes")
                   removeAccount = true;
                 break;
 
               case Preferred:
                 if ((*it).value("PreferredAccount") != "Yes")
                   removeAccount = true;
                 break;
 
               case Payment | Preferred:
                 break;
 
               default:
                 removeAccount = true;
                 break;
             }
             break;
 
             // filter all accounts that are not used on homepage views
           default:
             removeAccount = true;
             break;
         }
 
       } else if ((*it).isClosed() || (*it).isInvest()) {
         // don't show if closed or a stock account
         removeAccount = true;
       }
 
       if (removeAccount)
         it = accounts.erase(it);
       else
         ++it;
     }
 
     if (!accounts.isEmpty()) {
       // sort the accounts by name
       qStableSort(accounts.begin(), accounts.end(), accountNameLess);
       QString tmp;
       int i = 0;
       tmp = "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + header + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
       m_html += tmp;
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       m_html += "<tr class=\"item\">";
 
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) {
         QString pathStatusHeader = QPixmapToDataUri(Icons::get(Icon::Download).pixmap(QSize(16,16)));
         m_html += QString("<td class=\"center\"><img src=\"%1\" border=\"0\"></td>").arg(pathStatusHeader);
       }
 
       m_html += "<td class=\"left\" width=\"35%\">";
       m_html += i18n("Account");
       m_html += "</td>";
 
       if (KMyMoneySettings::showCountOfUnmarkedTransactions())
         m_html += QString("<td class=\"center\">!M</td>");
 
       if (KMyMoneySettings::showCountOfClearedTransactions())
         m_html += QString("<td class=\"center\">C</td>");
 
       if (KMyMoneySettings::showCountOfNotReconciledTransactions())
         m_html += QString("<td class=\"center\">!R</td>");
 
       if (KMyMoneySettings::showDateOfLastReconciliation())
         m_html += QString("<td>%1</td>").arg(i18n("Last Reconciled"));
 
       m_html += "<td width=\"25%\" class=\"right\">";
       m_html += i18n("Current Balance");
       m_html += "</td>";
 
       //only show limit info if user chose to do so
       if (KMyMoneySettings::showLimitInfo()) {
         m_html += "<td width=\"40%\" class=\"right\">";
         m_html += i18n("To Minimum Balance / Maximum Credit");
         m_html += "</td>";
       }
       m_html += "</tr>";
 
       m_total = 0;
       QList<MyMoneyAccount>::const_iterator it_m;
       for (it_m = accounts.constBegin(); it_m != accounts.constEnd(); ++it_m) {
         m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         showAccountEntry(*it_m);
         m_html += "</tr>";
       }
       m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
       QString amount = m_total.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) m_html += "<td></td>";
       m_html += QString("<td class=\"right\"><b>%1</b></td>").arg(i18n("Total"));
       if (KMyMoneySettings::showCountOfUnmarkedTransactions()) m_html += "<td></td>";
       if (KMyMoneySettings::showCountOfClearedTransactions()) m_html += "<td></td>";
       if (KMyMoneySettings::showCountOfNotReconciledTransactions()) m_html += "<td></td>";
       if (KMyMoneySettings::showDateOfLastReconciliation()) m_html += "<td></td>";
       m_html += QString("<td class=\"right\"><b>%1</b></td></tr>").arg(showColoredAmount(amount, m_total.isNegative()));
       m_html += "</table></div></div>";
     }
   }
 
   void showFavoriteReports()
   {
     QList<MyMoneyReport> reports = MyMoneyFile::instance()->reportList();
 
     if (!reports.isEmpty()) {
       bool firstTime = 1;
       int row = 0;
       QList<MyMoneyReport>::const_iterator it_report = reports.constBegin();
       while (it_report != reports.constEnd()) {
         if ((*it_report).isFavorite()) {
           if (firstTime) {
             m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("Favorite Reports"));
             m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
             m_html += "<tr class=\"item\"><td class=\"left\" width=\"40%\">";
             m_html += i18n("Report");
             m_html += "</td><td width=\"60%\" class=\"left\">";
             m_html += i18n("Comment");
             m_html += "</td></tr>";
             firstTime = false;
           }
 
           m_html += QString("<tr class=\"row-%1\"><td>%2%3%4</td><td align=\"left\">%5</td></tr>")
                        .arg(row++ & 0x01 ? "even" : "odd")
                        .arg(link(VIEW_REPORTS, QString("?id=%1").arg((*it_report).id())))
                        .arg((*it_report).name())
                        .arg(linkend())
                        .arg((*it_report).comment());
         }
 
         ++it_report;
       }
       if (!firstTime)
         m_html += "</table></div></div>";
     }
   }
 
   void showForecast()
   {
     MyMoneyFile* file = MyMoneyFile::instance();
     QList<MyMoneyAccount> accList;
 
     //if forecast has not been executed yet, do it.
     if (!m_forecast.isForecastDone())
       doForecast();
 
     accList = m_forecast.accountList();
 
     if (accList.count() > 0) {
       // sort the accounts by name
       qStableSort(accList.begin(), accList.end(), accountNameLess);
       int i = 0;
 
       int colspan = 1;
       //get begin day
       int beginDay = QDate::currentDate().daysTo(m_forecast.beginForecastDate());
       //if begin day is today skip to next cycle
       if (beginDay == 0)
         beginDay = m_forecast.accountsCycle();
 
       // Now output header
       m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("%1 Day Forecast", m_forecast.forecastDays()));
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       m_html += "<tr class=\"item\"><td class=\"left\" width=\"40%\">";
       m_html += i18n("Account");
       m_html += "</td>";
       int colWidth = 55 / (m_forecast.forecastDays() / m_forecast.accountsCycle());
       for (i = 0; (i*m_forecast.accountsCycle() + beginDay) <= m_forecast.forecastDays(); ++i) {
         m_html += QString("<td width=\"%1%\" class=\"right\">").arg(colWidth);
 
         m_html += i18ncp("Forecast days", "%1 day", "%1 days", i * m_forecast.accountsCycle() + beginDay);
         m_html += "</td>";
         colspan++;
       }
       m_html += "</tr>";
 
       // Now output entries
       i = 0;
 
       QList<MyMoneyAccount>::ConstIterator it_account;
       for (it_account = accList.constBegin(); it_account != accList.constEnd(); ++it_account) {
         //MyMoneyAccount acc = (*it_n);
 
         m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         m_html += QString("<td width=\"40%\">") +
                      link(VIEW_LEDGER, QString("?id=%1").arg((*it_account).id())) + (*it_account).name() + linkend() + "</td>";
 
         int dropZero = -1; //account dropped below zero
         int dropMinimum = -1; //account dropped below minimum balance
         QString minimumBalance = (*it_account).value("minimumBalance");
         MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
         MyMoneySecurity currency;
         MyMoneyMoney forecastBalance;
 
         //change account to deep currency if account is an investment
         if ((*it_account).isInvest()) {
           MyMoneySecurity underSecurity = file->security((*it_account).currencyId());
           currency = file->security(underSecurity.tradingCurrency());
         } else {
           currency = file->security((*it_account).currencyId());
         }
 
         for (int f = beginDay; f <= m_forecast.forecastDays(); f += m_forecast.accountsCycle()) {
           forecastBalance = m_forecast.forecastBalance(*it_account, QDate::currentDate().addDays(f));
           QString amount;
           amount = MyMoneyUtils::formatMoney(forecastBalance, *it_account, currency);
           amount.replace(QChar(' '), "&nbsp;");
           m_html += QString("<td width=\"%1%\" align=\"right\">").arg(colWidth);
           m_html += QString("%1</td>").arg(showColoredAmount(amount, forecastBalance.isNegative()));
         }
 
         m_html += "</tr>";
 
         //Check if the account is going to be below zero or below the minimal balance in the forecast period
 
         //Check if the account is going to be below minimal balance
         dropMinimum = m_forecast.daysToMinimumBalance(*it_account);
 
         //Check if the account is going to be below zero in the future
         dropZero = m_forecast.daysToZeroBalance(*it_account);
 
 
         // spit out possible warnings
         QString msg;
 
         // if a minimum balance has been specified, an appropriate warning will
         // only be shown, if the drop below 0 is on a different day or not present
 
         if (dropMinimum != -1
             && !minBalance.isZero()
             && (dropMinimum < dropZero
                 || dropZero == -1)) {
           switch (dropMinimum) {
             case 0:
               msg = i18n("The balance of %1 is below the minimum balance %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(minBalance, *it_account, currency));
               msg = showColoredAmount(msg, true);
               break;
             default:
               msg = i18np("The balance of %2 will drop below the minimum balance %3 in %1 day.",
                           "The balance of %2 will drop below the minimum balance %3 in %1 days.",
                           dropMinimum - 1, (*it_account).name(), MyMoneyUtils::formatMoney(minBalance, *it_account, currency));
               msg = showColoredAmount(msg, true);
               break;
           }
 
           if (!msg.isEmpty()) {
             m_html += QString("<tr class=\"warning\" style=\"font-weight: normal;\" ><td colspan=%2 align=\"center\" >%1</td></tr>").arg(msg).arg(colspan);
           }
         }
         // a drop below zero is always shown
         msg.clear();
         switch (dropZero) {
           case -1:
             break;
           case 0:
             if ((*it_account).accountGroup() == Account::Type::Asset) {
               msg = i18n("The balance of %1 is below %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
               msg = showColoredAmount(msg, true);
               break;
             }
             if ((*it_account).accountGroup() == Account::Type::Liability) {
               msg = i18n("The balance of %1 is above %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
               break;
             }
             break;
           default:
             if ((*it_account).accountGroup() == Account::Type::Asset) {
               msg = i18np("The balance of %2 will drop below %3 in %1 day.",
                           "The balance of %2 will drop below %3 in %1 days.",
                           dropZero, (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
               msg = showColoredAmount(msg, true);
               break;
             }
             if ((*it_account).accountGroup() == Account::Type::Liability) {
               msg = i18np("The balance of %2 will raise above %3 in %1 day.",
                           "The balance of %2 will raise above %3 in %1 days.",
                           dropZero, (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
               break;
             }
         }
         if (!msg.isEmpty()) {
           m_html += QString("<tr class=\"warning\"><td colspan=%2 align=\"center\" ><b>%1</b></td></tr>").arg(msg).arg(colspan);
         }
       }
       m_html += "</table></div></div>";
 
     }
   }
 
   QString link(const QString& view, const QString& query, const QString& _title = QString()) const
   {
     QString titlePart;
     QString title(_title);
     if (!title.isEmpty())
       titlePart = QString(" title=\"%1\"").arg(title.replace(QLatin1Char(' '), "&nbsp;"));
 
     return QString("<a href=\"/%1%2\"%3>").arg(view, query, titlePart);
   }
 
   QString linkend() const
   {
     return QStringLiteral("</a>");
   }
 
   void showAssetsLiabilities()
   {
     QList<MyMoneyAccount> accounts;
     QList<MyMoneyAccount>::ConstIterator it;
     QList<MyMoneyAccount> assets;
     QList<MyMoneyAccount> liabilities;
     MyMoneyMoney netAssets;
     MyMoneyMoney netLiabilities;
     QString fontStart, fontEnd;
 
     MyMoneyFile* file = MyMoneyFile::instance();
     int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
     int i = 0;
 
     // get list of all accounts
     file->accountList(accounts);
 
     for (it = accounts.constBegin(); it != accounts.constEnd();) {
       if (!(*it).isClosed()) {
         switch ((*it).accountType()) {
             // group all assets into one list but make sure that investment accounts always show up
           case Account::Type::Investment:
             assets << *it;
             break;
 
           case Account::Type::Checkings:
           case Account::Type::Savings:
           case Account::Type::Cash:
           case Account::Type::Asset:
           case Account::Type::AssetLoan:
             // list account if it's the last in the hierarchy or has transactions in it
             if ((*it).accountList().isEmpty() || (file->transactionCount((*it).id()) > 0)) {
               assets << *it;
             }
             break;
 
             // group the liabilities into the other
           case Account::Type::CreditCard:
           case Account::Type::Liability:
           case Account::Type::Loan:
             // list account if it's the last in the hierarchy or has transactions in it
             if ((*it).accountList().isEmpty() || (file->transactionCount((*it).id()) > 0)) {
               liabilities << *it;
             }
             break;
 
           default:
             break;
         }
       }
       ++it;
     }
 
     //only do it if we have assets or liabilities account
     if (assets.count() > 0 || liabilities.count() > 0) {
       // sort the accounts by name
       qStableSort(assets.begin(), assets.end(), accountNameLess);
       qStableSort(liabilities.begin(), liabilities.end(), accountNameLess);
       QString statusHeader;
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) {
         QString pathStatusHeader;
         pathStatusHeader = QPixmapToDataUri(Icons::get(Icon::ViewOutbox).pixmap(QSize(16,16)));
         statusHeader = QString("<img src=\"%1\" border=\"0\">").arg(pathStatusHeader);
       }
 
       //print header
       m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Assets and Liabilities Summary") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
 
       //column titles
 
       m_html += "<tr class=\"item\">";
 
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) {
         m_html += "<td class=\"setcolor\">";
         m_html += statusHeader;
         m_html += "</td>";
       }
 
       m_html += "<td class=\"left\" width=\"30%\">";
       m_html += i18n("Asset Accounts");
       m_html += "</td>";
 
       if (KMyMoneySettings::showCountOfUnmarkedTransactions())
         m_html += "<td class=\"setcolor\">!M</td>";
 
       if (KMyMoneySettings::showCountOfClearedTransactions())
         m_html += "<td class=\"setcolor\">C</td>";
 
       if (KMyMoneySettings::showCountOfNotReconciledTransactions())
         m_html += "<td class=\"setcolor\">!R</td>";
 
       if (KMyMoneySettings::showDateOfLastReconciliation())
         m_html += "<td class=\"setcolor\">" + i18n("Last Reconciled") + "</td>";
 
       m_html += "<td width=\"15%\" class=\"right\">";
       m_html += i18n("Current Balance");
       m_html += "</td>";
 
       //intermediate row to separate both columns
       m_html += "<td width=\"10%\" class=\"setcolor\"></td>";
 
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) {
         m_html += "<td class=\"setcolor\">";
         m_html += statusHeader;
         m_html += "</td>";
       }
 
       m_html += "<td class=\"left\" width=\"30%\">";
       m_html += i18n("Liability Accounts");
       m_html += "</td>";
 
       if (KMyMoneySettings::showCountOfUnmarkedTransactions())
         m_html += "<td class=\"setcolor\">!M</td>";
 
       if (KMyMoneySettings::showCountOfClearedTransactions())
         m_html += "<td class=\"setcolor\">C</td>";
 
       if (KMyMoneySettings::showCountOfNotReconciledTransactions())
         m_html += "<td class=\"setcolor\">!R</td>";
 
       if (KMyMoneySettings::showDateOfLastReconciliation())
         m_html += "<td class=\"setcolor\">" + i18n("Last Reconciled") + "</td>";
 
       m_html += "<td width=\"15%\" class=\"right\">";
       m_html += i18n("Current Balance");
       m_html += "</td></tr>";
 
       QString placeHolder_Status, placeHolder_Counts;
       if (KMyMoneySettings::showBalanceStatusOfOnlineAccounts()) placeHolder_Status = "<td></td>";
       if (KMyMoneySettings::showCountOfUnmarkedTransactions()) placeHolder_Counts = "<td></td>";
       if (KMyMoneySettings::showCountOfClearedTransactions()) placeHolder_Counts += "<td></td>";
       if (KMyMoneySettings::showCountOfNotReconciledTransactions()) placeHolder_Counts += "<td></td>";
       if (KMyMoneySettings::showDateOfLastReconciliation()) placeHolder_Counts += "<td></td>";
 
       //get asset and liability accounts
       QList<MyMoneyAccount>::const_iterator asset_it = assets.constBegin();
       QList<MyMoneyAccount>::const_iterator liabilities_it = liabilities.constBegin();
       for (; asset_it != assets.constEnd() || liabilities_it != liabilities.constEnd();) {
         m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         //write an asset account if we still have any
         if (asset_it != assets.constEnd()) {
           MyMoneyMoney value;
           //investment accounts consolidate the balance of its subaccounts
           if ((*asset_it).accountType() == Account::Type::Investment) {
             value = investmentBalance(*asset_it);
           } else {
             value = MyMoneyFile::instance()->balance((*asset_it).id(), QDate::currentDate());
           }
 
           //calculate balance for foreign currency accounts
           if ((*asset_it).currencyId() != file->baseCurrency().id()) {
             ReportAccount repAcc = ReportAccount((*asset_it).id());
             MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
             MyMoneyMoney baseValue = value * curPrice;
             baseValue = baseValue.convert(10000);
             netAssets += baseValue;
           } else {
             netAssets += value;
           }
           //show the account without minimum balance
           showAccountEntry(*asset_it, value, MyMoneyMoney(), false);
           ++asset_it;
         } else {
           //write a white space if we don't
           m_html += QString("%1<td></td>%2<td></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
         }
 
         //leave the intermediate column empty
         m_html += "<td class=\"setcolor\"></td>";
 
         //write a liability account
         if (liabilities_it != liabilities.constEnd()) {
           MyMoneyMoney value;
           value = MyMoneyFile::instance()->balance((*liabilities_it).id(), QDate::currentDate());
           //calculate balance if foreign currency
           if ((*liabilities_it).currencyId() != file->baseCurrency().id()) {
             ReportAccount repAcc = ReportAccount((*liabilities_it).id());
             MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
             MyMoneyMoney baseValue = value * curPrice;
             baseValue = baseValue.convert(10000);
             netLiabilities += baseValue;
           } else {
             netLiabilities += value;
           }
           //show the account without minimum balance
           showAccountEntry(*liabilities_it, value, MyMoneyMoney(), false);
           ++liabilities_it;
         } else {
           //leave the space empty if we run out of liabilities
           m_html += QString("%1<td></td>%2<td></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
         }
         m_html += "</tr>";
       }
 
       //calculate net worth
       MyMoneyMoney netWorth = netAssets + netLiabilities;
 
       //format assets, liabilities and net worth
       QString amountAssets = netAssets.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       QString amountLiabilities = netLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       QString amountNetWorth = netWorth.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       amountAssets.replace(QChar(' '), "&nbsp;");
       amountLiabilities.replace(QChar(' '), "&nbsp;");
       amountNetWorth.replace(QChar(' '), "&nbsp;");
 
       m_html += QString("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(i++ & 0x01 ? "even" : "odd");
 
       //print total for assets
       m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Total Assets")).arg(placeHolder_Counts).arg(showColoredAmount(amountAssets, netAssets.isNegative()));
 
       //leave the intermediate column empty
       m_html += "<td class=\"setcolor\"></td>";
 
       //print total liabilities
       m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Total Liabilities")).arg(placeHolder_Counts).arg(showColoredAmount(amountLiabilities, netLiabilities.isNegative()));
       m_html += "</tr>";
 
       //print net worth
       m_html += QString("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(i++ & 0x01 ? "even" : "odd");
 
       m_html += QString("%1<td></td><td></td>%2<td class=\"setcolor\"></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
       m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Net Worth")).arg(placeHolder_Counts).arg(showColoredAmount(amountNetWorth, netWorth.isNegative()));
 
       m_html += "</tr>";
       m_html += "</table>";
       m_html += "</div></div>";
     }
   }
 
   void showBudget()
   {
     MyMoneyFile* file = MyMoneyFile::instance();
 
     if (file->countBudgets()) {
       int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
       bool isOverrun = false;
       int i = 0;
 
       //config report just like "Monthly Budgeted vs Actual
       MyMoneyReport reportCfg = MyMoneyReport(
                                   MyMoneyReport::eBudgetActual,
                                   MyMoneyReport::eMonths,
                                   TransactionFilter::Date::CurrentMonth,
                                   MyMoneyReport::eDetailAll,
                                   i18n("Monthly Budgeted vs. Actual"),
                                   i18n("Generated Report"));
 
       reportCfg.setBudget("Any", true);
 
       reports::PivotTable table(reportCfg);
 
       PivotGrid grid = table.grid();
 
       //div header
       m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Budget") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
 
       //display budget summary
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       m_html += "<tr class=\"itemtitle\">";
       m_html += "<td class=\"left\" colspan=\"3\">";
       m_html += i18n("Current Month Summary");
       m_html += "</td></tr>";
       m_html += "<tr class=\"item\">";
       m_html += "<td class=\"right\" width=\"50%\">";
       m_html += i18n("Budgeted");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"20%\">";
       m_html += i18n("Actual");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"20%\">";
       m_html += i18n("Difference");
       m_html += "</td></tr>";
 
       m_html += QString("<tr class=\"row-odd\">");
 
       MyMoneyMoney totalBudgetValue = grid.m_total[eBudget].m_total;
       MyMoneyMoney totalActualValue = grid.m_total[eActual].m_total;
       MyMoneyMoney totalBudgetDiffValue = grid.m_total[eBudgetDiff].m_total;
 
       QString totalBudgetAmount = totalBudgetValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       QString totalActualAmount = totalActualValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
       QString totalBudgetDiffAmount = totalBudgetDiffValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
       m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalBudgetAmount, totalBudgetValue.isNegative()));
       m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalActualAmount, totalActualValue.isNegative()));
       m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalBudgetDiffAmount, totalBudgetDiffValue.isNegative()));
       m_html += "</tr>";
       m_html += "</table>";
 
       //budget overrun
       m_html += "<div class=\"gap\">&nbsp;</div>\n";
       m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       m_html += "<tr class=\"itemtitle\">";
       m_html += "<td class=\"left\" colspan=\"4\">";
       m_html += i18n("Budget Overruns");
       m_html += "</td></tr>";
       m_html += "<tr class=\"item\">";
       m_html += "<td class=\"left\" width=\"30%\">";
       m_html += i18n("Account");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"20%\">";
       m_html += i18n("Budgeted");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"20%\">";
       m_html += i18n("Actual");
       m_html += "</td>";
       m_html += "<td class=\"right\" width=\"20%\">";
       m_html += i18n("Difference");
       m_html += "</td></tr>";
 
 
       PivotGrid::iterator it_outergroup = grid.begin();
       while (it_outergroup != grid.end()) {
         i = 0;
         PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
         while (it_innergroup != (*it_outergroup).end()) {
           PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
           while (it_row != (*it_innergroup).end()) {
             //column number is 1 because the report includes only current month
             if (it_row.value()[eBudgetDiff].value(1).isNegative()) {
               //get report account to get the name later
               ReportAccount rowname = it_row.key();
 
               //write the outergroup if it is the first row of outergroup being shown
               if (i == 0) {
                 m_html += "<tr style=\"font-weight:bold;\">";
                 m_html += QString("<td class=\"left\" colspan=\"4\">%1</td>").arg(MyMoneyAccount::accountTypeToString(rowname.accountType()));
                 m_html += "</tr>";
               }
               m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
 
               //get values from grid
               MyMoneyMoney actualValue = it_row.value()[eActual][1];
               MyMoneyMoney budgetValue = it_row.value()[eBudget][1];
               MyMoneyMoney budgetDiffValue = it_row.value()[eBudgetDiff][1];
 
               //format amounts
               QString actualAmount = actualValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
               QString budgetAmount = budgetValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
               QString budgetDiffAmount = budgetDiffValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
               //account name
               m_html += QString("<td>") + link(VIEW_LEDGER, QString("?id=%1").arg(rowname.id())) + rowname.name() + linkend() + "</td>";
 
               //show amounts
               m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(budgetAmount, budgetValue.isNegative()));
               m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(actualAmount, actualValue.isNegative()));
               m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(budgetDiffAmount, budgetDiffValue.isNegative()));
               m_html += "</tr>";
 
               //set the flag that there are overruns
               isOverrun = true;
             }
             ++it_row;
           }
           ++it_innergroup;
         }
         ++it_outergroup;
       }
 
       //if no negative differences are found, then inform that
       if (!isOverrun) {
         m_html += QString::fromLatin1("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(((i++ & 1) == 1) ? QLatin1String("even") : QLatin1String("odd"));
         m_html += QString::fromLatin1("<td class=\"center\" colspan=\"4\">%1</td>").arg(i18n("No Budget Categories have been overrun"));
         m_html += "</tr>";
       }
       m_html += "</table></div></div>";
     }
   }
 
   void showCashFlowSummary()
   {
     MyMoneyTransactionFilter filter;
     MyMoneyMoney incomeValue;
     MyMoneyMoney expenseValue;
 
     MyMoneyFile* file = MyMoneyFile::instance();
     int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
 
     //set start and end of month dates
     QDate startOfMonth = QDate(QDate::currentDate().year(), QDate::currentDate().month(), 1);
     QDate endOfMonth = QDate(QDate::currentDate().year(), QDate::currentDate().month(), QDate::currentDate().daysInMonth());
 
     //Add total income and expenses for this month
     //get transactions for current month
     filter.setDateFilter(startOfMonth, endOfMonth);
     filter.setReportAllSplits(false);
 
     QList<MyMoneyTransaction> transactions = file->transactionList(filter);
     //if no transaction then skip and print total in zero
     if (transactions.size() > 0) {
 
       //get all transactions for this month
       foreach (const auto transaction, transactions) {
         //get the splits for each transaction
         foreach (const auto split, transaction.splits()) {
           if (!split.shares().isZero()) {
             ReportAccount repSplitAcc = ReportAccount(split.accountId());
 
             //only add if it is an income or expense
             if (repSplitAcc.isIncomeExpense()) {
               MyMoneyMoney value;
 
               //convert to base currency if necessary
               if (repSplitAcc.currencyId() != file->baseCurrency().id()) {
                 MyMoneyMoney curPrice = repSplitAcc.baseCurrencyPrice(transaction.postDate());
                 value = (split.shares() * MyMoneyMoney::MINUS_ONE) * curPrice;
                 value = value.convert(10000);
               } else {
                 value = (split.shares() * MyMoneyMoney::MINUS_ONE);
               }
 
               //store depending on account type
               if (repSplitAcc.accountType() == Account::Type::Income) {
                 incomeValue += value;
               } else {
                 expenseValue += value;
               }
             }
           }
         }
       }
     }
 
     //format income and expenses
     QString amountIncome = incomeValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountExpense = expenseValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     amountIncome.replace(QChar(' '), "&nbsp;");
     amountExpense.replace(QChar(' '), "&nbsp;");
 
     //calculate schedules
 
     //Add all schedules for this month
     MyMoneyMoney scheduledIncome;
     MyMoneyMoney scheduledExpense;
     MyMoneyMoney scheduledLiquidTransfer;
     MyMoneyMoney scheduledOtherTransfer;
 
     //get overdues and schedules until the end of this month
     QList<MyMoneySchedule> schedule = file->scheduleList(QString(), Schedule::Type::Any,
                                       Schedule::Occurrence::Any,
                                       Schedule::PaymentType::Any,
                                       QDate(),
                                       endOfMonth, false);
 
     //Remove the finished schedules
     QList<MyMoneySchedule>::Iterator finished_it;
     for (finished_it = schedule.begin(); finished_it != schedule.end();) {
       if ((*finished_it).isFinished()) {
         finished_it = schedule.erase(finished_it);
         continue;
       }
       ++finished_it;
     }
 
     //add income and expenses
     QList<MyMoneySchedule>::Iterator sched_it;
     for (sched_it = schedule.begin(); sched_it != schedule.end();) {
       QDate nextDate = (*sched_it).nextDueDate();
       int cnt = 0;
 
       while (nextDate.isValid() && nextDate <= endOfMonth) {
         ++cnt;
         nextDate = (*sched_it).nextPayment(nextDate);
         // for single occurrence nextDate will not change, so we
         // better get out of here.
         if ((*sched_it).occurrence() == Schedule::Occurrence::Once)
           break;
       }
 
       MyMoneyAccount acc = (*sched_it).account();
       if (!acc.id().isEmpty()) {
         MyMoneyTransaction transaction = (*sched_it).transaction();
         // only show the entry, if it is still active
 
         MyMoneySplit sp = transaction.splitByAccount(acc.id(), true);
 
         // take care of the autoCalc stuff
         if ((*sched_it).type() == Schedule::Type::LoanPayment) {
           nextDate = (*sched_it).nextPayment((*sched_it).lastPayment());
 
           //make sure we have all 'starting balances' so that the autocalc works
           QMap<QString, MyMoneyMoney> balanceMap;
 
           foreach (const auto split, transaction.splits()) {
             acc = file->account(split.accountId());
             // collect all overdues on the first day
             QDate schedDate = nextDate;
             if (QDate::currentDate() >= nextDate)
               schedDate = QDate::currentDate().addDays(1);
 
             balanceMap[acc.id()] += file->balance(acc.id(), QDate::currentDate());
           }
           KMyMoneyUtils::calculateAutoLoan(*sched_it, transaction, balanceMap);
         }
 
         //go through the splits and assign to liquid or other transfers
         const QList<MyMoneySplit> splits = transaction.splits();
         QList<MyMoneySplit>::const_iterator split_it;
         for (split_it = splits.constBegin(); split_it != splits.constEnd(); ++split_it) {
           if ((*split_it).accountId() != acc.id()) {
             ReportAccount repSplitAcc = ReportAccount((*split_it).accountId());
 
             //get the shares and multiply by the quantity of occurrences in the period
             MyMoneyMoney value = (*split_it).shares() * cnt;
 
             //convert to foreign currency if needed
             if (repSplitAcc.currencyId() != file->baseCurrency().id()) {
               MyMoneyMoney curPrice = repSplitAcc.baseCurrencyPrice(QDate::currentDate());
               value = value * curPrice;
               value = value.convert(10000);
             }
 
             if ((repSplitAcc.isLiquidLiability()
                  || repSplitAcc.isLiquidAsset())
                 && acc.accountGroup() != repSplitAcc.accountGroup()) {
               scheduledLiquidTransfer += value;
             } else if (repSplitAcc.isAssetLiability()
                        && !repSplitAcc.isLiquidLiability()
                        && !repSplitAcc.isLiquidAsset()) {
               scheduledOtherTransfer += value;
             } else if (repSplitAcc.isIncomeExpense()) {
               //income and expenses are stored as negative values
               if (repSplitAcc.accountType() == Account::Type::Income)
                 scheduledIncome -= value;
               if (repSplitAcc.accountType() == Account::Type::Expense)
                 scheduledExpense -= value;
             }
           }
         }
       }
       ++sched_it;
     }
 
     //format the currency strings
     QString amountScheduledIncome = scheduledIncome.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountScheduledExpense = scheduledExpense.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountScheduledLiquidTransfer = scheduledLiquidTransfer.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountScheduledOtherTransfer = scheduledOtherTransfer.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
     amountScheduledIncome.replace(QChar(' '), "&nbsp;");
     amountScheduledExpense.replace(QChar(' '), "&nbsp;");
     amountScheduledLiquidTransfer.replace(QChar(' '), "&nbsp;");
     amountScheduledOtherTransfer.replace(QChar(' '), "&nbsp;");
 
     //get liquid assets and liabilities
     QList<MyMoneyAccount> accounts;
     QList<MyMoneyAccount>::const_iterator account_it;
     MyMoneyMoney liquidAssets;
     MyMoneyMoney liquidLiabilities;
 
     // get list of all accounts
     file->accountList(accounts);
     for (account_it = accounts.constBegin(); account_it != accounts.constEnd();) {
       if (!(*account_it).isClosed()) {
         switch ((*account_it).accountType()) {
             //group all assets into one list
           case Account::Type::Checkings:
           case Account::Type::Savings:
           case Account::Type::Cash: {
               MyMoneyMoney value = MyMoneyFile::instance()->balance((*account_it).id(), QDate::currentDate());
               //calculate balance for foreign currency accounts
               if ((*account_it).currencyId() != file->baseCurrency().id()) {
                 ReportAccount repAcc = ReportAccount((*account_it).id());
                 MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
                 MyMoneyMoney baseValue = value * curPrice;
                 liquidAssets += baseValue;
                 liquidAssets = liquidAssets.convert(10000);
               } else {
                 liquidAssets += value;
               }
               break;
             }
             //group the liabilities into the other
           case Account::Type::CreditCard: {
               MyMoneyMoney value;
               value = MyMoneyFile::instance()->balance((*account_it).id(), QDate::currentDate());
               //calculate balance if foreign currency
               if ((*account_it).currencyId() != file->baseCurrency().id()) {
                 ReportAccount repAcc = ReportAccount((*account_it).id());
                 MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
                 MyMoneyMoney baseValue = value * curPrice;
                 liquidLiabilities += baseValue;
                 liquidLiabilities = liquidLiabilities.convert(10000);
               } else {
                 liquidLiabilities += value;
               }
               break;
             }
           default:
             break;
         }
       }
       ++account_it;
     }
     //calculate net worth
     MyMoneyMoney liquidWorth = liquidAssets + liquidLiabilities;
 
     //format assets, liabilities and net worth
     QString amountLiquidAssets = liquidAssets.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountLiquidLiabilities = liquidLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountLiquidWorth = liquidWorth.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     amountLiquidAssets.replace(QChar(' '), "&nbsp;");
     amountLiquidLiabilities.replace(QChar(' '), "&nbsp;");
     amountLiquidWorth.replace(QChar(' '), "&nbsp;");
 
     //show the summary
     m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Cash Flow Summary") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
 
     //print header
     m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     //income and expense title
     m_html += "<tr class=\"itemtitle\">";
     m_html += "<td class=\"left\" colspan=\"4\">";
     m_html += i18n("Income and Expenses of Current Month");
     m_html += "</td></tr>";
     //column titles
     m_html += "<tr class=\"item\">";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Income");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Scheduled Income");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Expenses");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Scheduled Expenses");
     m_html += "</td>";
     m_html += "</tr>";
 
     //add row with banding
     m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
 
     //print current income
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountIncome, incomeValue.isNegative()));
 
     //print the scheduled income
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledIncome, scheduledIncome.isNegative()));
 
     //print current expenses
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpense,  expenseValue.isNegative()));
 
     //print the scheduled expenses
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledExpense,  scheduledExpense.isNegative()));
     m_html += "</tr>";
 
     m_html += "</table>";
 
     //print header of assets and liabilities
     m_html += "<div class=\"gap\">&nbsp;</div>\n";
     m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     //assets and liabilities title
     m_html += "<tr class=\"itemtitle\">";
     m_html += "<td class=\"left\" colspan=\"4\">";
     m_html += i18n("Liquid Assets and Liabilities");
     m_html += "</td></tr>";
     //column titles
     m_html += "<tr class=\"item\">";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Liquid Assets");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Transfers to Liquid Liabilities");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Liquid Liabilities");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Other Transfers");
     m_html += "</td>";
     m_html += "</tr>";
 
     //add row with banding
     m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
 
     //print current liquid assets
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountLiquidAssets, liquidAssets.isNegative()));
 
     //print the scheduled transfers
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledLiquidTransfer, scheduledLiquidTransfer.isNegative()));
 
     //print current liabilities
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountLiquidLiabilities,  liquidLiabilities.isNegative()));
 
     //print the scheduled transfers
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledOtherTransfer, scheduledOtherTransfer.isNegative()));
 
 
     m_html += "</tr>";
 
     m_html += "</table>";
 
     //final conclusion
     MyMoneyMoney profitValue = incomeValue + expenseValue + scheduledIncome + scheduledExpense;
     MyMoneyMoney expectedAsset = liquidAssets + scheduledIncome + scheduledExpense + scheduledLiquidTransfer + scheduledOtherTransfer;
     MyMoneyMoney expectedLiabilities = liquidLiabilities + scheduledLiquidTransfer;
 
     QString amountExpectedAsset = expectedAsset.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountExpectedLiabilities = expectedLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountProfit = profitValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     amountProfit.replace(QChar(' '), "&nbsp;");
     amountExpectedAsset.replace(QChar(' '), "&nbsp;");
     amountExpectedLiabilities.replace(QChar(' '), "&nbsp;");
 
 
 
     //print header of cash flow status
     m_html += "<div class=\"gap\">&nbsp;</div>\n";
     m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     //income and expense title
     m_html += "<tr class=\"itemtitle\">";
     m_html += "<td class=\"left\" colspan=\"4\">";
     m_html += i18n("Cash Flow Status");
     m_html += "</td></tr>";
     //column titles
     m_html += "<tr class=\"item\">";
     m_html += "<td>&nbsp;</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Expected Liquid Assets");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Expected Liquid Liabilities");
     m_html += "</td>";
     m_html += "<td width=\"25%\" class=\"center\">";
     m_html += i18n("Expected Profit/Loss");
     m_html += "</td>";
     m_html += "</tr>";
 
     //add row with banding
     m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
     m_html += "<td>&nbsp;</td>";
 
     //print expected assets
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpectedAsset, expectedAsset.isNegative()));
 
     //print expected liabilities
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpectedLiabilities, expectedLiabilities.isNegative()));
 
     //print expected profit
     m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountProfit, profitValue.isNegative()));
 
     m_html += "</tr>";
     m_html += "</table>";
     m_html += "</div></div>";
   }
 
 
   KHomeView     *q_ptr;
 
   /**
    * daily balances of an account
    */
   typedef QMap<QDate, MyMoneyMoney> dailyBalances;
 
   #ifdef ENABLE_WEBENGINE
   QWebEngineView   *m_view;
   #else
   KWebView         *m_view;
   #endif
 
   QString           m_html;
   bool              m_showAllSchedules;
   bool              m_needLoad;
   MyMoneyForecast   m_forecast;
   MyMoneyMoney      m_total;
   /**
     * Hold the last valid size of the net worth graph
     * for the times when the needed size can't be computed.
     */
   QSize           m_netWorthGraphLastValidSize;
 
   /**
     * daily forecast balance of accounts
     */
   QMap<QString, dailyBalances> m_accountList;
   QPrinter *m_currentPrinter;
 };
 
 #endif
diff --git a/kmymoney/views/kinstitutionsview.cpp b/kmymoney/views/kinstitutionsview.cpp
index 4281f621b..848c6a828 100644
--- a/kmymoney/views/kinstitutionsview.cpp
+++ b/kmymoney/views/kinstitutionsview.cpp
@@ -1,238 +1,238 @@
 /***************************************************************************
                           kinstitutionsview.cpp
                              -------------------
     copyright            : (C) 2007 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kinstitutionsview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QMenu>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneysettings.h"
 #include "mymoneyexception.h"
 #include "knewbankdlg.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 KInstitutionsView::KInstitutionsView(QWidget *parent) :
     KMyMoneyAccountsViewBase(*new KInstitutionsViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::NewInstitution],    &QAction::triggered, this, &KInstitutionsView::slotNewInstitution);
   connect(pActions[eMenu::Action::EditInstitution],   &QAction::triggered, this, &KInstitutionsView::slotEditInstitution);
   connect(pActions[eMenu::Action::DeleteInstitution], &QAction::triggered, this, &KInstitutionsView::slotDeleteInstitution);
 }
 
 KInstitutionsView::~KInstitutionsView()
 {
 }
 
 void KInstitutionsView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KInstitutionsView);
         QTimer::singleShot(0, d->ui->m_accountTree, SLOT(setFocus()));
       }
       break;
 
     case eView::Action::EditInstitution:
       slotEditInstitution();
       break;
 
     default:
       break;
   }
 }
 
 void KInstitutionsView::refresh()
 {
   Q_D(KInstitutionsView);
   if (!isVisible()) {
     d->m_needsRefresh = true;
     return;
   }
   d->m_needsRefresh = false;
 
   d->m_proxyModel->invalidate();
   d->m_proxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
   d->m_proxyModel->setHideClosedAccounts(KMyMoneySettings::hideClosedAccounts());
 }
 
 void KInstitutionsView::showEvent(QShowEvent * event)
 {
   Q_D(KInstitutionsView);
   if (!d->m_proxyModel)
     d->init();
 
   emit customActionRequested(View::Institutions, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KInstitutionsView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KInstitutionsView);
   if (typeid(obj) != typeid(MyMoneyInstitution) ||
       (obj.id().isEmpty() && d->m_currentInstitution.id().isEmpty())) // do not disable actions that were already disabled
     return;
 
   const auto& inst = static_cast<const MyMoneyInstitution&>(obj);
 
   pActions[eMenu::Action::NewInstitution]->setEnabled(true);
   auto b = inst.id().isEmpty() ? false : true;
   pActions[eMenu::Action::EditInstitution]->setEnabled(b);
   pActions[eMenu::Action::DeleteInstitution]->setEnabled(b && !MyMoneyFile::instance()->isReferenced(inst));
   d->m_currentInstitution = inst;
 }
 
 void KInstitutionsView::slotNetWorthChanged(const MyMoneyMoney &netWorth)
 {
   Q_D(KInstitutionsView);
   d->netBalProChanged(netWorth, d->ui->m_totalProfitsLabel, View::Institutions);
 }
 
 void KInstitutionsView::slotNewInstitution()
 {
   Q_D(KInstitutionsView);
   d->m_currentInstitution.clearId();
   QPointer<KNewBankDlg> dlg = new KNewBankDlg(d->m_currentInstitution);
   if (dlg->exec() == QDialog::Accepted && dlg != 0) {
     d->m_currentInstitution = dlg->institution();
 
     const auto file = MyMoneyFile::instance();
     MyMoneyFileTransaction ft;
 
     try {
       file->addInstitution(d->m_currentInstitution);
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Cannot add institution: %1", e.what()));
+      KMessageBox::information(this, i18n("Cannot add institution: %1", QString::fromLatin1(e.what())));
     }
   }
   delete dlg;
 }
 
 void KInstitutionsView::slotShowInstitutionsMenu(const MyMoneyInstitution& inst)
 {
   Q_UNUSED(inst);
   pMenus[eMenu::Menu::Institution]->exec(QCursor::pos());
 }
 
 void KInstitutionsView::slotEditInstitution()
 {
   Q_D(KInstitutionsView);
 
   // make sure the selected object has an id
   if (d->m_currentInstitution.id().isEmpty())
     return;
 
   try {
     const auto file = MyMoneyFile::instance();
 
     //grab a pointer to the view, regardless of it being a account or institution view.
     auto institution = file->institution(d->m_currentInstitution.id());
 
     // bankSuccess is not checked anymore because d->m_file->institution will throw anyway
     QPointer<KNewBankDlg> dlg = new KNewBankDlg(institution);
     if (dlg->exec() == QDialog::Accepted && dlg != 0) {
       MyMoneyFileTransaction ft;
       try {
         file->modifyInstitution(dlg->institution());
         ft.commit();
         emit selectByObject(dlg->institution(), eView::Intent::None);
       } catch (const MyMoneyException &e) {
-        KMessageBox::information(this, i18n("Unable to store institution: %1", e.what()));
+        KMessageBox::information(this, i18n("Unable to store institution: %1", QString::fromLatin1(e.what())));
       }
     }
     delete dlg;
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::information(this, i18n("Unable to edit institution: %1", e.what()));
+    KMessageBox::information(this, i18n("Unable to edit institution: %1", QString::fromLatin1(e.what())));
   }
 }
 
 void KInstitutionsView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::OpenContextMenu:
       slotShowInstitutionsMenu(static_cast<const MyMoneyInstitution&>(obj));
       break;
 
     default:
       break;
   }
 }
 
 void KInstitutionsView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   Q_D(KInstitutionsView);
   switch (intent) {
     case eView::Intent::UpdateNetWorth:
       if (variant.count() == 1 && d->m_proxyModel)
         slotNetWorthChanged(variant.first().value<MyMoneyMoney>());
       break;
     default:
       break;
   }
 }
 
 void KInstitutionsView::slotDeleteInstitution()
 {
   Q_D(KInstitutionsView);
   const auto file = MyMoneyFile::instance();
   try {
     auto institution = file->institution(d->m_currentInstitution.id());
     if ((KMessageBox::questionYesNo(this, i18n("<p>Do you really want to delete the institution <b>%1</b>?</p>", institution.name()))) == KMessageBox::No)
       return;
     MyMoneyFileTransaction ft;
 
     try {
       file->removeInstitution(institution);
       emit selectByObject(MyMoneyInstitution(), eView::Intent::None);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to delete institution: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to delete institution: %1", QString::fromLatin1(e.what())));
     }
   } catch (const MyMoneyException &e) {
-    KMessageBox::information(this, i18n("Unable to delete institution: %1", e.what()));
+    KMessageBox::information(this, i18n("Unable to delete institution: %1", QString::fromLatin1(e.what())));
   }
 }
diff --git a/kmymoney/views/kinvestmentview.cpp b/kmymoney/views/kinvestmentview.cpp
index 988c7bca5..c622a2409 100644
--- a/kmymoney/views/kinvestmentview.cpp
+++ b/kmymoney/views/kinvestmentview.cpp
@@ -1,371 +1,371 @@
 /***************************************************************************
                           kinvestmentview.cpp  -  description
                              -------------------
     begin                : Mon Mar 12 2007
     copyright            : (C) 2007 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kinvestmentview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QAction>
 #include <QMenu>
 #include <QBitArray>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneymoney.h"
 #include "mymoneyprice.h"
 #include "kequitypriceupdatedlg.h"
 #include "kcurrencycalculator.h"
 #include "knewinvestmentwizard.h"
 #include "kmymoneyutils.h"
 #include "menuenums.h"
 #include "storageenums.h"
 
 using namespace Icons;
 
 KInvestmentView::KInvestmentView(QWidget *parent) :
   KMyMoneyViewBase(*new KInvestmentViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::NewInvestment],       &QAction::triggered, this, &KInvestmentView::slotNewInvestment);
   connect(pActions[eMenu::Action::EditInvestment],      &QAction::triggered, this, &KInvestmentView::slotEditInvestment);
   connect(pActions[eMenu::Action::DeleteInvestment],    &QAction::triggered, this, &KInvestmentView::slotDeleteInvestment);
   connect(pActions[eMenu::Action::UpdatePriceOnline],   &QAction::triggered, this, &KInvestmentView::slotUpdatePriceOnline);
   connect(pActions[eMenu::Action::UpdatePriceManually], &QAction::triggered, this, &KInvestmentView::slotUpdatePriceManually);
 }
 
 KInvestmentView::~KInvestmentView()
 {
 }
 
 void KInvestmentView::setDefaultFocus()
 {
   Q_D(KInvestmentView);
   auto tab = static_cast<eView::Investment::Tab>(d->ui->m_tab->currentIndex());
 
   switch (tab) {
   case eView::Investment::Tab::Equities:
       QTimer::singleShot(0, d->ui->m_equitiesTree, SLOT(setFocus()));
       break;
     case eView::Investment::Tab::Securities:
       QTimer::singleShot(0, d->ui->m_securitiesTree, SLOT(setFocus()));
       break;
   }
 }
 
 void KInvestmentView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       setDefaultFocus();
       break;
 
     default:
       break;
   }
 }
 
 void KInvestmentView::refresh()
 {
   Q_D(KInvestmentView);
   d->m_needReload[eView::Investment::Tab::Equities] = d->m_needReload[eView::Investment::Tab::Securities] = true;
   if (isVisible())
     slotLoadTab(d->ui->m_tab->currentIndex());
 }
 
 void KInvestmentView::showEvent(QShowEvent* event)
 {
   Q_D(KInvestmentView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Investments, eView::Action::AboutToShow);
 
   d->m_needReload[eView::Investment::Tab::Equities] = true;  // ensure tree view will be reloaded after selecting account in ledger view
   if (d->m_needReload[eView::Investment::Tab::Equities] == true ||
       d->m_needReload[eView::Investment::Tab::Securities] == true)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KInvestmentView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KInvestmentView);
   if (typeid(obj) != typeid(MyMoneyAccount) &&
       (obj.id().isEmpty() && d->m_currentEquity.id().isEmpty())) // do not disable actions that were already disabled)))
     return;
 
   const auto& acc = static_cast<const MyMoneyAccount&>(obj);
 
   const auto file = MyMoneyFile::instance();
   auto b = acc.accountType() == eMyMoney::Account::Type::Investment ? true : false;
   if (isVisible() && !d->m_idInvAcc.isEmpty())
     b = true;
 
   pActions[eMenu::Action::NewInvestment]->setEnabled(b);
 
   b = acc.isInvest() ? true : false;
   pActions[eMenu::Action::EditInvestment]->setEnabled(b);
   pActions[eMenu::Action::DeleteInvestment]->setEnabled(b && !file->isReferenced(acc));
   pActions[eMenu::Action::UpdatePriceManually]->setEnabled(b);
   pActions[eMenu::Action::UpdatePriceOnline]->setEnabled(b && !file->security(acc.currencyId()).value("kmm-online-source").isEmpty());
 
   switch (acc.accountType()) {
     case eMyMoney::Account::Type::Investment:
     case eMyMoney::Account::Type::Stock:
       d->m_currentEquity = acc;
       break;
     default:
       d->m_currentEquity = MyMoneyAccount();
       break;
   }
 }
 
 void KInvestmentView::slotLoadTab(int index)
 {
   Q_D(KInvestmentView);
   auto tab = static_cast<eView::Investment::Tab>(index);
   if (d->m_needReload[tab]) {
     switch (tab) {
       case eView::Investment::Tab::Equities:
         d->loadInvestmentTab();
         break;
       case eView::Investment::Tab::Securities:
         d->loadSecuritiesTab();
         break;
     }
     d->m_needReload[tab] = false;
   }
 }
 
 void KInvestmentView::slotEquitySelected(const QModelIndex &current, const QModelIndex &previous)
 {
   Q_D(KInvestmentView);
   Q_UNUSED(current);
   Q_UNUSED(previous);
   emit selectByObject(d->currentEquity(), eView::Intent::None);
 }
 
 void KInvestmentView::slotSecuritySelected(const QModelIndex &current, const QModelIndex &previous)
 {
   Q_D(KInvestmentView);
   Q_UNUSED(current);
   Q_UNUSED(previous);
   const auto sec = d->currentSecurity();
   if (!sec.id().isEmpty()) {
     QBitArray skip((int)eStorage::Reference::Count);
     skip.fill(false);
     skip.setBit((int)eStorage::Reference::Price);
     d->ui->m_editSecurityButton->setEnabled(true);
     d->ui->m_deleteSecurityButton->setEnabled(!MyMoneyFile::instance()->isReferenced(sec, skip));
   } else {
     d->ui->m_editSecurityButton->setEnabled(false);
     d->ui->m_deleteSecurityButton->setEnabled(false);
   }
 }
 
 void KInvestmentView::slotSelectAccount(const QString &id)
 {
   Q_D(KInvestmentView);
   if (!id.isEmpty()) {
     d->m_idInvAcc = id;
     if (isVisible()) {
       d->ui->m_accountComboBox->setSelected(id);
       slotSecuritySelected(QModelIndex(), QModelIndex());
       slotEquitySelected(QModelIndex(), QModelIndex());
     }
   }
 }
 
 void KInvestmentView::slotSelectAccount(const MyMoneyObject &obj)
 {
   if (typeid(obj) != typeid(MyMoneyAccount))
      return;
   const auto acc = dynamic_cast<const MyMoneyAccount &>(obj);
 
   if (acc.accountType() == eMyMoney::Account::Type::Investment)
     slotSelectAccount(acc.id());
 }
 
 void KInvestmentView::slotLoadAccount(const QString &id)
 {
   Q_D(KInvestmentView);
   const auto indexList = d->m_equitiesProxyModel->match(d->m_equitiesProxyModel->index(0,0), EquitiesModel::InvestmentID, id, 1,
                                                    Qt::MatchFlags(Qt::MatchExactly | Qt::MatchRecursive | Qt::MatchWrap));
 
   const auto acc = MyMoneyFile::instance()->account(id);
   if (!indexList.isEmpty()) {
     d->ui->m_equitiesTree->setRootIndex(indexList.first());
     d->m_idInvAcc = id;
     if (isVisible())
       emit selectByObject(acc, eView::Intent::SynchronizeAccountInLedgersView);
   }
   updateActions(acc);
 }
 
 void KInvestmentView::slotInvestmentMenuRequested(const QPoint&)
 {
   Q_D(KInvestmentView);
   MyMoneyAccount acc;
   auto treeItem = d->ui->m_equitiesTree->currentIndex();
   if (treeItem.isValid()) {
     auto mdlItem = d->m_equitiesProxyModel->index(treeItem.row(), EquitiesModel::Equity, treeItem.parent());
     acc = MyMoneyFile::instance()->account(mdlItem.data(EquitiesModel::EquityID).toString());
   }
   slotShowInvestmentMenu(acc);
 }
 
 void KInvestmentView::slotShowInvestmentMenu(const MyMoneyAccount& acc)
 {
   Q_UNUSED(acc);
   pMenus[eMenu::Menu::Investment]->exec(QCursor::pos());
 }
 
 void KInvestmentView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::SynchronizeAccountInInvestmentView:
       if (KMyMoneySettings::syncLedgerInvestment())
         slotSelectAccount(obj);
       break;
 
     case eView::Intent::OpenContextMenu:
       slotShowInvestmentMenu(static_cast<const MyMoneyAccount&>(obj));
       break;
 
     default:
       break;
   }
 }
 
 void KInvestmentView::slotNewInvestment()
 {
   Q_D(KInvestmentView);
   if (!isVisible())
     KNewInvestmentWizard::newInvestment(d->m_currentEquity);
   else
     KNewInvestmentWizard::newInvestment(MyMoneyFile::instance()->account(d->m_idInvAcc));
 }
 
 void KInvestmentView::slotEditInvestment()
 {
   Q_D(KInvestmentView);
   KNewInvestmentWizard::editInvestment(d->m_currentEquity);
 }
 
 void KInvestmentView::slotDeleteInvestment()
 {
   Q_D(KInvestmentView);
   if (KMessageBox::questionYesNo(this,
                                  i18n("<p>Do you really want to delete the investment <b>%1</b>?</p>", d->m_currentEquity.name()),
                                  i18n("Delete investment"),
                                  KStandardGuiItem::yes(), KStandardGuiItem::no(),
                                  "DeleteInvestment") == KMessageBox::Yes) {
     auto file = MyMoneyFile::instance();
     MyMoneyFileTransaction ft;
     try {
 //      d->m_selectedAccount = MyMoneyAccount(); // CAUTION: deleting equity from investments view needs this, if ID of the equity to be deleted is the smallest from all
       file->removeAccount(d->m_currentEquity);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to delete investment: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to delete investment: %1", QString::fromLatin1(e.what())));
     }
   } else {
     // we should not keep the 'no' setting because that can confuse people like
     // I have seen in some usability tests. So we just delete it right away.
     KSharedConfigPtr kconfig = KSharedConfig::openConfig();
     if (kconfig) {
       kconfig->group(QLatin1String("Notification Messages")).deleteEntry(QLatin1String("DeleteInvestment"));
     }
   }
 }
 
 void KInvestmentView::slotUpdatePriceOnline()
 {
   Q_D(KInvestmentView);
   if (!d->m_currentEquity.id().isEmpty()) {
     QPointer<KEquityPriceUpdateDlg> dlg = new KEquityPriceUpdateDlg(0, d->m_currentEquity.currencyId());
     if (dlg->exec() == QDialog::Accepted && dlg != nullptr)
       dlg->storePrices();
     delete dlg;
   }
 }
 
 void KInvestmentView::slotUpdatePriceManually()
 {
   Q_D(KInvestmentView);
   if (!d->m_currentEquity.id().isEmpty()) {
     try {
       auto security = MyMoneyFile::instance()->security(d->m_currentEquity.currencyId());
       auto currency = MyMoneyFile::instance()->security(security.tradingCurrency());
       const auto& price = MyMoneyFile::instance()->price(security.id(), currency.id());
 
       QPointer<KCurrencyCalculator> calc =
         new KCurrencyCalculator(security, currency, MyMoneyMoney::ONE,
                                 price.rate(currency.id()), price.date(),
                                 MyMoneyMoney::precToDenom(security.pricePrecision()));
       calc->setupPriceEditor();
 
       // The dialog takes care of adding the price if necessary
       calc->exec();
       delete calc;
     } catch (const MyMoneyException &e) {
-      qDebug("Error in price update: %s", qPrintable(e.what()));
+      qDebug("Error in price update: %s", e.what());
     }
   }
 }
 
 void KInvestmentView::slotEditSecurity()
 {
   Q_D(KInvestmentView);
   auto sec = d->currentSecurity();
 
   if (!sec.id().isEmpty()) {
     QPointer<KNewInvestmentWizard> dlg = new KNewInvestmentWizard(sec, this);
     dlg->setObjectName("KNewInvestmentWizard");
     if (dlg->exec() == QDialog::Accepted)
       dlg->createObjects(QString());
     delete dlg;
   }
 }
 
 void KInvestmentView::slotDeleteSecurity()
 {
   Q_D(KInvestmentView);
   auto sec = d->currentSecurity();
   if (!sec.id().isEmpty())
     KMyMoneyUtils::deleteSecurity(sec, this);
 }
diff --git a/kmymoney/views/kmymoneyview.cpp b/kmymoney/views/kmymoneyview.cpp
index e114f5e47..e77a63d71 100644
--- a/kmymoney/views/kmymoneyview.cpp
+++ b/kmymoney/views/kmymoneyview.cpp
@@ -1,857 +1,857 @@
 /***************************************************************************
                           kmymoneyview.cpp
                              -------------------
     copyright            : (C) 2000-2001 by Michael Edwardes <mte@users.sourceforge.net>
                                2004 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017, 2018 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 <config-kmymoney.h>
 #include "kmymoneyview.h"
 
 // ----------------------------------------------------------------------------
 // Std Includes
 
 #include <memory>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFile>
 #include <QRegExp>
 #include <QLayout>
 #include <QList>
 #include <QByteArray>
 #include <QUrl>
 #include <QIcon>
 #include <QTemporaryFile>
 #include <QUrlQuery>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KTitleWidget>
 #include <KCompressionDevice>
 #include <KSharedConfig>
 #include <KBackup>
 #include <KActionCollection>
 #include <KIO/StoredTransferJob>
 #include <KJobWidgets>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #ifdef ENABLE_UNFINISHEDFEATURES
 #include "simpleledgerview.h"
 #endif
 
 #include "kmymoneysettings.h"
 #include "kmymoneytitlelabel.h"
 #include <libkgpgfile/kgpgfile.h>
 #include "kcurrencyeditdlg.h"
 #include "mymoneystoragemgr.h"
 #include "mymoneystoragebin.h"
 #include "mymoneyexception.h"
 #include "mymoneystoragexml.h"
 #include "mymoneystorageanon.h"
 #include "khomeview.h"
 #include "kaccountsview.h"
 #include "kcategoriesview.h"
 #include "kinstitutionsview.h"
 #include "kpayeesview.h"
 #include "ktagsview.h"
 #include "kscheduledview.h"
 #include "kgloballedgerview.h"
 #include "kinvestmentview.h"
 #include "models.h"
 #include "accountsmodel.h"
 #include "equitiesmodel.h"
 #include "securitiesmodel.h"
 #include "icons.h"
 #include "amountedit.h"
 #include "kmymoneyaccounttreeview.h"
 #include "accountsviewproxymodel.h"
 #include "mymoneyprice.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneyaccount.h"
 #include "mymoneyinstitution.h"
 #include "kmymoneyedit.h"
 #include "mymoneyfile.h"
 #include "mymoneysecurity.h"
 #include "mymoneyreport.h"
 #include "kmymoneyplugin.h"
 #include "mymoneyenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 using namespace eMyMoney;
 
 typedef void(KMyMoneyView::*KMyMoneyViewFunc)();
 
 KMyMoneyView::KMyMoneyView()
     : KPageWidget(nullptr),
     m_header(0),
     m_lastViewSelected(0),
     m_storagePlugins(nullptr)
 {
   // this is a workaround for the bug in KPageWidget that causes the header to be shown
   // for a short while during page switch which causes a kind of bouncing of the page's
   // content and if the page's content is at it's minimum size then during a page switch
   // the main window's size is also increased to fit the header that is shown for a sort
   // period - reading the code in kpagewidget.cpp we know that the header should be at (1,1)
   // in a grid layout so if we find it there remove it for good to avoid the described issues
   QGridLayout* gridLayout =  qobject_cast<QGridLayout*>(layout());
   if (gridLayout) {
     QLayoutItem* headerItem = gridLayout->itemAtPosition(1, 1);
     // make sure that we remove only the header - we avoid surprises if the header is not at (1,1) in the layout
     if (headerItem && qobject_cast<KTitleWidget*>(headerItem->widget()) != NULL) {
       gridLayout->removeItem(headerItem);
       // after we remove the KPageWidget standard header replace it with our own title label
       m_header = new KMyMoneyTitleLabel(this);
       m_header->setObjectName("titleLabel");
       m_header->setMinimumSize(QSize(100, 30));
       m_header->setRightImageFile("pics/titlelabel_background.png");
       m_header->setVisible(KMyMoneySettings::showTitleBar());
       gridLayout->addWidget(m_header, 1, 1);
     }
   }
 
 //  newStorage();
   m_model = new KPageWidgetModel(this); // cannot be parentless, otherwise segfaults at exit
 
   viewBases[View::Home] = new KHomeView;
   viewBases[View::Institutions] = new KInstitutionsView;
   viewBases[View::Accounts] = new KAccountsView;
   viewBases[View::Schedules] = new KScheduledView;
   viewBases[View::Categories] = new KCategoriesView;
   viewBases[View::Tags] = new KTagsView;
   viewBases[View::Payees] = new KPayeesView;
   viewBases[View::Ledgers] = new KGlobalLedgerView;
   viewBases[View::Investments] = new KInvestmentView;
   #ifdef ENABLE_UNFINISHEDFEATURES
   viewBases[View::NewLedgers] = new SimpleLedgerView;
   #endif
 
   struct viewInfo
   {
     View id;
     QString name;
     Icon icon;
   };
 
   const QVector<viewInfo> viewsInfo
   {
     {View::Home,            i18n("Home"),                         Icon::ViewHome},
     {View::Institutions,    i18n("Institutions"),                 Icon::ViewInstitutions},
     {View::Accounts,        i18n("Accounts"),                     Icon::ViewAccounts},
     {View::Schedules,       i18n("Scheduled\ntransactions"),      Icon::ViewSchedules},
     {View::Categories,      i18n("Categories"),                   Icon::ViewCategories},
     {View::Tags,            i18n("Tags"),                         Icon::ViewTags},
     {View::Payees,          i18n("Payees"),                       Icon::ViewPayees},
     {View::Ledgers,         i18n("Ledgers"),                      Icon::ViewLedgers},
     {View::Investments,     i18n("Investments"),                  Icon::ViewInvestment},
     #ifdef ENABLE_UNFINISHEDFEATURES
     {View::NewLedgers,      i18n("New ledger"),                   Icon::DocumentProperties},
     #endif
   };
 
   for (const viewInfo& view : viewsInfo) {
     /* There is a bug in
     static int layoutText(QTextLayout *layout, int maxWidth)
     from kpageview_p.cpp from kwidgetsaddons.
     The method doesn't break strings that are too long. Following line
     workarounds this by using LINE SEPARATOR character which is accepted by
     QTextLayout::createLine().*/
     viewFrames[view.id] = m_model->addPage(viewBases[view.id], QString(view.name).replace('\n', QString::fromLocal8Bit("\xe2\x80\xa8")));
     viewFrames[view.id]->setIcon(Icons::get(view.icon));
     connect(viewBases[view.id], &KMyMoneyViewBase::selectByObject, this, &KMyMoneyView::slotSelectByObject);
     connect(viewBases[view.id], &KMyMoneyViewBase::selectByVariant, this, &KMyMoneyView::slotSelectByVariant);
     connect(viewBases[view.id], &KMyMoneyViewBase::customActionRequested, this, &KMyMoneyView::slotCustomActionRequested);
   }
 
   connect(Models::instance()->accountsModel(), &AccountsModel::netWorthChanged, this, &KMyMoneyView::slotSelectByVariant);
   connect(Models::instance()->institutionsModel(), &AccountsModel::netWorthChanged, this, &KMyMoneyView::slotSelectByVariant);
   connect(Models::instance()->institutionsModel(), &AccountsModel::profitChanged, this, &KMyMoneyView::slotSelectByVariant);
 
   //set the model
   setModel(m_model);
   setCurrentPage(viewFrames[View::Home]);
   connect(this, SIGNAL(currentPageChanged(QModelIndex,QModelIndex)), this, SLOT(slotCurrentPageChanged(QModelIndex,QModelIndex)));
 
   updateViewType();
 }
 
 KMyMoneyView::~KMyMoneyView()
 {
   KMyMoneySettings::setLastViewSelected(m_lastViewSelected);
 }
 
 void KMyMoneyView::slotFileOpened()
 {
   if (viewBases.contains(View::OnlineJobOutbox))
     viewBases[View::OnlineJobOutbox]->executeCustomAction(eView::Action::InitializeAfterFileOpen);
 
   #ifdef ENABLE_UNFINISHEDFEATURES
   static_cast<SimpleLedgerView*>(viewBases[View::NewLedgers])->openFavoriteLedgers();
   #endif
   switchToDefaultView();
 }
 
 void KMyMoneyView::slotFileClosed()
 {
 
   if (viewBases.contains(View::Reports))
     viewBases[View::Reports]->executeCustomAction(eView::Action::CleanupBeforeFileClose);
 
   if (viewBases.contains(View::OnlineJobOutbox))
     viewBases[View::OnlineJobOutbox]->executeCustomAction(eView::Action::CleanupBeforeFileClose);
 
   #ifdef ENABLE_UNFINISHEDFEATURES
   static_cast<SimpleLedgerView*>(viewBases[View::NewLedgers])->closeLedgers();
   #endif
   slotShowHomePage();
 }
 
 void KMyMoneyView::slotShowHomePage()
 {
   showPageAndFocus(View::Home);
 }
 
 void KMyMoneyView::slotShowInstitutionsPage()
 {
   showPageAndFocus(View::Institutions);
 }
 
 void KMyMoneyView::slotShowAccountsPage()
 {
   showPageAndFocus(View::Accounts);
 }
 
 void KMyMoneyView::slotShowSchedulesPage()
 {
   showPageAndFocus(View::Schedules);
 }
 
 void KMyMoneyView::slotShowCategoriesPage()
 {
   showPageAndFocus(View::Categories);
 }
 
 void KMyMoneyView::slotShowTagsPage()
 {
   showPageAndFocus(View::Tags);
 }
 
 void KMyMoneyView::slotShowPayeesPage()
 {
   showPageAndFocus(View::Payees);
 }
 
 void KMyMoneyView::slotShowLedgersPage()
 {
   showPageAndFocus(View::Ledgers);
 }
 
 void KMyMoneyView::slotShowInvestmentsPage()
 {
   showPageAndFocus(View::Investments);
 }
 
 void KMyMoneyView::slotShowReportsPage()
 {
   showPageAndFocus(View::Reports);
 }
 
 void KMyMoneyView::slotShowBudgetPage()
 {
   showPageAndFocus(View::Budget);
 }
 
 void KMyMoneyView::slotShowForecastPage()
 {
   showPageAndFocus(View::Forecast);
 }
 
 void KMyMoneyView::slotShowOutboxPage()
 {
   showPageAndFocus(View::OnlineJobOutbox);
 }
 
 void KMyMoneyView::showTitleBar(bool show)
 {
   if (m_header)
     m_header->setVisible(show);
 }
 
 void KMyMoneyView::updateViewType()
 {
   // set the face type
   KPageView::FaceType faceType = KPageView::List;
   switch (KMyMoneySettings::viewType()) {
     case 0:
       faceType = KPageView::List;
       break;
     case 1:
       faceType = KPageView::Tree;
       break;
     case 2:
       faceType = KPageView::Tabbed;
       break;
   }
   if (faceType != KMyMoneyView::faceType()) {
     setFaceType(faceType);
     if (faceType == KPageView::Tree) {
       QList<QTreeView *> views = findChildren<QTreeView*>();
       foreach (QTreeView * view, views) {
         if (view && (view->parent() == this)) {
           view->setRootIsDecorated(false);
           break;
         }
       }
     }
   }
 }
 
 void KMyMoneyView::slotAccountTreeViewChanged(const eAccountsModel::Column column, const bool show)
 {
   QVector<AccountsViewProxyModel *> proxyModels
   {
     static_cast<KMyMoneyAccountsViewBase*>(viewBases[View::Institutions])->getProxyModel(),
     static_cast<KMyMoneyAccountsViewBase*>(viewBases[View::Accounts])->getProxyModel(),
     static_cast<KMyMoneyAccountsViewBase*>(viewBases[View::Categories])->getProxyModel()
   };
 
   if (viewBases.contains(View::Budget))
     proxyModels.append(static_cast<KMyMoneyAccountsViewBase*>(viewBases[View::Budget])->getProxyModel());
 
   for (auto i = proxyModels.count() - 1; i >= 0; --i) { // weed out unloaded views
     if (!proxyModels.at(i))
       proxyModels.removeAt(i);
   }
 
   QString question;
 
   if (show)
     question = i18n("Do you want to show <b>%1</b> column on every loaded view?", AccountsModel::getHeaderName(column));
   else
     question = i18n("Do you want to hide <b>%1</b> column on every loaded view?", AccountsModel::getHeaderName(column));
 
 
   if (proxyModels.count() == 1 || // no need to ask what to do with other views because they aren't loaded
       KMessageBox::questionYesNo(this,
                                  question,
                                  QString(),
                                  KStandardGuiItem::yes(), KStandardGuiItem::no(),
                                  QStringLiteral("ShowColumnOnEveryView")) == KMessageBox::Yes) {
     Models::instance()->accountsModel()->setColumnVisibility(column, show);
     Models::instance()->institutionsModel()->setColumnVisibility(column, show);
     foreach(AccountsViewProxyModel *proxyModel, proxyModels) {
       if (!proxyModel)
         continue;
       proxyModel->setColumnVisibility(column, show);
       proxyModel->invalidate();
     }
   } else if(show) {
     // in case we need to show it, we have to make sure to set the visibility
     // in the base model as well. Otherwise, we don't see the column through the proxy model
     Models::instance()->accountsModel()->setColumnVisibility(column, show);
     Models::instance()->institutionsModel()->setColumnVisibility(column, show);
   }
 }
 
 void KMyMoneyView::setOnlinePlugins(QMap<QString, KMyMoneyPlugin::OnlinePlugin*>& plugins)
 {
   if (viewBases.contains(View::Accounts))
     viewBases[View::Accounts]->slotSelectByVariant(QVariantList {QVariant::fromValue(static_cast<void*>(&plugins))}, eView::Intent::SetOnlinePlugins);
 
   if (viewBases.contains(View::OnlineJobOutbox))
     viewBases[View::OnlineJobOutbox]->slotSelectByVariant(QVariantList {QVariant::fromValue(static_cast<void*>(&plugins))}, eView::Intent::SetOnlinePlugins);
 }
 
 void KMyMoneyView::setStoragePlugins(QMap<QString, KMyMoneyPlugin::StoragePlugin*>& plugins)
 {
   m_storagePlugins = &plugins;
 }
 
 eDialogs::ScheduleResultCode KMyMoneyView::enterSchedule(MyMoneySchedule& schedule, bool autoEnter, bool extendedKeys)
 {
   return static_cast<KScheduledView*>(viewBases[View::Schedules])->enterSchedule(schedule, autoEnter, extendedKeys);
 }
 
 void KMyMoneyView::addView(KMyMoneyViewBase* view, const QString& name, View idView)
 {
   auto isViewInserted = false;
   for (auto i = (int)idView; i < (int)View::None; ++i) {
     if (viewFrames.contains((View)i)) {
       viewFrames[idView] = m_model->insertPage(viewFrames[(View)i],view, name);
       isViewInserted = true;
       break;
     }
   }
 
   if (!isViewInserted)
     viewFrames[idView] = m_model->addPage(view, name);
 
   viewBases[idView] = view;
   connect(viewBases[idView], &KMyMoneyViewBase::selectByObject, this, &KMyMoneyView::slotSelectByObject);
   connect(viewBases[idView], &KMyMoneyViewBase::selectByVariant, this, &KMyMoneyView::slotSelectByVariant);
   connect(viewBases[idView], &KMyMoneyViewBase::customActionRequested, this, &KMyMoneyView::slotCustomActionRequested);
 
   auto icon = Icon::ViewForecast;
   switch (idView) {
     case View::Reports:
       icon = Icon::ViewReports;
       break;
     case View::Budget:
       icon = Icon::ViewBudgets;
       break;
     case View::Forecast:
       icon = Icon::ViewForecast;
       break;
     case View::OnlineJobOutbox:
       icon = Icon::ViewOutbox;
       break;
     default:
       break;
   }
   viewFrames[idView]->setIcon(Icons::get(icon));
 }
 
 void KMyMoneyView::removeView(View idView)
 {
   if (!viewBases.contains(idView))
     return;
 
   disconnect(viewBases[idView], &KMyMoneyViewBase::selectByObject, this, &KMyMoneyView::slotSelectByObject);
   disconnect(viewBases[idView], &KMyMoneyViewBase::selectByVariant, this, &KMyMoneyView::slotSelectByVariant);
   disconnect(viewBases[idView], &KMyMoneyViewBase::customActionRequested, this, &KMyMoneyView::slotCustomActionRequested);
 
   m_model->removePage(viewFrames[idView]);
   viewFrames.remove(idView);
   viewBases.remove(idView);
 }
 
 QHash<eMenu::Action, QAction *> KMyMoneyView::actionsToBeConnected()
 {
   using namespace eMenu;
   // add fast switching of main views through Ctrl + NUM_X
   struct pageInfo {
     Action           view;
     KMyMoneyViewFunc callback;
     QString          text;
     QKeySequence     shortcut = QKeySequence();
   };
 
   const QVector<pageInfo> pageInfos {
     {Action::ShowHomeView,            &KMyMoneyView::slotShowHomePage,          i18n("Show home page"),                   Qt::CTRL + Qt::Key_1},
     {Action::ShowInstitutionsView,    &KMyMoneyView::slotShowInstitutionsPage,  i18n("Show institutions page"),           Qt::CTRL + Qt::Key_2},
     {Action::ShowAccountsView,        &KMyMoneyView::slotShowAccountsPage,      i18n("Show accounts page"),               Qt::CTRL + Qt::Key_3},
     {Action::ShowSchedulesView,       &KMyMoneyView::slotShowSchedulesPage,     i18n("Show scheduled transactions page"), Qt::CTRL + Qt::Key_4},
     {Action::ShowCategoriesView,      &KMyMoneyView::slotShowCategoriesPage,    i18n("Show categories page"),             Qt::CTRL + Qt::Key_5},
     {Action::ShowTagsView,            &KMyMoneyView::slotShowTagsPage,          i18n("Show tags page"),                   },
     {Action::ShowPayeesView,          &KMyMoneyView::slotShowPayeesPage,        i18n("Show payees page"),                 Qt::CTRL + Qt::Key_6},
     {Action::ShowLedgersView,         &KMyMoneyView::slotShowLedgersPage,       i18n("Show ledgers page"),                Qt::CTRL + Qt::Key_7},
     {Action::ShowInvestmentsView,     &KMyMoneyView::slotShowInvestmentsPage,   i18n("Show investments page"),            Qt::CTRL + Qt::Key_8},
     {Action::ShowReportsView,         &KMyMoneyView::slotShowReportsPage,       i18n("Show reports page"),                Qt::CTRL + Qt::Key_9},
     {Action::ShowBudgetView,          &KMyMoneyView::slotShowBudgetPage,        i18n("Show budget page"),                },
     {Action::ShowForecastView,        &KMyMoneyView::slotShowForecastPage,      i18n("Show forecast page"),              },
     {Action::ShowOnlineJobOutboxView, &KMyMoneyView::slotShowOutboxPage,        i18n("Show outbox page")                 }
   };
 
   QHash<Action, QAction *> lutActions;
   auto pageCount = 0;
   for (const pageInfo& info : pageInfos) {
     auto a = new QAction(this);
     // KActionCollection::addAction by name sets object name anyways,
     // so, as better alternative, set it here right from the start
     a->setObjectName(QString::fromLatin1("ShowPage%1").arg(QString::number(pageCount++)));
     a->setText(info.text);
     connect(a, &QAction::triggered, this, info.callback);
     lutActions.insert(info.view, a);  // store QAction's pointer for later processing
     if (!info.shortcut.isEmpty())
       a->setShortcut(info.shortcut);
   }
   return lutActions;
 }
 
 bool KMyMoneyView::showPageHeader() const
 {
   return false;
 }
 
 void KMyMoneyView::showPageAndFocus(View idView)
 {
   if (viewFrames.contains(idView)) {
     showPage(idView);
     viewBases[idView]->executeCustomAction(eView::Action::SetDefaultFocus);
   }
 }
 
 void KMyMoneyView::showPage(View idView)
 {
   if (!viewFrames.contains(idView) ||
       currentPage() == viewFrames[idView])
     return;
 
   setCurrentPage(viewFrames[idView]);
   pActions[eMenu::Action::Print]->setEnabled(canPrint());
   emit aboutToChangeView();
 }
 
 bool KMyMoneyView::canPrint()
 {
   return ((viewFrames.contains(View::Reports) && viewFrames[View::Reports] == currentPage()) ||
           (viewFrames.contains(View::Home) && viewFrames[View::Home] == currentPage())
          );
 }
 
 void KMyMoneyView::enableViewsIfFileOpen(bool fileOpen)
 {
   // call set enabled only if the state differs to avoid widgets 'bouncing on the screen' while doing this
   for (auto i = (int)View::Home; i < (int)View::None; ++i)
     if (viewFrames.contains(View(i)))
       if (viewFrames[View(i)]->isEnabled() != fileOpen)
         viewFrames[View(i)]->setEnabled(fileOpen);
 
   emit viewStateChanged(fileOpen);
 }
 
 void KMyMoneyView::switchToDefaultView()
 {
   const auto idView = KMyMoneySettings::startLastViewSelected() ?
         static_cast<View>(KMyMoneySettings::lastViewSelected()) :
         View::Home;
   // if we currently see a different page, then select the right one
   if (viewFrames.contains(idView) && viewFrames[idView] != currentPage())
     showPage(idView);
 }
 
 void KMyMoneyView::slotPayeeSelected(const QString& payee, const QString& account, const QString& transaction)
 {
   showPage(View::Payees);
   static_cast<KPayeesView*>(viewBases[View::Payees])->slotSelectPayeeAndTransaction(payee, account, transaction);
 }
 
 void KMyMoneyView::slotTagSelected(const QString& tag, const QString& account, const QString& transaction)
 {
   showPage(View::Tags);
   static_cast<KTagsView*>(viewBases[View::Tags])->slotSelectTagAndTransaction(tag, account, transaction);
 }
 
 void KMyMoneyView::finishReconciliation(const MyMoneyAccount& /* account */)
 {
   Models::instance()->accountsModel()->slotReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
   static_cast<KGlobalLedgerView*>(viewBases[View::Ledgers])->slotSetReconcileAccount(MyMoneyAccount(), QDate(), MyMoneyMoney());
 }
 
 void KMyMoneyView::slotSetBaseCurrency(const MyMoneySecurity& baseCurrency)
 {
   if (!baseCurrency.id().isEmpty()) {
     QString baseId;
     try {
       baseId = MyMoneyFile::instance()->baseCurrency().id();
     } catch (const MyMoneyException &e) {
-      qDebug("%s", qPrintable(e.what()));
+      qDebug("%s", e.what());
     }
 
     if (baseCurrency.id() != baseId) {
       MyMoneyFileTransaction ft;
       try {
         MyMoneyFile::instance()->setBaseCurrency(baseCurrency);
         ft.commit();
       } catch (const MyMoneyException &e) {
-        KMessageBox::sorry(this, i18n("Cannot set %1 as base currency: %2", baseCurrency.name(), e.what()), i18n("Set base currency"));
+        KMessageBox::sorry(this, i18n("Cannot set %1 as base currency: %2", baseCurrency.name(), QString::fromLatin1(e.what())), i18n("Set base currency"));
       }
     }
     AmountEdit::setStandardPrecision(MyMoneyMoney::denomToPrec(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction()));
     KMyMoneyEdit::setStandardPrecision(MyMoneyMoney::denomToPrec(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction()));
   }
 }
 
 void KMyMoneyView::viewAccountList(const QString& /*selectAccount*/)
 {
   if (viewFrames[View::Accounts] != currentPage())
     showPage(View::Accounts);
   viewBases[View::Accounts]->show();
 }
 
 void KMyMoneyView::slotRefreshViews()
 {
   showTitleBar(KMyMoneySettings::showTitleBar());
 
   for (auto i = (int)View::Home; i < (int)View::None; ++i)
     if (viewBases.contains(View(i)))
       viewBases[View(i)]->executeCustomAction(eView::Action::Refresh);
 
   viewBases[View::Payees]->executeCustomAction(eView::Action::ClosePayeeIdentifierSource);
 }
 
 void KMyMoneyView::slotShowTransactionDetail(bool detailed)
 {
   KMyMoneySettings::setShowRegisterDetailed(detailed);
   slotRefreshViews();
 }
 
 void KMyMoneyView::slotCurrentPageChanged(const QModelIndex current, const QModelIndex)
 {
   // remember the current page
   m_lastViewSelected = current.row();
   // set the current page's title in the header
   if (m_header)
     m_header->setText(m_model->data(current, KPageModel::HeaderRole).toString());
 }
 
 void KMyMoneyView::createSchedule(MyMoneySchedule newSchedule, MyMoneyAccount& newAccount)
 {
   // Add the schedule only if one exists
   //
   // Remember to modify the first split to reference the newly created account
   if (!newSchedule.name().isEmpty()) {
     MyMoneyFileTransaction ft;
     try {
       // We assume at least 2 splits in the transaction
       MyMoneyTransaction t = newSchedule.transaction();
       if (t.splitCount() < 2) {
-        throw MYMONEYEXCEPTION("Transaction for schedule has less than 2 splits!");
+        throw MYMONEYEXCEPTION_CSTRING("Transaction for schedule has less than 2 splits!");
       }
       // now search the split that does not have an account reference
       // and set it up to be the one of the account we just added
       // to the account pool. Note: the schedule code used to leave
       // this always the first split, but the loan code leaves it as
       // the second one. So I thought, searching is a good alternative ....
       foreach (const auto split, t.splits()) {
         if (split.accountId().isEmpty()) {
           MyMoneySplit s = split;
           s.setAccountId(newAccount.id());
           t.modifySplit(s);
           break;
         }
       }
       newSchedule.setTransaction(t);
 
       MyMoneyFile::instance()->addSchedule(newSchedule);
 
       // in case of a loan account, we keep a reference to this
       // schedule in the account
       if (newAccount.isLoan()) {
         newAccount.setValue("schedule", newSchedule.id());
         MyMoneyFile::instance()->modifyAccount(newAccount);
       }
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to add schedule: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to add schedule: %1", QString::fromLatin1(e.what())));
     }
   }
 }
 
 void KMyMoneyView::slotPrintView()
 {
   if (viewFrames.contains(View::Reports) && viewFrames[View::Reports] == currentPage())
     viewBases[View::Reports]->executeCustomAction(eView::Action::Print);
   else if (viewFrames.contains(View::Home) && viewFrames[View::Home] == currentPage())
     viewBases[View::Home]->executeCustomAction(eView::Action::Print);
 }
 
 void KMyMoneyView::resetViewSelection(const View)
 {
   emit aboutToChangeView();
 }
 
 void KMyMoneyView::slotOpenObjectRequested(const MyMoneyObject& obj)
 {
   if (typeid(obj) == typeid(MyMoneyAccount)) {
     const auto& acc = static_cast<const MyMoneyAccount&>(obj);
     // check if we can open this account
     // currently it make's sense for asset and liability accounts
     if (!MyMoneyFile::instance()->isStandardAccount(acc.id()))
       if (viewBases.contains(View::Ledgers))
         viewBases[View::Ledgers]->slotSelectByVariant(QVariantList {QVariant(acc.id()), QVariant(QString()) }, eView::Intent::ShowTransaction );
 
   } else if (typeid(obj) == typeid(MyMoneyInstitution)) {
 //    const auto& inst = static_cast<const MyMoneyInstitution&>(obj);
     if (viewBases.contains(View::Institutions))
       viewBases[View::Institutions]->executeCustomAction(eView::Action::EditInstitution);
   } else if (typeid(obj) == typeid(MyMoneySchedule)) {
     if (viewBases.contains(View::Schedules))
       viewBases[View::Schedules]->executeCustomAction(eView::Action::EditSchedule);
   } else if (typeid(obj) == typeid(MyMoneyReport)) {
 //    const auto& rep = static_cast<const MyMoneyReport&>(obj);
     showPage(View::Reports);
     if (viewBases.contains(View::Reports))
         viewBases[View::Reports]->slotSelectByObject(obj, eView::Intent::OpenObject);
   }
 }
 
 void KMyMoneyView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch (intent) {
     case eView::Intent::None:
       slotObjectSelected(obj);
       break;
 
     case eView::Intent::SynchronizeAccountInInvestmentView:
       if (viewBases.contains(View::Investments))
         viewBases[View::Investments]->slotSelectByObject(obj, intent);
       break;
 
     case eView::Intent::SynchronizeAccountInLedgersView:
       if (viewBases.contains(View::Ledgers))
         viewBases[View::Ledgers]->slotSelectByObject(obj, intent);
       break;
 
     case eView::Intent::OpenObject:
       slotOpenObjectRequested(obj);
       break;
 
     case eView::Intent::OpenContextMenu:
       slotContextMenuRequested(obj);
       break;
 
     case eView::Intent::StartEnteringOverdueScheduledTransactions:
       if (viewBases.contains(View::Schedules))
         viewBases[View::Schedules]->slotSelectByObject(obj, intent);
       break;
 
     case eView::Intent::FinishEnteringOverdueScheduledTransactions:
       if (viewBases.contains(View::Ledgers)) {
         showPage(View::Ledgers);
         viewBases[View::Ledgers]->slotSelectByObject(obj, intent);
       }
       break;
 
     default:
       break;
   }
 }
 
 void KMyMoneyView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::ReportProgress:
       if (variant.count() == 2)
         emit statusProgress(variant.at(0).toInt(), variant.at(1).toInt());
       break;
 
     case eView::Intent::ReportProgressMessage:
       if (variant.count() == 1)
         emit statusMsg(variant.first().toString());
       break;
 
     case eView::Intent::UpdateNetWorth:
       if (viewBases.contains(View::Accounts))
         viewBases[View::Accounts]->slotSelectByVariant(variant, intent);
 
       if (viewBases.contains(View::Institutions))
         viewBases[View::Institutions]->slotSelectByVariant(variant, intent);
       break;
 
     case eView::Intent::UpdateProfit:
       if (viewBases.contains(View::Categories))
         viewBases[View::Categories]->slotSelectByVariant(variant, intent);
       break;
 
     case eView::Intent::ShowTransaction:
       if (viewBases.contains(View::Ledgers)) {
         showPage(View::Ledgers);
         viewBases[View::Ledgers]->slotSelectByVariant(variant, intent);
       }
       break;
 
     case eView::Intent::ToggleColumn:
       if (variant.count() == 2)
         slotAccountTreeViewChanged(variant.at(0).value<eAccountsModel::Column>(), variant.at(1).value<bool>());
       break;
 
     case eView::Intent::ShowPayee:
       if (viewBases.contains(View::Payees)) {
         showPage(View::Payees);
         viewBases[View::Payees]->slotSelectByVariant(variant, intent);
       }
       break;
 
     case eView::Intent::SelectRegisterTransactions:
       if (variant.count() == 1)
         emit transactionsSelected(variant.at(0).value<KMyMoneyRegister::SelectedTransactions>()); // for plugins
       break;
 
     case eView::Intent::AccountReconciled:
       if (variant.count() == 5)
         emit accountReconciled(variant.at(0).value<MyMoneyAccount>(),
                                variant.at(1).value<QDate>(),
                                variant.at(2).value<MyMoneyMoney>(),
                                variant.at(3).value<MyMoneyMoney>(),
                                variant.at(4).value<QList<QPair<MyMoneyTransaction, MyMoneySplit>>>()); // for plugins
       break;
 
     default:
       break;
   }
 }
 
 void KMyMoneyView::slotCustomActionRequested(View view, eView::Action action)
 {
   switch (action) {
     case eView::Action::AboutToShow:
       emit aboutToChangeView();
       break;
     case eView::Action::SwitchView:
       showPage(view);
       break;
     default:
       break;
   }
 }
 
 void KMyMoneyView::slotObjectSelected(const MyMoneyObject& obj)
 {
   // carrying some slots over to views isn't easy for all slots...
   // ...so calls to kmymoney still must be here
   if (typeid(obj) == typeid(MyMoneyAccount)) {
     QVector<View> views {View::Investments, View::Categories, View::Accounts,
                          View::Ledgers, View::Reports, View::OnlineJobOutbox};
     for (const auto view : views)
       if (viewBases.contains(view))
         viewBases[view]->slotSelectByObject(obj, eView::Intent::UpdateActions);
 
     // for plugin only
     const auto& acc = static_cast<const MyMoneyAccount&>(obj);
     if (!acc.isIncomeExpense() &&
         !MyMoneyFile::instance()->isStandardAccount(acc.id()))
       emit accountSelected(acc);
   } else if (typeid(obj) == typeid(MyMoneyInstitution)) {
     viewBases[View::Institutions]->slotSelectByObject(obj, eView::Intent::UpdateActions);
   } else if (typeid(obj) == typeid(MyMoneySchedule)) {
     viewBases[View::Schedules]->slotSelectByObject(obj, eView::Intent::UpdateActions);
   }
 }
 
 void KMyMoneyView::slotContextMenuRequested(const MyMoneyObject& obj)
 {
   if (typeid(obj) == typeid(MyMoneyAccount)) {
     const auto& acc = static_cast<const MyMoneyAccount&>(obj);
     if (acc.isInvest())
       viewBases[View::Investments]->slotSelectByObject(obj, eView::Intent::OpenContextMenu);
     else if (acc.isIncomeExpense())
       viewBases[View::Categories]->slotSelectByObject(obj, eView::Intent::OpenContextMenu);
     else
       viewBases[View::Accounts]->slotSelectByObject(obj, eView::Intent::OpenContextMenu);
 
   } else if (typeid(obj) == typeid(MyMoneyInstitution)) {
     viewBases[View::Institutions]->slotSelectByObject(obj, eView::Intent::OpenContextMenu);
   } else if (typeid(obj) == typeid(MyMoneySchedule)) {
     viewBases[View::Schedules]->slotSelectByObject(obj, eView::Intent::OpenContextMenu);
   }
 }
diff --git a/kmymoney/views/kpayeesview.cpp b/kmymoney/views/kpayeesview.cpp
index 5afaf1b50..121228722 100644
--- a/kmymoney/views/kpayeesview.cpp
+++ b/kmymoney/views/kpayeesview.cpp
@@ -1,722 +1,719 @@
 /***************************************************************************
                           kpayeesview.cpp
                           ---------------
     begin                : Thu Jan 24 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <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>
                            Andreas Nicolai <Andreas.Nicolai@gmx.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kpayeesview_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QMap>
 #include <QList>
 #include <QTimer>
 #include <QMenu>
 #include <QDesktopServices>
 #include <QIcon>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KGuiItem>
 #include <KHelpClient>
 #include <KSharedConfig>
 #include <KListWidgetSearchLine>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <config-kmymoney.h>
 #include "ui_kpayeesview.h"
 #include "kmymoneyviewbase_p.h"
 #include "kpayeeidentifierview.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneytransactionfilter.h"
 #include "kmymoneysettings.h"
 #include "models.h"
 #include "accountsmodel.h"
 #include "mymoneysecurity.h"
 #include "mymoneycontact.h"
 #include "mymoneyprice.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "icons/icons.h"
 #include "transaction.h"
 #include "widgetenums.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 // *** KPayeesView Implementation ***
 
 KPayeesView::KPayeesView(QWidget *parent) :
     KMyMoneyViewBase(*new KPayeesViewPrivate(this), parent)
 {
   connect(pActions[eMenu::Action::NewPayee],    &QAction::triggered, this, &KPayeesView::slotNewPayee);
   connect(pActions[eMenu::Action::RenamePayee], &QAction::triggered, this, &KPayeesView::slotRenamePayee);
   connect(pActions[eMenu::Action::DeletePayee], &QAction::triggered, this, &KPayeesView::slotDeletePayee);
   connect(pActions[eMenu::Action::MergePayee],  &QAction::triggered, this, &KPayeesView::slotMergePayee);
 }
 
 KPayeesView::~KPayeesView()
 {
 }
 
 void KPayeesView::slotChooseDefaultAccount()
 {
   Q_D(KPayeesView);
   MyMoneyFile* file = MyMoneyFile::instance();
   QMap<QString, int> account_count;
 
   KMyMoneyRegister::RegisterItem* item = d->ui->m_register->firstItem();
   while (item) {
     //only walk through selectable items. eg. transactions and not group markers
     if (item->isSelectable()) {
       auto t = dynamic_cast<KMyMoneyRegister::Transaction*>(item);
       if (!t)
         return;
       MyMoneySplit s = t->transaction().splitByPayee(d->m_payee.id());
       const MyMoneyAccount& acc = file->account(s.accountId());
 
       QString txt;
       if (s.action() != MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization)
           && acc.accountType() != eMyMoney::Account::Type::AssetLoan
           && !file->isTransfer(t->transaction())
           && t->transaction().splitCount() == 2) {
         MyMoneySplit s0 = t->transaction().splitByAccount(s.accountId(), false);
         if (account_count.contains(s0.accountId())) {
           account_count[s0.accountId()]++;
         } else {
           account_count[s0.accountId()] = 1;
         }
       }
     }
     item = item->nextItem();
   }
 
   QMap<QString, int>::Iterator most_frequent, iter;
   most_frequent = account_count.begin();
   for (iter = account_count.begin(); iter != account_count.end(); ++iter) {
     if (iter.value() > most_frequent.value()) {
       most_frequent = iter;
     }
   }
 
   if (most_frequent != account_count.end()) {
     d->ui->checkEnableDefaultCategory->setChecked(true);
     d->ui->comboDefaultCategory->setSelected(most_frequent.key());
     d->setDirty(true);
   }
 }
 
 void KPayeesView::slotClosePayeeIdentifierSource()
 {
   Q_D(KPayeesView);
   if (!d->m_needLoad)
     d->ui->payeeIdentifiers->closeSource();
 }
 
 void KPayeesView::slotSelectByVariant(const QVariantList& variant, eView::Intent intent)
 {
   switch (intent) {
     case eView::Intent::ShowPayee:
       if (variant.count() == 3)
         slotSelectPayeeAndTransaction(variant.at(0).toString(), variant.at(1).toString(), variant.at(2).toString());
       break;
     default:
       break;
   }
 }
 
 
 void KPayeesView::slotStartRename(QListWidgetItem* item)
 {
   Q_D(KPayeesView);
   d->m_allowEditing = true;
   d->ui->m_payeesList->editItem(item);
 }
 
 // This variant is only called when a single payee is selected and renamed.
 void KPayeesView::slotRenameSinglePayee(QListWidgetItem* p)
 {
   Q_D(KPayeesView);
   //if there is no current item selected, exit
   if (d->m_allowEditing == false || !d->ui->m_payeesList->currentItem() || p != d->ui->m_payeesList->currentItem())
     return;
 
   //qDebug() << "[KPayeesView::slotRenamePayee]";
   // create a copy of the new name without appended whitespaces
   QString new_name = p->text();
   if (d->m_payee.name() != new_name) {
     MyMoneyFileTransaction ft;
     try {
       // check if we already have a payee with the new name
       try {
         // this function call will throw an exception, if the payee
         // hasn't been found.
         MyMoneyFile::instance()->payeeByName(new_name);
         // the name already exists, ask the user whether he's sure to keep the name
         if (KMessageBox::questionYesNo(this,
                                        i18n("A payee with the name '%1' already exists. It is not advisable to have "
                                             "multiple payees with the same identification name. Are you sure you would like "
                                             "to rename the payee?", new_name)) != KMessageBox::Yes) {
           p->setText(d->m_payee.name());
           return;
         }
       } catch (const MyMoneyException &) {
         // all ok, the name is unique
       }
 
       d->m_payee.setName(new_name);
       d->m_newName = new_name;
       MyMoneyFile::instance()->modifyPayee(d->m_payee);
 
       // the above call to modifyPayee will reload the view so
       // all references and pointers to the view have to be
       // re-established.
 
       // make sure, that the record is visible even if it moved
       // out of sight due to the rename operation
       d->ensurePayeeVisible(d->m_payee.id());
 
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to modify payee"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify payee"), QString::fromLatin1(e.what()));
     }
   } else {
     p->setText(new_name);
   }
 }
 
 void KPayeesView::slotSelectPayee(QListWidgetItem* cur, QListWidgetItem* prev)
 {
   Q_D(KPayeesView);
   Q_UNUSED(cur);
   Q_UNUSED(prev);
 
   d->m_allowEditing = false;
 }
 
 void KPayeesView::slotSelectPayee()
 {
   Q_D(KPayeesView);
   // check if the content of a currently selected payee was modified
   // and ask to store the data
   if (d->isDirty()) {
     if (KMessageBox::questionYesNo(this,
                                    i18n("<qt>Do you want to save the changes for <b>%1</b>?</qt>", d->m_newName),
                                    i18n("Save changes")) == KMessageBox::Yes) {
       d->m_inSelection = true;
       slotUpdatePayee();
       d->m_inSelection = false;
     }
   }
 
   // make sure we always clear the selected list when listing again
   d->m_selectedPayeesList.clear();
 
   // loop over all payees and count the number of payees, also
   // obtain last selected payee
   d->selectedPayees(d->m_selectedPayeesList);
   updatePayeeActions(d->m_selectedPayeesList);
 
   emit selectObjects(d->m_selectedPayeesList);
 
   if (d->m_selectedPayeesList.isEmpty()) {
     d->ui->m_tabWidget->setEnabled(false); // disable tab widget
     d->ui->m_balanceLabel->hide();
     d->ui->m_deleteButton->setEnabled(false); //disable delete, rename and merge buttons
     d->ui->m_renameButton->setEnabled(false);
     d->ui->m_mergeButton->setEnabled(false);
     d->clearItemData();
     d->m_payee = MyMoneyPayee();
     d->ui->m_syncAddressbook->setEnabled(false);
     return; // make sure we don't access an undefined payee
   }
 
   d->ui->m_deleteButton->setEnabled(true); //re-enable delete button
 
   d->ui->m_syncAddressbook->setEnabled(true);
 
   // if we have multiple payees selected, clear and disable the payee information
   if (d->m_selectedPayeesList.count() > 1) {
     d->ui->m_tabWidget->setEnabled(false); // disable tab widget
     d->ui->m_renameButton->setEnabled(false); // disable also the rename button
     d->ui->m_mergeButton->setEnabled(true);
     d->ui->m_balanceLabel->hide();
     d->clearItemData();
   } else {
     d->ui->m_mergeButton->setEnabled(false);
     d->ui->m_renameButton->setEnabled(true);
   }
 
   // otherwise we have just one selected, enable payee information widget
   d->ui->m_tabWidget->setEnabled(true);
   d->ui->m_balanceLabel->show();
 
   // as of now we are updating only the last selected payee, and until
   // selection mode of the QListView has been changed to Extended, this
   // will also be the only selection and behave exactly as before - Andreas
   try {
     d->m_payee = d->m_selectedPayeesList[0];
 
     d->m_newName = d->m_payee.name();
 
     d->ui->addressEdit->setEnabled(true);
     d->ui->addressEdit->setText(d->m_payee.address());
     d->ui->postcodeEdit->setEnabled(true);
     d->ui->postcodeEdit->setText(d->m_payee.postcode());
     d->ui->telephoneEdit->setEnabled(true);
     d->ui->telephoneEdit->setText(d->m_payee.telephone());
     d->ui->emailEdit->setEnabled(true);
     d->ui->emailEdit->setText(d->m_payee.email());
     d->ui->notesEdit->setText(d->m_payee.notes());
 
     QStringList keys;
     bool ignorecase = false;
     MyMoneyPayee::payeeMatchType type = d->m_payee.matchData(ignorecase, keys);
 
     d->ui->matchTypeCombo->setCurrentIndex(d->ui->matchTypeCombo->findData(type));
     d->ui->matchKeyEditList->clear();
     d->ui->matchKeyEditList->insertStringList(keys);
     d->ui->checkMatchIgnoreCase->setChecked(ignorecase);
 
     d->ui->checkEnableDefaultCategory->setChecked(d->m_payee.defaultAccountEnabled());
     d->ui->comboDefaultCategory->setSelected(d->m_payee.defaultAccountId());
 
     d->ui->payeeIdentifiers->setSource(d->m_payee);
 
     slotPayeeDataChanged();
 
     d->showTransactions();
 
   } catch (const MyMoneyException &e) {
-    qDebug("exception during display of payee: %s at %s:%ld", qPrintable(e.what()), qPrintable(e.file()), e.line());
+    qDebug("exception during display of payee: %s", e.what());
     d->ui->m_register->clear();
     d->m_selectedPayeesList.clear();
     d->m_payee = MyMoneyPayee();
   }
   d->m_allowEditing = true;
 }
 
 void KPayeesView::slotKeyListChanged()
 {
   Q_D(KPayeesView);
   bool rc = false;
   bool ignorecase = false;
   QStringList keys;
 
   d->m_payee.matchData(ignorecase, keys);
   if (d->ui->matchTypeCombo->currentData().toUInt() == MyMoneyPayee::matchKey) {
     rc |= (keys != d->ui->matchKeyEditList->items());
   }
   d->setDirty(rc);
 }
 
 void KPayeesView::slotPayeeDataChanged()
 {
   Q_D(KPayeesView);
   bool rc = false;
 
   if (d->ui->m_tabWidget->isEnabled()) {
     rc |= ((d->m_payee.email().isEmpty() != d->ui->emailEdit->text().isEmpty())
            || (!d->ui->emailEdit->text().isEmpty() && d->m_payee.email() != d->ui->emailEdit->text()));
     rc |= ((d->m_payee.address().isEmpty() != d->ui->addressEdit->toPlainText().isEmpty())
            || (!d->ui->addressEdit->toPlainText().isEmpty() && d->m_payee.address() != d->ui->addressEdit->toPlainText()));
     rc |= ((d->m_payee.postcode().isEmpty() != d->ui->postcodeEdit->text().isEmpty())
            || (!d->ui->postcodeEdit->text().isEmpty() && d->m_payee.postcode() != d->ui->postcodeEdit->text()));
     rc |= ((d->m_payee.telephone().isEmpty() != d->ui->telephoneEdit->text().isEmpty())
            || (!d->ui->telephoneEdit->text().isEmpty() && d->m_payee.telephone() != d->ui->telephoneEdit->text()));
     rc |= ((d->m_payee.name().isEmpty() != d->m_newName.isEmpty())
            || (!d->m_newName.isEmpty() && d->m_payee.name() != d->m_newName));
     rc |= ((d->m_payee.notes().isEmpty() != d->ui->notesEdit->toPlainText().isEmpty())
            || (!d->ui->notesEdit->toPlainText().isEmpty() && d->m_payee.notes() != d->ui->notesEdit->toPlainText()));
 
     bool ignorecase = false;
     QStringList keys;
 
     MyMoneyPayee::payeeMatchType type = d->m_payee.matchData(ignorecase, keys);
     rc |= (static_cast<unsigned int>(type) != d->ui->matchTypeCombo->currentData().toUInt());
 
     d->ui->checkMatchIgnoreCase->setEnabled(false);
     d->ui->matchKeyEditList->setEnabled(false);
 
     if (d->ui->matchTypeCombo->currentData().toUInt() != MyMoneyPayee::matchDisabled) {
       d->ui->checkMatchIgnoreCase->setEnabled(true);
       // if we turn matching on, we default to 'ignore case'
       // TODO maybe make the default a user option
       if (type == MyMoneyPayee::matchDisabled && d->ui->matchTypeCombo->currentData().toUInt() != MyMoneyPayee::matchDisabled)
         d->ui->checkMatchIgnoreCase->setChecked(true);
       rc |= (ignorecase != d->ui->checkMatchIgnoreCase->isChecked());
       if (d->ui->matchTypeCombo->currentData().toUInt() == MyMoneyPayee::matchKey) {
         d->ui->matchKeyEditList->setEnabled(true);
         rc |= (keys != d->ui->matchKeyEditList->items());
       }
     }
 
     rc |= (d->ui->checkEnableDefaultCategory->isChecked() != d->m_payee.defaultAccountEnabled());
     if (d->ui->checkEnableDefaultCategory->isChecked()) {
       d->ui->comboDefaultCategory->setEnabled(true);
       d->ui->labelDefaultCategory->setEnabled(true);
       // this is only going to understand the first in the list of selected accounts
       if (d->ui->comboDefaultCategory->getSelected().isEmpty()) {
         rc |= !d->m_payee.defaultAccountId().isEmpty();
       } else {
         QString temp = d->ui->comboDefaultCategory->getSelected();
         rc |= (temp.isEmpty() != d->m_payee.defaultAccountId().isEmpty())
               || (!d->m_payee.defaultAccountId().isEmpty() && temp != d->m_payee.defaultAccountId());
       }
     } else {
       d->ui->comboDefaultCategory->setEnabled(false);
       d->ui->labelDefaultCategory->setEnabled(false);
     }
 
     rc |= (d->m_payee.payeeIdentifiers() != d->ui->payeeIdentifiers->identifiers());
   }
   d->setDirty(rc);
 }
 
 void KPayeesView::slotUpdatePayee()
 {
   Q_D(KPayeesView);
   if (d->isDirty()) {
     MyMoneyFileTransaction ft;
     d->setDirty(false);
     try {
       d->m_payee.setName(d->m_newName);
       d->m_payee.setAddress(d->ui->addressEdit->toPlainText());
       d->m_payee.setPostcode(d->ui->postcodeEdit->text());
       d->m_payee.setTelephone(d->ui->telephoneEdit->text());
       d->m_payee.setEmail(d->ui->emailEdit->text());
       d->m_payee.setNotes(d->ui->notesEdit->toPlainText());
       d->m_payee.setMatchData(static_cast<MyMoneyPayee::payeeMatchType>(d->ui->matchTypeCombo->currentData().toUInt()), d->ui->checkMatchIgnoreCase->isChecked(), d->ui->matchKeyEditList->items());
       d->m_payee.setDefaultAccountId();
       d->m_payee.resetPayeeIdentifiers(d->ui->payeeIdentifiers->identifiers());
 
       if (d->ui->checkEnableDefaultCategory->isChecked()) {
         QString temp;
         if (!d->ui->comboDefaultCategory->getSelected().isEmpty()) {
           temp = d->ui->comboDefaultCategory->getSelected();
           d->m_payee.setDefaultAccountId(temp);
         }
       }
 
       MyMoneyFile::instance()->modifyPayee(d->m_payee);
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(0, i18n("Unable to modify payee"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify payee"), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KPayeesView::slotSyncAddressBook()
 {
   Q_D(KPayeesView);
   if (d->m_payeeRows.isEmpty()) {                            // empty list means no syncing is pending...
     foreach (auto item, d->ui->m_payeesList->selectedItems()) {
       d->m_payeeRows.append(d->ui->m_payeesList->row(item));        // ...so initialize one
     }
     d->ui->m_payeesList->clearSelection();                       // otherwise slotSelectPayee will be run after every payee update
 //    d->ui->m_syncAddressbook->setEnabled(false);                 // disallow concurrent syncs
   }
 
   if (d->m_payeeRows.count() <= d->m_payeeRow) {
     if (auto item = dynamic_cast<KPayeeListItem*>(d->ui->m_payeesList->currentItem())) { // update ui if something is selected
       d->m_payee = item->payee();
       d->ui->addressEdit->setText(d->m_payee.address());
       d->ui->postcodeEdit->setText(d->m_payee.postcode());
       d->ui->telephoneEdit->setText(d->m_payee.telephone());
     }
     d->m_payeeRows.clear();  // that means end of sync
     d->m_payeeRow = 0;
     return;
   }
 
   if (auto item = dynamic_cast<KPayeeListItem*>(d->ui->m_payeesList->item(d->m_payeeRows.at(d->m_payeeRow))))
     d->m_payee = item->payee();
   ++d->m_payeeRow;
 
   d->m_contact->fetchContact(d->m_payee.email()); // search for payee's data in addressbook and receive it in slotContactFetched
 }
 
 void KPayeesView::slotContactFetched(const ContactData &identity)
 {
   Q_D(KPayeesView);
   if (!identity.email.isEmpty()) {  // empty e-mail means no identity fetched
     QString txt;
     if (!identity.street.isEmpty())
       txt.append(identity.street + '\n');
     if (!identity.locality.isEmpty()) {
       txt.append(identity.locality);
       if (!identity.postalCode.isEmpty())
         txt.append(' ' + identity.postalCode + '\n');
       else
         txt.append('\n');
     }
     if (!identity.country.isEmpty())
       txt.append(identity.country + '\n');
 
     if (!txt.isEmpty() && d->m_payee.address().compare(txt) != 0)
       d->m_payee.setAddress(txt);
 
     if (!identity.postalCode.isEmpty() && d->m_payee.postcode().compare(identity.postalCode) != 0)
       d->m_payee.setPostcode(identity.postalCode);
 
     if (!identity.phoneNumber.isEmpty() && d->m_payee.telephone().compare(identity.phoneNumber) != 0)
       d->m_payee.setTelephone(identity.phoneNumber);
 
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->modifyPayee(d->m_payee);
       ft.commit();
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(0, i18n("Unable to modify payee"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify payee"), QString::fromLatin1(e.what()));
     }
   }
 
   slotSyncAddressBook();  // process next payee
 }
 
 void KPayeesView::slotSendMail()
 {
   Q_D(KPayeesView);
   QRegularExpression re(".+@.+");
   if (re.match(d->m_payee.email()).hasMatch())
     QDesktopServices::openUrl(QUrl(QStringLiteral("mailto:?to=") + d->m_payee.email(), QUrl::TolerantMode));
 }
 
 void KPayeesView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KPayeesView);
         QTimer::singleShot(0, d->m_searchWidget, SLOT(setFocus()));
       }
       break;
 
     case eView::Action::ClosePayeeIdentifierSource:
       slotClosePayeeIdentifierSource();
       break;
 
     default:
       break;
   }
 }
 
 void KPayeesView::refresh()
 {
   Q_D(KPayeesView);
   if (isVisible()) {
     if (d->m_inSelection) {
       QTimer::singleShot(0, this, SLOT(refresh()));
     } else {
       d->loadPayees();
       d->m_needsRefresh = false;
     }
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KPayeesView::showEvent(QShowEvent* event)
 {
   Q_D(KPayeesView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Payees, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 
   QList<MyMoneyPayee> list;
   d->selectedPayees(list);
   emit selectObjects(list);
 }
 
 void KPayeesView::updatePayeeActions(const QList<MyMoneyPayee> &payees)
 {
   pActions[eMenu::Action::NewPayee]->setEnabled(true);
   const auto payeesCount = payees.count();
   auto b = payeesCount == 1 ? true : false;
   pActions[eMenu::Action::RenamePayee]->setEnabled(b);
   b = payeesCount > 1 ? true : false;
   pActions[eMenu::Action::MergePayee]->setEnabled(b);
   b = payeesCount == 0 ? false : true;
   pActions[eMenu::Action::DeletePayee]->setEnabled(b);
 }
 
 void KPayeesView::slotSelectTransaction()
 {
   Q_D(KPayeesView);
   auto list = d->ui->m_register->selectedItems();
   if (!list.isEmpty()) {
     const auto t = dynamic_cast<KMyMoneyRegister::Transaction*>(list[0]);
     if (t)
       emit selectByVariant(QVariantList {QVariant(t->split().accountId()), QVariant(t->transaction().id()) }, eView::Intent::ShowTransaction);
   }
 }
 
 void KPayeesView::slotSelectPayeeAndTransaction(const QString& payeeId, const QString& accountId, const QString& transactionId)
 {
   Q_D(KPayeesView);
   if (!isVisible())
     return;
 
   try {
     // clear filter
     d->m_searchWidget->clear();
     d->m_searchWidget->updateSearch();
 
     // deselect all other selected items
     QList<QListWidgetItem *> selectedItems = d->ui->m_payeesList->selectedItems();
     QList<QListWidgetItem *>::const_iterator payeesIt = selectedItems.constBegin();
     while (payeesIt != selectedItems.constEnd()) {
       if (auto item = dynamic_cast<KPayeeListItem*>(*payeesIt))
         item->setSelected(false);
       ++payeesIt;
     }
 
     // find the payee in the list
     QListWidgetItem* it;
     for (int i = 0; i < d->ui->m_payeesList->count(); ++i) {
       it = d->ui->m_payeesList->item(i);
       auto item = dynamic_cast<KPayeeListItem *>(it);
       if (item && item->payee().id() == payeeId) {
         d->ui->m_payeesList->scrollToItem(it, QAbstractItemView::PositionAtCenter);
 
         d->ui->m_payeesList->setCurrentItem(it);     // active item and deselect all others
         d->ui->m_payeesList->setCurrentRow(i, QItemSelectionModel::ClearAndSelect); // and select it
 
         //make sure the payee selection is updated and transactions are updated accordingly
         slotSelectPayee();
 
         KMyMoneyRegister::RegisterItem *registerItem = 0;
         for (i = 0; i < d->ui->m_register->rowCount(); ++i) {
           registerItem = d->ui->m_register->itemAtRow(i);
           if (auto t = dynamic_cast<KMyMoneyRegister::Transaction*>(registerItem)) {
             if (t->transaction().id() == transactionId && t->transaction().accountReferenced(accountId)) {
               d->ui->m_register->selectItem(registerItem);
               d->ui->m_register->ensureItemVisible(registerItem);
               break;
             }
           }
         }
         // quit out of outer for() loop
         break;
       }
     }
   } catch (const MyMoneyException &e) {
-    qWarning("Unexpected exception in KPayeesView::slotSelectPayeeAndTransaction %s", qPrintable(e.what()));
+    qWarning("Unexpected exception in KPayeesView::slotSelectPayeeAndTransaction %s", e.what());
   }
 }
 
 void KPayeesView::slotShowPayeesMenu(const QPoint& /*p*/)
 {
   Q_D(KPayeesView);
   if (dynamic_cast<KPayeeListItem*>(d->ui->m_payeesList->currentItem())) {
     slotSelectPayee();
     pMenus[eMenu::Menu::Payee]->exec(QCursor::pos());
   }
 }
 
 void KPayeesView::slotHelp()
 {
   KHelpClient::invokeHelp("details.payees");
 }
 
 void KPayeesView::slotChangeFilter(int index)
 {
   Q_D(KPayeesView);
   //update the filter type then reload the payees list
   d->m_payeeFilterType = index;
   d->loadPayees();
 }
 
 void KPayeesView::slotNewPayee()
 {
   QString id;
   KMyMoneyUtils::newPayee(i18n("New Payee"), id);
   slotSelectPayeeAndTransaction(id);
 }
 
 void KPayeesView::slotRenamePayee()
 {
   Q_D(KPayeesView);
   if (d->ui->m_payeesList->currentItem() && d->ui->m_payeesList->selectedItems().count() == 1) {
     slotStartRename(d->ui->m_payeesList->currentItem());
   }
 }
 
 void KPayeesView::slotDeletePayee()
 {
   Q_D(KPayeesView);
   if (d->m_selectedPayeesList.isEmpty())
     return; // shouldn't happen
 
   // get confirmation from user
   QString prompt;
   if (d->m_selectedPayeesList.size() == 1)
     prompt = i18n("<p>Do you really want to remove the payee <b>%1</b>?</p>", d->m_selectedPayeesList.front().name());
   else
     prompt = i18n("Do you really want to remove all selected payees?");
 
   if (KMessageBox::questionYesNo(this, prompt, i18n("Remove Payee")) == KMessageBox::No)
     return;
 
   d->payeeReassign(KPayeeReassignDlg::TypeDelete);
 }
 
 void KPayeesView::slotMergePayee()
 {
   Q_D(KPayeesView);
   if (d->m_selectedPayeesList.size() < 1)
     return; // shouldn't happen
 
   if (KMessageBox::questionYesNo(this, i18n("<p>Do you really want to merge the selected payees?"),
                                  i18n("Merge Payees")) == KMessageBox::No)
     return;
 
   if (d->payeeReassign(KPayeeReassignDlg::TypeMerge))
     // clean selection since we just deleted the selected payees
     d->m_selectedPayeesList.clear();
 }
diff --git a/kmymoney/views/kpayeesview_p.h b/kmymoney/views/kpayeesview_p.h
index ca1dcda36..f1acd8381 100644
--- a/kmymoney/views/kpayeesview_p.h
+++ b/kmymoney/views/kpayeesview_p.h
@@ -1,763 +1,761 @@
 /***************************************************************************
                           kpayeesview_p.h
                           ---------------
     begin                : Thu Jan 24 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <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>
                            Andreas Nicolai <Andreas.Nicolai@gmx.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KPAYEESVIEW_P_H
 #define KPAYEESVIEW_P_H
 
 #include "kpayeesview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QMap>
 #include <QList>
 #include <QTimer>
 #include <QDesktopServices>
 #include <QIcon>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KHelpClient>
 #include <KSharedConfig>
 #include <KListWidgetSearchLine>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <config-kmymoney.h>
 #include "ui_kpayeesview.h"
 #include "kmymoneyviewbase_p.h"
 #include "kmymoneyutils.h"
 #include "kmymoneymvccombo.h"
 #include "mymoneypayee.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneytransactionfilter.h"
 #include "kmymoneysettings.h"
 #include "kpayeereassigndlg.h"
 #include "models.h"
 #include "accountsmodel.h"
 #include "mymoneysecurity.h"
 #include "mymoneyschedule.h"
 #include "mymoneycontact.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneysplit.h"
 #include "mymoneyprice.h"
 #include "mymoneytransaction.h"
 #include "icons/icons.h"
 #include "transaction.h"
 #include "widgetenums.h"
 #include "mymoneyenums.h"
 #include "modelenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 // *** KPayeeListItem Implementation ***
 
 class KPayeeListItem : public QListWidgetItem
 {
 public:
   /**
     * Constructor to be used to construct a payee entry object.
     *
     * @param parent pointer to the QListWidget object this entry should be
     *               added to.
     * @param payee const reference to MyMoneyPayee for which
     *               the QListWidget entry is constructed
     */
   explicit KPayeeListItem(QListWidget *parent, const MyMoneyPayee& payee) :
     QListWidgetItem(parent, QListWidgetItem::UserType),
     m_payee(payee)
   {
     setText(payee.name());
     // allow in column rename
     setFlags(Qt::ItemIsEditable | Qt::ItemIsSelectable | Qt::ItemIsEnabled);
   }
 
   ~KPayeeListItem()
   {
   }
 
   const MyMoneyPayee& payee() const {
     return m_payee;
   }
 
 private:
   MyMoneyPayee  m_payee;
 };
 
 enum filterTypeE { eAllPayees = 0, eReferencedPayees = 1, eUnusedPayees = 2 };
 
 class KPayeesViewPrivate : public KMyMoneyViewBasePrivate
 {
   Q_DECLARE_PUBLIC(KPayeesView)
 
 public:
   explicit KPayeesViewPrivate(KPayeesView *qq) :
     KMyMoneyViewBasePrivate(),
     q_ptr(qq),
     ui(new Ui::KPayeesView),
     m_contact(nullptr),
     m_payeeRow(0),
     m_needLoad(true),
     m_searchWidget(nullptr),
     m_inSelection(false),
     m_allowEditing(true),
     m_payeeFilterType(0),
     m_filterProxyModel(nullptr)
   {
   }
 
   ~KPayeesViewPrivate()
   {
     if(!m_needLoad) {
       // remember the splitter settings for startup
       auto grp = KSharedConfig::openConfig()->group("Last Use Settings");
       grp.writeEntry("KPayeesViewSplitterSize", ui->m_splitter->saveState());
       grp.sync();
     }
     delete ui;
   }
 
   void init()
   {
     Q_Q(KPayeesView);
     m_needLoad = false;
     ui->setupUi(q);
 
     m_contact = new MyMoneyContact(q);
     m_filterProxyModel = new AccountNamesFilterProxyModel(q);
     m_filterProxyModel->setHideEquityAccounts(!KMyMoneySettings::expertMode());
     m_filterProxyModel->addAccountGroup(QVector<eMyMoney::Account::Type> {eMyMoney::Account::Type::Asset, eMyMoney::Account::Type::Liability, eMyMoney::Account::Type::Income, eMyMoney::Account::Type::Expense, eMyMoney::Account::Type::Equity});
 
     auto const model = Models::instance()->accountsModel();
     m_filterProxyModel->setSourceModel(model);
     m_filterProxyModel->setSourceColumns(model->getColumns());
     m_filterProxyModel->sort((int)eAccountsModel::Column::Account);
     ui->comboDefaultCategory->setModel(m_filterProxyModel);
 
     ui->matchTypeCombo->addItem(i18nc("@item No matching", "No matching"), MyMoneyPayee::matchDisabled);
     ui->matchTypeCombo->addItem(i18nc("@item Match Payees name partially", "Match Payees name (partial)"), MyMoneyPayee::matchName);
     ui->matchTypeCombo->addItem(i18nc("@item Match Payees name exactly", "Match Payees name (exact)"), MyMoneyPayee::matchNameExact);
     ui->matchTypeCombo->addItem(i18nc("@item Search match in list", "Match on a name listed below"), MyMoneyPayee::matchKey);
 
     // create the searchline widget
     // and insert it into the existing layout
     m_searchWidget = new KListWidgetSearchLine(q, ui->m_payeesList);
     m_searchWidget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed));
     ui->m_payeesList->setContextMenuPolicy(Qt::CustomContextMenu);
     ui->m_listTopHLayout->insertWidget(0, m_searchWidget);
 
     //load the filter type
     ui->m_filterBox->addItem(i18nc("@item Show all payees", "All"));
     ui->m_filterBox->addItem(i18nc("@item Show only used payees", "Used"));
     ui->m_filterBox->addItem(i18nc("@item Show only unused payees", "Unused"));
     ui->m_filterBox->setSizeAdjustPolicy(QComboBox::AdjustToContents);
 
     ui->m_newButton->setIcon(Icons::get(Icon::ListAddUser));
     ui->m_renameButton->setIcon(Icons::get(Icon::UserProperties));
     ui->m_deleteButton->setIcon(Icons::get(Icon::ListRemoveUser));
     ui->m_mergeButton->setIcon(Icons::get(Icon::Merge));
     ui->m_updateButton->setIcon(Icons::get(Icon::DialogOK));
     ui->m_syncAddressbook->setIcon(Icons::get(Icon::Refresh));
     ui->m_sendMail->setIcon(Icons::get(Icon::MailMessage));
 
     ui->m_updateButton->setEnabled(false);
     ui->m_syncAddressbook->setEnabled(false);
     #ifndef KMM_ADDRESSBOOK_FOUND
     ui->m_syncAddressbook->hide();
     #endif
     ui->matchTypeCombo->setCurrentIndex(0);
 
     ui->checkMatchIgnoreCase->setEnabled(false);
 
     ui->checkEnableDefaultCategory->setChecked(false);
     ui->labelDefaultCategory->setEnabled(false);
     ui->comboDefaultCategory->setEnabled(false);
 
     QList<eWidgets::eTransaction::Column> cols {
     eWidgets::eTransaction::Column::Date,
     eWidgets::eTransaction::Column::Account,
     eWidgets::eTransaction::Column::Detail,
     eWidgets::eTransaction::Column::ReconcileFlag,
     eWidgets::eTransaction::Column::Payment,
     eWidgets::eTransaction::Column::Deposit};
     ui->m_register->setupRegister(MyMoneyAccount(), cols);
     ui->m_register->setSelectionMode(QTableWidget::SingleSelection);
     ui->m_register->setDetailsColumnType(eWidgets::eRegister::DetailColumn::AccountFirst);
     ui->m_balanceLabel->hide();
 
     q->connect(m_contact, &MyMoneyContact::contactFetched, q, &KPayeesView::slotContactFetched);
 
     q->connect(ui->m_payeesList, static_cast<void (QListWidget::*)(QListWidgetItem*, QListWidgetItem*)>(&QListWidget::currentItemChanged), q, static_cast<void (KPayeesView::*)(QListWidgetItem*, QListWidgetItem*)>(&KPayeesView::slotSelectPayee));
     q->connect(ui->m_payeesList, &QListWidget::itemSelectionChanged, q,   static_cast<void (KPayeesView::*)()>(&KPayeesView::slotSelectPayee));
     q->connect(ui->m_payeesList, &QListWidget::itemDoubleClicked, q,      &KPayeesView::slotStartRename);
     q->connect(ui->m_payeesList, &QListWidget::itemChanged, q,            &KPayeesView::slotRenameSinglePayee);
     q->connect(ui->m_payeesList, &QWidget::customContextMenuRequested, q, &KPayeesView::slotShowPayeesMenu);
 
     q->connect(ui->m_newButton,     &QAbstractButton::clicked, q, &KPayeesView::slotNewPayee);
     q->connect(ui->m_renameButton,  &QAbstractButton::clicked, q, &KPayeesView::slotRenamePayee);
     q->connect(ui->m_deleteButton,  &QAbstractButton::clicked, q, &KPayeesView::slotDeletePayee);
     q->connect(ui->m_mergeButton,   &QAbstractButton::clicked, q, &KPayeesView::slotMergePayee);
 
     q->connect(ui->addressEdit,   &QTextEdit::textChanged, q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->postcodeEdit,  &QLineEdit::textChanged, q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->telephoneEdit, &QLineEdit::textChanged, q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->emailEdit,     &QLineEdit::textChanged, q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->notesEdit,     &QTextEdit::textChanged, q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->matchKeyEditList, &KEditListWidget::changed, q, &KPayeesView::slotKeyListChanged);
 
     q->connect(ui->matchTypeCombo, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), q, &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->checkMatchIgnoreCase, &QAbstractButton::toggled, q, &KPayeesView::slotPayeeDataChanged);
 
     q->connect(ui->checkEnableDefaultCategory,  &QAbstractButton::toggled, q,               &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->comboDefaultCategory,        &KMyMoneyAccountCombo::accountSelected, q,  &KPayeesView::slotPayeeDataChanged);
     q->connect(ui->buttonSuggestACategory,      &QAbstractButton::clicked, q,               &KPayeesView::slotChooseDefaultAccount);
 
     q->connect(ui->m_updateButton,    &QAbstractButton::clicked, q, &KPayeesView::slotUpdatePayee);
     q->connect(ui->m_syncAddressbook, &QAbstractButton::clicked, q, &KPayeesView::slotSyncAddressBook);
     q->connect(ui->m_helpButton,      &QAbstractButton::clicked, q, &KPayeesView::slotHelp);
     q->connect(ui->m_sendMail,        &QAbstractButton::clicked, q, &KPayeesView::slotSendMail);
 
     q->connect(ui->m_register, &KMyMoneyRegister::Register::editTransaction, q, &KPayeesView::slotSelectTransaction);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KPayeesView::refresh);
 
     q->connect(ui->m_filterBox, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), q, &KPayeesView::slotChangeFilter);
 
     q->connect(ui->payeeIdentifiers, &KPayeeIdentifierView::dataChanged, q, &KPayeesView::slotPayeeDataChanged);
 
     // use the size settings of the last run (if any)
     KConfigGroup grp = KSharedConfig::openConfig()->group("Last Use Settings");
     ui->m_splitter->restoreState(grp.readEntry("KPayeesViewSplitterSize", QByteArray()));
     ui->m_splitter->setChildrenCollapsible(false);
 
     //At start we haven't any payee selected
     ui->m_tabWidget->setEnabled(false); // disable tab widget
     ui->m_deleteButton->setEnabled(false); //disable delete, rename and merge buttons
     ui->m_renameButton->setEnabled(false);
     ui->m_mergeButton->setEnabled(false);
     m_payee = MyMoneyPayee(); // make sure we don't access an undefined payee
     clearItemData();
   }
 
   void loadPayees()
   {
     Q_Q(KPayeesView);
     if (m_inSelection)
       return;
 
     QMap<QString, bool> isSelected;
     QString id;
     MyMoneyFile* file = MyMoneyFile::instance();
 
     // remember which items are selected in the list
     QList<QListWidgetItem *> selectedItems = ui->m_payeesList->selectedItems();
     QList<QListWidgetItem *>::const_iterator payeesIt = selectedItems.constBegin();
 
     while (payeesIt != selectedItems.constEnd()) {
       KPayeeListItem* item = dynamic_cast<KPayeeListItem*>(*payeesIt);
       if (item)
         isSelected[item->payee().id()] = true;
       ++payeesIt;
     }
 
     // keep current selected item
     KPayeeListItem *currentItem = static_cast<KPayeeListItem *>(ui->m_payeesList->currentItem());
     if (currentItem)
       id = currentItem->payee().id();
 
     m_allowEditing = false;
     // clear the list
     m_searchWidget->clear();
     m_searchWidget->updateSearch();
     ui->m_payeesList->clear();
     ui->m_register->clear();
     currentItem = 0;
 
     QList<MyMoneyPayee>list = file->payeeList();
     QList<MyMoneyPayee>::ConstIterator it;
 
     for (it = list.constBegin(); it != list.constEnd(); ++it) {
       if (m_payeeFilterType == eAllPayees ||
           (m_payeeFilterType == eReferencedPayees && file->isReferenced(*it)) ||
           (m_payeeFilterType == eUnusedPayees && !file->isReferenced(*it))) {
         KPayeeListItem* item = new KPayeeListItem(ui->m_payeesList, *it);
         if (item->payee().id() == id)
           currentItem = item;
         if (isSelected[item->payee().id()])
           item->setSelected(true);
       }
     }
     ui->m_payeesList->sortItems();
 
     if (currentItem) {
       ui->m_payeesList->setCurrentItem(currentItem);
       ui->m_payeesList->scrollToItem(currentItem);
     }
 
     m_filterProxyModel->invalidate();
     ui->comboDefaultCategory->expandAll();
 
     q->slotSelectPayee(0, 0);
     m_allowEditing = true;
   }
 
   void selectedPayees(QList<MyMoneyPayee>& payeesList) const
   {
     QList<QListWidgetItem *> selectedItems = ui->m_payeesList->selectedItems();
     QList<QListWidgetItem *>::ConstIterator itemsIt = selectedItems.constBegin();
     while (itemsIt != selectedItems.constEnd()) {
       KPayeeListItem* item = dynamic_cast<KPayeeListItem*>(*itemsIt);
       if (item)
         payeesList << item->payee();
       ++itemsIt;
     }
   }
 
   void ensurePayeeVisible(const QString& id)
   {
     for (int i = 0; i < ui->m_payeesList->count(); ++i) {
       KPayeeListItem* p = dynamic_cast<KPayeeListItem*>(ui->m_payeesList->item(0));
       if (p && p->payee().id() == id) {
         ui->m_payeesList->scrollToItem(p, QAbstractItemView::PositionAtCenter);
 
         ui->m_payeesList->setCurrentItem(p);      // active item and deselect all others
         ui->m_payeesList->setCurrentRow(i, QItemSelectionModel::ClearAndSelect);   // and select it
         break;
       }
     }
   }
 
   void clearItemData()
   {
     ui->addressEdit->setText(QString());
     ui->postcodeEdit->setText(QString());
     ui->telephoneEdit->setText(QString());
     ui->emailEdit->setText(QString());
     ui->notesEdit->setText(QString());
     showTransactions();
   }
 
   /**
     * This method loads the m_transactionList, clears
     * the m_TransactionPtrVector and rebuilds and sorts
     * it according to the current settings. Then it
     * loads the m_transactionView with the transaction data.
     */
   void showTransactions()
   {
     MyMoneyMoney balance;
     const auto file = MyMoneyFile::instance();
     MyMoneySecurity base = file->baseCurrency();
 
     // setup sort order
     ui->m_register->setSortOrder(KMyMoneySettings::sortSearchView());
 
     // clear the register
     ui->m_register->clear();
 
     if (m_selectedPayeesList.isEmpty() || !ui->m_tabWidget->isEnabled()) {
       ui->m_balanceLabel->setText(i18n("Balance: %1", balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
       return;
     }
 
     // setup the list and the pointer vector
     MyMoneyTransactionFilter filter;
 
     for (QList<MyMoneyPayee>::const_iterator it = m_selectedPayeesList.constBegin();
          it != m_selectedPayeesList.constEnd();
          ++it)
       filter.addPayee((*it).id());
 
     filter.setDateFilter(KMyMoneySettings::startDate().date(), QDate());
 
     // retrieve the list from the engine
     file->transactionList(m_transactionList, filter);
 
     // create the elements for the register
     QList<QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
     QMap<QString, int> uniqueMap;
     MyMoneyMoney deposit, payment;
 
     int splitCount = 0;
     bool balanceAccurate = true;
     for (it = m_transactionList.constBegin(); it != m_transactionList.constEnd(); ++it) {
       const MyMoneySplit& split = (*it).second;
       MyMoneyAccount acc = file->account(split.accountId());
       ++splitCount;
       uniqueMap[(*it).first.id()]++;
 
       KMyMoneyRegister::Register::transactionFactory(ui->m_register, (*it).first, (*it).second, uniqueMap[(*it).first.id()]);
 
       // take care of foreign currencies
       MyMoneyMoney val = split.shares().abs();
       if (acc.currencyId() != base.id()) {
         const MyMoneyPrice &price = file->price(acc.currencyId(), base.id());
         // in case the price is valid, we use it. Otherwise, we keep
         // a flag that tells us that the balance is somewhat inaccurate
         if (price.isValid()) {
           val *= price.rate(base.id());
         } else {
           balanceAccurate = false;
         }
       }
 
       if (split.shares().isNegative()) {
         payment += val;
       } else {
         deposit += val;
       }
     }
     balance = deposit - payment;
 
     // add the group markers
     ui->m_register->addGroupMarkers();
 
     // sort the transactions according to the sort setting
     ui->m_register->sortItems();
 
     // remove trailing and adjacent markers
     ui->m_register->removeUnwantedGroupMarkers();
 
     ui->m_register->updateRegister(true);
 
     // we might end up here with updates disabled on the register so
     // make sure that we enable updates here
     ui->m_register->setUpdatesEnabled(true);
     ui->m_balanceLabel->setText(i18n("Balance: %1%2",
                                  balanceAccurate ? "" : "~",
                                  balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
   }
 
   /**
     * Implement common task when deleting or merging payees
     */
   bool payeeReassign(int type)
   {
     Q_Q(KPayeesView);
     if (!(type >= 0 && type < KPayeeReassignDlg::TypeCount))
       return false;
 
     const auto file = MyMoneyFile::instance();
 
     MyMoneyFileTransaction ft;
     try {
       // create a transaction filter that contains all payees selected for removal
       MyMoneyTransactionFilter f = MyMoneyTransactionFilter();
       for (QList<MyMoneyPayee>::const_iterator it = m_selectedPayeesList.constBegin();
            it != m_selectedPayeesList.constEnd(); ++it) {
         f.addPayee((*it).id());
       }
       // request a list of all transactions that still use the payees in question
       QList<MyMoneyTransaction> translist = file->transactionList(f);
   //     qDebug() << "[KPayeesView::slotDeletePayee]  " << translist.count() << " transaction still assigned to payees";
 
       // now get a list of all schedules that make use of one of the payees
       QList<MyMoneySchedule> used_schedules;
       foreach (const auto schedule, file->scheduleList()) {
         // loop over all splits in the transaction of the schedule
         foreach (const auto split, schedule.transaction().splits()) {
           // is the payee in the split to be deleted?
           if (payeeInList(m_selectedPayeesList, split.payeeId())) {
             used_schedules.push_back(schedule); // remember this schedule
             break;
           }
         }
       }
   //     qDebug() << "[KPayeesView::slotDeletePayee]  " << used_schedules.count() << " schedules use one of the selected payees";
 
       // and a list of all loan accounts that references one of the payees
       QList<MyMoneyAccount> allAccounts;
       QList<MyMoneyAccount> usedAccounts;
       file->accountList(allAccounts);
       foreach (const MyMoneyAccount &account, allAccounts) {
         if (account.isLoan()) {
           MyMoneyAccountLoan loanAccount(account);
           foreach (const MyMoneyPayee &payee, m_selectedPayeesList) {
             if (loanAccount.hasReferenceTo(payee.id())) {
               usedAccounts.append(account);
             }
           }
         }
       }
 
 
       MyMoneyPayee newPayee;
       bool addToMatchList = false;
       // if at least one payee is still referenced, we need to reassign its transactions first
       if (!translist.isEmpty() || !used_schedules.isEmpty() || !usedAccounts.isEmpty()) {
 
         // first create list with all non-selected payees
         QList<MyMoneyPayee> remainingPayees;
         if (type == KPayeeReassignDlg::TypeMerge) {
           remainingPayees = m_selectedPayeesList;
         } else {
           remainingPayees = file->payeeList();
           QList<MyMoneyPayee>::iterator it_p;
           for (it_p = remainingPayees.begin(); it_p != remainingPayees.end();) {
             if (m_selectedPayeesList.contains(*it_p)) {
               it_p = remainingPayees.erase(it_p);
             } else {
               ++it_p;
             }
           }
         }
 
         // show error message if no payees remain
         if (remainingPayees.isEmpty()) {
           KMessageBox::sorry(q, i18n("At least one transaction/scheduled transaction or loan account is still referenced by a payee. "
                                         "Currently you have all payees selected. However, at least one payee must remain so "
                                         "that the transaction/scheduled transaction or loan account can be reassigned."));
           return false;
         }
 
         // show transaction reassignment dialog
         KPayeeReassignDlg * dlg = new KPayeeReassignDlg(static_cast<KPayeeReassignDlg::OperationType>(type), q);
         KMyMoneyMVCCombo::setSubstringSearchForChildren(dlg, !KMyMoneySettings::stringMatchFromStart());
         QString payee_id = dlg->show(remainingPayees);
         addToMatchList = dlg->addToMatchList();
         delete dlg; // and kill the dialog
         if (payee_id.isEmpty())
           return false; // the user aborted the dialog, so let's abort as well
 
         // try to get selected payee. If not possible and we are merging payees,
         // then we create a new one
         try {
           newPayee = file->payee(payee_id);
         } catch (const MyMoneyException &) {
           if (type == KPayeeReassignDlg::TypeMerge) {
             // it's ok to use payee_id for both arguments since the first is const,
             // so it's garantee not to change its content
             if (!KMyMoneyUtils::newPayee(payee_id, payee_id))
               return false; // the user aborted the dialog, so let's abort as well
             newPayee = file->payee(payee_id);
           } else {
             return false;
           }
         }
 
         // TODO : check if we have a report that explicitively uses one of our payees
         //        and issue an appropriate warning
         try {
           // now loop over all transactions and reassign payee
           for (auto& transaction : translist) {
             // create a copy of the splits list in the transaction
             // loop over all splits
             for (auto& split : transaction.splits()) {
               // if the split is assigned to one of the selected payees, we need to modify it
               if (payeeInList(m_selectedPayeesList, split.payeeId())) {
                 split.setPayeeId(payee_id); // first modify payee in current split
                 // then modify the split in our local copy of the transaction list
                 transaction.modifySplit(split); // this does not modify the list object 'splits'!
               }
             } // for - Splits
             file->modifyTransaction(transaction);  // modify the transaction in the MyMoney object
           } // for - Transactions
 
           // now loop over all schedules and reassign payees
           for (auto& schedule : used_schedules) {
             // create copy of transaction in current schedule
             auto trans = schedule.transaction();
             // create copy of lists of splits
             for (auto& split : trans.splits()) {
               if (payeeInList(m_selectedPayeesList, split.payeeId())) {
                 split.setPayeeId(payee_id);
                 trans.modifySplit(split); // does not modify the list object 'splits'!
               }
             } // for - Splits
             // store transaction in current schedule
             schedule.setTransaction(trans);
             file->modifySchedule(schedule);  // modify the schedule in the MyMoney engine
           } // for - Schedules
 
           // reassign the payees in the loans that reference the deleted payees
           foreach (const MyMoneyAccount &account, usedAccounts) {
             MyMoneyAccountLoan loanAccount(account);
             loanAccount.setPayee(payee_id);
             file->modifyAccount(loanAccount);
           }
 
         } catch (const MyMoneyException &e) {
-          KMessageBox::detailedSorry(q, i18n("Unable to reassign payee of transaction/split"),
-                                     i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+          KMessageBox::detailedSorry(q, i18n("Unable to reassign payee of transaction/split"), e.what());
         }
       } else { // if !translist.isEmpty()
         if (type == KPayeeReassignDlg::TypeMerge) {
           KMessageBox::sorry(q, i18n("Nothing to merge."), i18n("Merge Payees"));
           return false;
         }
       }
 
       bool ignorecase;
       QStringList payeeNames;
       MyMoneyPayee::payeeMatchType matchType = newPayee.matchData(ignorecase, payeeNames);
       QStringList deletedPayeeNames;
 
       // now loop over all selected payees and remove them
       for (QList<MyMoneyPayee>::iterator it = m_selectedPayeesList.begin();
            it != m_selectedPayeesList.end(); ++it) {
         if (newPayee.id() != (*it).id()) {
           if (addToMatchList) {
             deletedPayeeNames << (*it).name();
           }
           file->removePayee(*it);
         }
       }
 
       // if we initially have no matching turned on, we just ignore the case (default)
       if (matchType == MyMoneyPayee::matchDisabled)
         ignorecase = true;
 
       // update the destination payee if this was requested by the user
       if (addToMatchList && deletedPayeeNames.count() > 0) {
         // add new names to the list
         // TODO: it would be cool to somehow shrink the list to make better use
         //       of regular expressions at this point. For now, we leave this task
         //       to the user himeself.
         QStringList::const_iterator it_n;
         for (it_n = deletedPayeeNames.constBegin(); it_n != deletedPayeeNames.constEnd(); ++it_n) {
           if (matchType == MyMoneyPayee::matchKey) {
             // make sure we really need it and it is not caught by an existing regexp
             QStringList::const_iterator it_k;
             for (it_k = payeeNames.constBegin(); it_k != payeeNames.constEnd(); ++it_k) {
               QRegExp exp(*it_k, ignorecase ? Qt::CaseInsensitive : Qt::CaseSensitive);
               if (exp.indexIn(*it_n) != -1)
                 break;
             }
             if (it_k == payeeNames.constEnd())
               payeeNames << QRegExp::escape(*it_n);
           } else if (payeeNames.contains(*it_n) == 0)
             payeeNames << QRegExp::escape(*it_n);
         }
 
         // and update the payee in the engine context
         // make sure to turn on matching for this payee in the right mode
         newPayee.setMatchData(MyMoneyPayee::matchKey, ignorecase, payeeNames);
         file->modifyPayee(newPayee);
       }
       ft.commit();
 
       // If we just deleted the payees, they sure don't exist anymore
       m_selectedPayeesList.clear();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(q, i18n("Unable to remove payee(s)"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(q, i18n("Unable to remove payee(s)"), e.what());
     }
 
     return true;
   }
 
   /**
     * Check if a list contains a payee with a given id
     *
     * @param list const reference to value list
     * @param id const reference to id
     *
     * @retval true object has been found
     * @retval false object is not in list
     */
   bool payeeInList(const QList<MyMoneyPayee>& list, const QString& id) const
   {
     bool rc = false;
     QList<MyMoneyPayee>::const_iterator it_p = list.begin();
     while (it_p != list.end()) {
       if ((*it_p).id() == id) {
         rc = true;
         break;
       }
       ++it_p;
     }
     return rc;
   }
 
   /** Checks whether the currently selected payee is "dirty"
    * @return true, if payee is modified (is "dirty"); false otherwise
    */
   bool isDirty() const
   {
     return ui->m_updateButton->isEnabled();
   }
 
   /** Sets the payee's "dirty" (modified) status
    * @param dirty if true (default), payee will be set to dirty
    */
   void setDirty(bool dirty)
   {
     ui->m_updateButton->setEnabled(dirty);
   }
 
   KPayeesView      *q_ptr;
   Ui::KPayeesView  *ui;
   MyMoneyPayee      m_payee;
   QString           m_newName;
   MyMoneyContact   *m_contact;
   int               m_payeeRow;
   QList<int>        m_payeeRows;
 
   /**
     * List of selected payees
     */
   QList<MyMoneyPayee> m_selectedPayeesList;
 
   /**
     * q member holds a list of all transactions
     */
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > m_transactionList;
 
   /**
     * q member holds the load state of page
     */
   bool m_needLoad;
 
   /**
     * Search widget for the list
     */
   KListWidgetSearchLine*  m_searchWidget;
 
   /**
    * Semaphore to suppress loading during selection
    */
   bool m_inSelection;
 
   /**
    * q signals whether a payee can be edited
    **/
   bool m_allowEditing;
 
   /**
     * q holds the filter type
     */
   int m_payeeFilterType;
 
   AccountNamesFilterProxyModel *m_filterProxyModel;
 };
 
 #endif
diff --git a/kmymoney/views/kscheduledview.cpp b/kmymoney/views/kscheduledview.cpp
index 456315af5..500e71a75 100644
--- a/kmymoney/views/kscheduledview.cpp
+++ b/kmymoney/views/kscheduledview.cpp
@@ -1,468 +1,468 @@
 /***************************************************************************
                           kscheduledview.cpp  -  description
                              -------------------
     begin                : Sun Jan 27 2002
     copyright            : (C) 2000-2002 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kscheduledview_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QTimer>
 #include <QPushButton>
 #include <QMenu>
 #include <QIcon>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KMessageBox>
 #include <KSharedConfig>
 #include <KTreeWidgetSearchLine>
 #include <KTreeWidgetSearchLineWidget>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kscheduledview.h"
 #include "keditloanwizard.h"
 #include "kmymoneyutils.h"
 #include "kmymoneysettings.h"
 #include "mymoneyexception.h"
 #include "kscheduletreeitem.h"
 #include "keditscheduledlg.h"
 #include "ktreewidgetfilterlinewidget.h"
 #include "icons/icons.h"
 #include "mymoneyutils.h"
 #include "mymoneyaccount.h"
 #include "mymoneymoney.h"
 #include "mymoneysecurity.h"
 #include "mymoneyschedule.h"
 #include "mymoneyfile.h"
 #include "mymoneypayee.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyenums.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 KScheduledView::KScheduledView(QWidget *parent) :
   KMyMoneyViewBase(*new KScheduledViewPrivate(this), parent)
 {
   typedef void(KScheduledView::*KScheduledViewFunc)();
   const QHash<eMenu::Action, KScheduledViewFunc> actionConnections {
     {eMenu::Action::NewSchedule,        &KScheduledView::slotNewSchedule},
     {eMenu::Action::EditSchedule,       &KScheduledView::slotEditSchedule},
     {eMenu::Action::DeleteSchedule,     &KScheduledView::slotDeleteSchedule},
     {eMenu::Action::DuplicateSchedule,  &KScheduledView::slotDuplicateSchedule},
     {eMenu::Action::EnterSchedule,      &KScheduledView::slotEnterSchedule},
     {eMenu::Action::SkipSchedule,       &KScheduledView::slotSkipSchedule},
   };
 
   for (auto a = actionConnections.cbegin(); a != actionConnections.cend(); ++a)
     connect(pActions[a.key()], &QAction::triggered, this, a.value());
 
   Q_D(KScheduledView);
   d->m_balanceWarning.reset(new KBalanceWarning(this));
 }
 
 KScheduledView::~KScheduledView()
 {
 }
 
 void KScheduledView::slotTimerDone()
 {
   Q_D(KScheduledView);
   QTreeWidgetItem* item;
 
   item = d->ui->m_scheduleTree->currentItem();
   if (item) {
     d->ui->m_scheduleTree->scrollToItem(item);
   }
 
   // force a repaint of all items to update the branches
   /*for (item = d->ui->m_scheduleTree->item(0); item != 0; item = d->ui->m_scheduleTree->item(d->ui->m_scheduleTree->row(item) + 1)) {
     d->ui->m_scheduleTree->repaintItem(item);
   }
   resize(width(), height() + 1);*/
 }
 
 void KScheduledView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KScheduledView);
         QTimer::singleShot(0, d->m_searchWidget->searchLine(), SLOT(setFocus()));
       }
       break;
 
     case eView::Action::EditSchedule:
       slotEditSchedule();
       break;
 
     default:
       break;
   }
 }
 
 void KScheduledView::refresh()
 {
   Q_D(KScheduledView);
   if (isVisible()) {
     d->ui->m_qbuttonNew->setEnabled(true);
 
     d->refreshSchedule(true, d->m_currentSchedule.id());
 
     d->m_needsRefresh = false;
     QTimer::singleShot(50, this, SLOT(slotRearrange()));
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KScheduledView::showEvent(QShowEvent* event)
 {
   Q_D(KScheduledView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Schedules, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   QWidget::showEvent(event);
 }
 
 void KScheduledView::updateActions(const MyMoneyObject& obj)
 {
   Q_D(KScheduledView);
   if (typeid(obj) != typeid(MyMoneySchedule) &&
       (obj.id().isEmpty() && d->m_currentSchedule.id().isEmpty())) // do not disable actions that were already disabled))
     return;
 
   const auto& sch = static_cast<const MyMoneySchedule&>(obj);
 
   const QVector<eMenu::Action> actionsToBeDisabled {
         eMenu::Action::EditSchedule, eMenu::Action::DuplicateSchedule, eMenu::Action::DeleteSchedule,
         eMenu::Action::EnterSchedule, eMenu::Action::SkipSchedule,
   };
 
   for (const auto& a : actionsToBeDisabled)
     pActions[a]->setEnabled(false);
 
   pActions[eMenu::Action::NewSchedule]->setEnabled(true);
 
   if (!sch.id().isEmpty()) {
     pActions[eMenu::Action::EditSchedule]->setEnabled(true);
     pActions[eMenu::Action::DuplicateSchedule]->setEnabled(true);
     pActions[eMenu::Action::DeleteSchedule]->setEnabled(!MyMoneyFile::instance()->isReferenced(sch));
     if (!sch.isFinished()) {
       pActions[eMenu::Action::EnterSchedule]->setEnabled(true);
       // a schedule with a single occurrence cannot be skipped
       if (sch.occurrence() != eMyMoney::Schedule::Occurrence::Once) {
         pActions[eMenu::Action::SkipSchedule]->setEnabled(true);
       }
     }
   }
   d->m_currentSchedule = sch;
 }
 
 eDialogs::ScheduleResultCode KScheduledView::enterSchedule(MyMoneySchedule& schedule, bool autoEnter, bool extendedKeys)
 {
   Q_D(KScheduledView);
   return d->enterSchedule(schedule, autoEnter, extendedKeys);
 }
 
 void KScheduledView::slotRearrange()
 {
   resizeEvent(0);
 }
 
 void KScheduledView::slotEnterOverdueSchedules(const MyMoneyAccount& acc)
 {
   Q_D(KScheduledView);
   const auto file = MyMoneyFile::instance();
   auto schedules = file->scheduleList(acc.id(), eMyMoney::Schedule::Type::Any, eMyMoney::Schedule::Occurrence::Any, eMyMoney::Schedule::PaymentType::Any, QDate(), QDate(), true);
   if (!schedules.isEmpty()) {
     if (KMessageBox::questionYesNo(this,
                                    i18n("KMyMoney has detected some overdue scheduled transactions for this account. Do you want to enter those scheduled transactions now?"),
                                    i18n("Scheduled transactions found")) == KMessageBox::Yes) {
 
       QMap<QString, bool> skipMap;
       bool processedOne;
       auto rc = eDialogs::ScheduleResultCode::Enter;
       do {
         processedOne = false;
         QList<MyMoneySchedule>::const_iterator it_sch;
         for (it_sch = schedules.constBegin(); (rc != eDialogs::ScheduleResultCode::Cancel) && (it_sch != schedules.constEnd()); ++it_sch) {
           MyMoneySchedule sch(*(it_sch));
 
           // and enter it if it is not on the skip list
           if (skipMap.find((*it_sch).id()) == skipMap.end()) {
             rc = d->enterSchedule(sch, false, true);
             if (rc == eDialogs::ScheduleResultCode::Ignore) {
               skipMap[(*it_sch).id()] = true;
             }
           }
         }
 
         // reload list (maybe this schedule needs to be added again)
         schedules = file->scheduleList(acc.id(), eMyMoney::Schedule::Type::Any, eMyMoney::Schedule::Occurrence::Any, eMyMoney::Schedule::PaymentType::Any, QDate(), QDate(), true);
       } while (processedOne);
     }
   }
   emit selectByObject(MyMoneySchedule(), eView::Intent::FinishEnteringOverdueScheduledTransactions);
 }
 
 void KScheduledView::slotSelectByObject(const MyMoneyObject& obj, eView::Intent intent)
 {
   switch(intent) {
     case eView::Intent::UpdateActions:
       updateActions(obj);
       break;
 
     case eView::Intent::StartEnteringOverdueScheduledTransactions:
       slotEnterOverdueSchedules(static_cast<const MyMoneyAccount&>(obj));
       break;
 
     case eView::Intent::OpenContextMenu:
       slotShowScheduleMenu(static_cast<const MyMoneySchedule&>(obj));
       break;
 
     default:
       break;
   }
 }
 
 void KScheduledView::customContextMenuRequested(const QPoint)
 {
   Q_D(KScheduledView);
   emit selectByObject(d->m_currentSchedule, eView::Intent::None);
   emit selectByObject(d->m_currentSchedule, eView::Intent::OpenContextMenu);
 }
 
 void KScheduledView::slotListItemExecuted(QTreeWidgetItem* item, int)
 {
   if (!item)
     return;
 
   try {
     const auto sch = item->data(0, Qt::UserRole).value<MyMoneySchedule>();
     emit selectByObject(sch, eView::Intent::None);
     emit selectByObject(sch, eView::Intent::OpenContextMenu);
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Error executing item"), e.what());
+    KMessageBox::detailedSorry(this, i18n("Error executing item"), QString::fromLatin1(e.what()));
   }
 }
 
 void KScheduledView::slotAccountActivated()
 {
   Q_D(KScheduledView);
   d->m_filterAccounts.clear();
 
   try {
 
     int accountCount = 0;
     MyMoneyFile* file = MyMoneyFile::instance();
 
     // extract a list of all accounts under the asset and liability groups
     // and sort them by name
     QList<MyMoneyAccount> list;
     QStringList accountList = file->asset().accountList();
     accountList.append(file->liability().accountList());
     file->accountList(list, accountList, true);
     qStableSort(list.begin(), list.end(), KScheduledViewPrivate::accountNameLessThan);
 
     QList<MyMoneyAccount>::ConstIterator it_a;
     for (it_a = list.constBegin(); it_a != list.constEnd(); ++it_a) {
       if (!(*it_a).isClosed()) {
         if (!d->m_kaccPopup->actions().value(accountCount)->isChecked()) {
           d->m_filterAccounts.append((*it_a).id());
         }
         ++accountCount;
       }
     }
 
     d->refreshSchedule(false, d->m_currentSchedule.id());
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedError(this, i18n("Unable to filter account"), e.what());
+    KMessageBox::detailedError(this, i18n("Unable to filter account"), QString::fromLatin1(e.what()));
   }
 }
 
 void KScheduledView::slotListViewExpanded(QTreeWidgetItem* item)
 {
   Q_D(KScheduledView);
   if (item) {
     if (item->text(0) == i18n("Bills"))
       d->m_openBills = true;
     else if (item->text(0) == i18n("Deposits"))
       d->m_openDeposits = true;
     else if (item->text(0) == i18n("Transfers"))
       d->m_openTransfers = true;
     else if (item->text(0) == i18n("Loans"))
       d->m_openLoans = true;
   }
 }
 
 void KScheduledView::slotListViewCollapsed(QTreeWidgetItem* item)
 {
   Q_D(KScheduledView);
   if (item) {
     if (item->text(0) == i18n("Bills"))
       d->m_openBills = false;
     else if (item->text(0) == i18n("Deposits"))
       d->m_openDeposits = false;
     else if (item->text(0) == i18n("Transfers"))
       d->m_openTransfers = false;
     else if (item->text(0) == i18n("Loans"))
       d->m_openLoans = false;
   }
 }
 
 void KScheduledView::slotSelectSchedule(const QString& schedule)
 {
   Q_D(KScheduledView);
   d->refreshSchedule(true, schedule);
 }
 
 void KScheduledView::slotShowScheduleMenu(const MyMoneySchedule& sch)
 {
   Q_UNUSED(sch)
   pMenus[eMenu::Menu::Schedule]->exec(QCursor::pos());
 }
 
 void KScheduledView::slotSetSelectedItem()
 {
   Q_D(KScheduledView);
   MyMoneySchedule sch;
   const auto item = d->ui->m_scheduleTree->currentItem();
   if (item) {
     try {
       sch = item->data(0, Qt::UserRole).value<MyMoneySchedule>();
     } catch (const MyMoneyException &e) {
-      qDebug("KScheduledView::slotSetSelectedItem: %s", qPrintable(e.what()));
+      qDebug("KScheduledView::slotSetSelectedItem: %s", e.what());
     }
   }
 
   emit selectByObject(sch, eView::Intent::None);
 }
 
 void KScheduledView::slotNewSchedule()
 {
   KEditScheduleDlg::newSchedule(MyMoneyTransaction(), eMyMoney::Schedule::Occurrence::Monthly);
 }
 
 void KScheduledView::slotEditSchedule()
 {
   Q_D(KScheduledView);
   KEditScheduleDlg::editSchedule(d->m_currentSchedule);
 }
 
 void KScheduledView::slotDeleteSchedule()
 {
   Q_D(KScheduledView);
   if (!d->m_currentSchedule.id().isEmpty()) {
     MyMoneyFileTransaction ft;
     try {
       MyMoneySchedule sched = MyMoneyFile::instance()->schedule(d->m_currentSchedule.id());
       QString msg = i18n("<p>Are you sure you want to delete the scheduled transaction <b>%1</b>?</p>", d->m_currentSchedule.name());
       if (sched.type() == eMyMoney::Schedule::Type::LoanPayment) {
         msg += QString(" ");
         msg += i18n("In case of loan payments it is currently not possible to recreate the scheduled transaction.");
       }
       if (KMessageBox::questionYesNo(this, msg) == KMessageBox::No)
         return;
 
       MyMoneyFile::instance()->removeSchedule(sched);
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to remove scheduled transaction '%1'", d->m_currentSchedule.name()), e.what());
+      KMessageBox::detailedSorry(this, i18n("Unable to remove scheduled transaction '%1'", d->m_currentSchedule.name()), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KScheduledView::slotDuplicateSchedule()
 {
   Q_D(KScheduledView);
   // since we may jump here via code, we have to make sure to react only
   // if the action is enabled
   if (pActions[eMenu::Action::DuplicateSchedule]->isEnabled()) {
     MyMoneySchedule sch = d->m_currentSchedule;
     sch.clearId();
     sch.setLastPayment(QDate());
     sch.setName(i18nc("Copy of scheduled transaction name", "Copy of %1", sch.name()));
     // make sure that we set a valid next due date if the original next due date is invalid
     if (!sch.nextDueDate().isValid())
       sch.setNextDueDate(QDate::currentDate());
 
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->addSchedule(sch);
       ft.commit();
 
       // select the new schedule in the view
       if (!d->m_currentSchedule.id().isEmpty())
         emit selectByObject(sch, eView::Intent::None);
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to duplicate scheduled transaction: '%1'", d->m_currentSchedule.name()), e.what());
+      KMessageBox::detailedSorry(this, i18n("Unable to duplicate scheduled transaction: '%1'", d->m_currentSchedule.name()), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KScheduledView::slotEnterSchedule()
 {
   Q_D(KScheduledView);
   if (!d->m_currentSchedule.id().isEmpty()) {
     try {
       auto schedule = MyMoneyFile::instance()->schedule(d->m_currentSchedule.id());
       d->enterSchedule(schedule);
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unknown scheduled transaction '%1'", d->m_currentSchedule.name()), e.what());
+      KMessageBox::detailedSorry(this, i18n("Unknown scheduled transaction '%1'", d->m_currentSchedule.name()), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KScheduledView::slotSkipSchedule()
 {
   Q_D(KScheduledView);
   if (!d->m_currentSchedule.id().isEmpty()) {
     try {
       auto schedule = MyMoneyFile::instance()->schedule(d->m_currentSchedule.id());
       d->skipSchedule(schedule);
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unknown scheduled transaction '%1'", d->m_currentSchedule.name()), e.what());
+      KMessageBox::detailedSorry(this, i18n("Unknown scheduled transaction '%1'", d->m_currentSchedule.name()), QString::fromLatin1(e.what()));
     }
   }
 }
diff --git a/kmymoney/views/ktagsview.cpp b/kmymoney/views/ktagsview.cpp
index d57e94033..fd66a2cc3 100644
--- a/kmymoney/views/ktagsview.cpp
+++ b/kmymoney/views/ktagsview.cpp
@@ -1,758 +1,754 @@
 /***************************************************************************
                           ktagsview.cpp
                           -------------
     begin                : Sat Oct 13 2012
     copyright            : (C) 2012 by Alessandro Russo <axela74@yahoo.it>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "ktagsview.h"
 #include "ktagsview_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTimer>
 #include <QMenu>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KHelpClient>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyexception.h"
 #include "mymoneymoney.h"
 #include "mymoneyprice.h"
 #include "kmymoneysettings.h"
 #include "ktagreassigndlg.h"
 #include "kmymoneyutils.h"
 #include "kmymoneymvccombo.h"
 #include "mymoneysecurity.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyschedule.h"
 #include "transaction.h"
 #include "menuenums.h"
 
 using namespace Icons;
 
 /* -------------------------------------------------------------------------*/
 /*                         KTransactionPtrVector                            */
 /* -------------------------------------------------------------------------*/
 
 // *** KTagsView Implementation ***
 KTagsView::KTagsView(QWidget *parent) :
     KMyMoneyViewBase(*new KTagsViewPrivate(this), parent)
 {
   typedef void(KTagsView::*KTagsViewFunc)();
   const QHash<eMenu::Action, KTagsViewFunc> actionConnections {
     {eMenu::Action::NewTag,    &KTagsView::slotNewTag},
     {eMenu::Action::RenameTag, &KTagsView::slotRenameTag},
     {eMenu::Action::DeleteTag, &KTagsView::slotDeleteTag}
   };
 
   for (auto a = actionConnections.cbegin(); a != actionConnections.cend(); ++a)
     connect(pActions[a.key()], &QAction::triggered, this, a.value());
 }
 
 KTagsView::~KTagsView()
 {
 }
 
 void KTagsView::executeCustomAction(eView::Action action)
 {
   switch(action) {
     case eView::Action::Refresh:
       refresh();
       break;
 
     case eView::Action::SetDefaultFocus:
       {
         Q_D(KTagsView);
         QTimer::singleShot(0, d->m_searchWidget, SLOT(setFocus()));
       }
       break;
 
     default:
       break;
   }
 }
 
 void KTagsView::refresh()
 {
   Q_D(KTagsView);
   if (isVisible()) {
     if (d->m_inSelection)
       QTimer::singleShot(0, this, SLOT(refresh()));
     else
       loadTags();
     d->m_needsRefresh = false;
   } else {
     d->m_needsRefresh = true;
   }
 }
 
 void KTagsView::slotStartRename(QListWidgetItem* item)
 {
   Q_D(KTagsView);
   d->m_allowEditing = true;
   d->ui->m_tagsList->editItem(item);
 }
 
 // This variant is only called when a single tag is selected and renamed.
 void KTagsView::slotRenameSingleTag(QListWidgetItem* ta)
 {
   Q_D(KTagsView);
   //if there is no current item selected, exit
   if (d->m_allowEditing == false || !d->ui->m_tagsList->currentItem() || ta != d->ui->m_tagsList->currentItem())
     return;
 
   //qDebug() << "[KTagsView::slotRenameTag]";
   // create a copy of the new name without appended whitespaces
   auto new_name = ta->text();
   if (d->m_tag.name() != new_name) {
     MyMoneyFileTransaction ft;
     try {
       // check if we already have a tag with the new name
       try {
         // this function call will throw an exception, if the tag
         // hasn't been found.
         MyMoneyFile::instance()->tagByName(new_name);
         // the name already exists, ask the user whether he's sure to keep the name
         if (KMessageBox::questionYesNo(this,
                                        i18n("A tag with the name '%1' already exists. It is not advisable to have "
                                             "multiple tags with the same identification name. Are you sure you would like "
                                             "to rename the tag?", new_name)) != KMessageBox::Yes) {
           ta->setText(d->m_tag.name());
           return;
         }
       } catch (const MyMoneyException &) {
         // all ok, the name is unique
       }
 
       d->m_tag.setName(new_name);
       d->m_newName = new_name;
       MyMoneyFile::instance()->modifyTag(d->m_tag);
 
       // the above call to modifyTag will reload the view so
       // all references and pointers to the view have to be
       // re-established.
 
       // make sure, that the record is visible even if it moved
       // out of sight due to the rename operation
       ensureTagVisible(d->m_tag.id());
 
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to modify tag"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify tag"), QString::fromLatin1(e.what()));
     }
   } else {
     ta->setText(new_name);
   }
 }
 
 void KTagsView::ensureTagVisible(const QString& id)
 {
   Q_D(KTagsView);
   for (int i = 0; i < d->ui->m_tagsList->count(); ++i) {
     KTagListItem* ta = dynamic_cast<KTagListItem*>(d->ui->m_tagsList->item(0));
     if (ta && ta->tag().id() == id) {
       d->ui->m_tagsList->scrollToItem(ta, QAbstractItemView::PositionAtCenter);
 
       d->ui->m_tagsList->setCurrentItem(ta);      // active item and deselect all others
       d->ui->m_tagsList->setCurrentRow(i, QItemSelectionModel::ClearAndSelect);   // and select it
       break;
     }
   }
 }
 
 void KTagsView::selectedTags(QList<MyMoneyTag>& tagsList) const
 {
   Q_D(const KTagsView);
   QList<QListWidgetItem *> selectedItems = d->ui->m_tagsList->selectedItems();
   QList<QListWidgetItem *>::ConstIterator itemsIt = selectedItems.constBegin();
   while (itemsIt != selectedItems.constEnd()) {
     KTagListItem* item = dynamic_cast<KTagListItem*>(*itemsIt);
     if (item)
       tagsList << item->tag();
     ++itemsIt;
   }
 }
 
 void KTagsView::slotSelectTag(QListWidgetItem* cur, QListWidgetItem* prev)
 {
   Q_D(KTagsView);
   Q_UNUSED(cur);
   Q_UNUSED(prev);
 
   d->m_allowEditing = false;
 }
 
 void KTagsView::slotSelectTag()
 {
   Q_D(KTagsView);
   // check if the content of a currently selected tag was modified
   // and ask to store the data
   if (d->ui->m_updateButton->isEnabled()) {
     if (KMessageBox::questionYesNo(this, QString("<qt>%1</qt>").arg(
                                      i18n("Do you want to save the changes for <b>%1</b>?", d->m_newName)),
                                    i18n("Save changes")) == KMessageBox::Yes) {
       d->m_inSelection = true;
       slotUpdateTag();
       d->m_inSelection = false;
     }
   }
   // loop over all tags and count the number of tags, also
   // obtain last selected tag
   QList<MyMoneyTag> tagsList;
   selectedTags(tagsList);
   slotSelectTags(tagsList);
 
   if (tagsList.isEmpty()) {
     d->ui->m_tabWidget->setEnabled(false); // disable tab widget
     d->ui->m_balanceLabel->hide();
     d->ui->m_deleteButton->setEnabled(false); //disable delete and rename button
     d->ui->m_renameButton->setEnabled(false);
     clearItemData();
     d->m_tag = MyMoneyTag();
     return; // make sure we don't access an undefined tag
   }
 
   d->ui->m_deleteButton->setEnabled(true); //re-enable delete button
 
   // if we have multiple tags selected, clear and disable the tag information
   if (tagsList.count() > 1) {
     d->ui->m_tabWidget->setEnabled(false); // disable tab widget
     d->ui->m_renameButton->setEnabled(false); // disable also the rename button
     d->ui->m_balanceLabel->hide();
     clearItemData();
   } else d->ui->m_renameButton->setEnabled(true);
 
   // otherwise we have just one selected, enable tag information widget and renameButton
   d->ui->m_tabWidget->setEnabled(true);
   d->ui->m_balanceLabel->show();
 
   // as of now we are updating only the last selected tag, and until
   // selection mode of the QListView has been changed to Extended, this
   // will also be the only selection and behave exactly as before - Andreas
   try {
     d->m_tag = tagsList[0];
 
     d->m_newName = d->m_tag.name();
     d->ui->m_colorbutton->setEnabled(true);
     d->ui->m_colorbutton->setColor(d->m_tag.tagColor());
     d->ui->m_closed->setEnabled(true);
     d->ui->m_closed->setChecked(d->m_tag.isClosed());
     d->ui->m_notes->setEnabled(true);
     d->ui->m_notes->setText(d->m_tag.notes());
     slotTagDataChanged();
 
     showTransactions();
 
   } catch (const MyMoneyException &e) {
-    qDebug("exception during display of tag: %s at %s:%ld", qPrintable(e.what()), qPrintable(e.file()), e.line());
+    qDebug("exception during display of tag: %s", e.what());
     d->ui->m_register->clear();
     d->m_tag = MyMoneyTag();
   }
   d->m_allowEditing = true;
 }
 
 void KTagsView::clearItemData()
 {
   Q_D(KTagsView);
   d->ui->m_colorbutton->setColor(QColor());
   d->ui->m_closed->setChecked(false);
   d->ui->m_notes->setText(QString());
   showTransactions();
 }
 
 void KTagsView::showTransactions()
 {
   Q_D(KTagsView);
   MyMoneyMoney balance;
   auto file = MyMoneyFile::instance();
   MyMoneySecurity base = file->baseCurrency();
 
   // setup sort order
   d->ui->m_register->setSortOrder(KMyMoneySettings::sortSearchView());
 
   // clear the register
   d->ui->m_register->clear();
 
   if (d->m_tag.id().isEmpty() || !d->ui->m_tabWidget->isEnabled()) {
     d->ui->m_balanceLabel->setText(i18n("Balance: %1", balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
     return;
   }
 
   // setup the list and the pointer vector
   MyMoneyTransactionFilter filter;
   filter.addTag(d->m_tag.id());
   filter.setDateFilter(KMyMoneySettings::startDate().date(), QDate());
 
   // retrieve the list from the engine
   file->transactionList(d->m_transactionList, filter);
 
   // create the elements for the register
   QList<QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
   QMap<QString, int> uniqueMap;
   MyMoneyMoney deposit, payment;
 
   int splitCount = 0;
   bool balanceAccurate = true;
   for (it = d->m_transactionList.constBegin(); it != d->m_transactionList.constEnd(); ++it) {
     const MyMoneySplit& split = (*it).second;
     MyMoneyAccount acc = file->account(split.accountId());
     ++splitCount;
     uniqueMap[(*it).first.id()]++;
 
     KMyMoneyRegister::Register::transactionFactory(d->ui->m_register, (*it).first, (*it).second, uniqueMap[(*it).first.id()]);
 
     // take care of foreign currencies
     MyMoneyMoney val = split.shares().abs();
     if (acc.currencyId() != base.id()) {
       const MyMoneyPrice &price = file->price(acc.currencyId(), base.id());
       // in case the price is valid, we use it. Otherwise, we keep
       // a flag that tells us that the balance is somewhat inaccurate
       if (price.isValid()) {
         val *= price.rate(base.id());
       } else {
         balanceAccurate = false;
       }
     }
 
     if (split.shares().isNegative()) {
       payment += val;
     } else {
       deposit += val;
     }
   }
   balance = deposit - payment;
 
   // add the group markers
   d->ui->m_register->addGroupMarkers();
 
   // sort the transactions according to the sort setting
   d->ui->m_register->sortItems();
 
   // remove trailing and adjacent markers
   d->ui->m_register->removeUnwantedGroupMarkers();
 
   d->ui->m_register->updateRegister(true);
 
   // we might end up here with updates disabled on the register so
   // make sure that we enable updates here
   d->ui->m_register->setUpdatesEnabled(true);
   d->ui->m_balanceLabel->setText(i18n("Balance: %1%2",
                                balanceAccurate ? "" : "~",
                                balance.formatMoney(file->baseCurrency().smallestAccountFraction())));
 }
 
 void KTagsView::slotTagDataChanged()
 {
   Q_D(KTagsView);
   auto rc = false;
 
   if (d->ui->m_tabWidget->isEnabled()) {
     rc |= ((d->m_tag.tagColor().isValid() != d->ui->m_colorbutton->color().isValid())
            || (d->ui->m_colorbutton->color().isValid() && d->m_tag.tagColor() != d->ui->m_colorbutton->color()));
     rc |= (d->ui->m_closed->isChecked() != d->m_tag.isClosed());
     rc |= ((d->m_tag.notes().isEmpty() != d->ui->m_notes->toPlainText().isEmpty())
            || (!d->ui->m_notes->toPlainText().isEmpty() && d->m_tag.notes() != d->ui->m_notes->toPlainText()));
   }
   d->ui->m_updateButton->setEnabled(rc);
 }
 
 void KTagsView::slotUpdateTag()
 {
   Q_D(KTagsView);
   if (d->ui->m_updateButton->isEnabled()) {
     MyMoneyFileTransaction ft;
     d->ui->m_updateButton->setEnabled(false);
     try {
       d->m_tag.setName(d->m_newName);
       d->m_tag.setTagColor(d->ui->m_colorbutton->color());
       d->m_tag.setClosed(d->ui->m_closed->isChecked());
       d->m_tag.setNotes(d->ui->m_notes->toPlainText());
 
       MyMoneyFile::instance()->modifyTag(d->m_tag);
       ft.commit();
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::detailedSorry(this, i18n("Unable to modify tag"),
-                                 i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+      KMessageBox::detailedSorry(this, i18n("Unable to modify tag"), QString::fromLatin1(e.what()));
     }
   }
 }
 
 void KTagsView::showEvent(QShowEvent* event)
 {
   Q_D(KTagsView);
   if (d->m_needLoad)
     d->init();
 
   emit customActionRequested(View::Tags, eView::Action::AboutToShow);
 
   if (d->m_needsRefresh)
     refresh();
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 
   QList<MyMoneyTag> list;
   selectedTags(list);
   slotSelectTags(list);
 }
 
 void KTagsView::updateTagActions(const QList<MyMoneyTag>& tags)
 {
   pActions[eMenu::Action::NewTag]->setEnabled(true);
   const auto tagsCount = tags.count();
   auto b = tagsCount == 1 ? true : false;
   pActions[eMenu::Action::RenameTag]->setEnabled(b);
   b = tagsCount >= 1 ? true : false;
   pActions[eMenu::Action::DeleteTag]->setEnabled(b);
 }
 
 void KTagsView::loadTags()
 {
   Q_D(KTagsView);
   if (d->m_inSelection)
     return;
 
   QMap<QString, bool> isSelected;
   QString id;
   MyMoneyFile* file = MyMoneyFile::instance();
 
   // remember which items are selected in the list
   QList<QListWidgetItem *> selectedItems = d->ui->m_tagsList->selectedItems();
   QList<QListWidgetItem *>::const_iterator tagsIt = selectedItems.constBegin();
 
   while (tagsIt != selectedItems.constEnd()) {
     KTagListItem* item = dynamic_cast<KTagListItem*>(*tagsIt);
     if (item)
       isSelected[item->tag().id()] = true;
     ++tagsIt;
   }
 
   // keep current selected item
   KTagListItem *currentItem = static_cast<KTagListItem *>(d->ui->m_tagsList->currentItem());
   if (currentItem)
     id = currentItem->tag().id();
 
   d->m_allowEditing = false;
   // clear the list
   d->m_searchWidget->clear();
   d->m_searchWidget->updateSearch();
   d->ui->m_tagsList->clear();
   d->ui->m_register->clear();
   currentItem = 0;
 
   QList<MyMoneyTag>list = file->tagList();
   QList<MyMoneyTag>::ConstIterator it;
 
   for (it = list.constBegin(); it != list.constEnd(); ++it) {
     if (d->m_tagFilterType == (int)eView::Tag::All ||
         (d->m_tagFilterType == (int)eView::Tag::Referenced && file->isReferenced(*it)) ||
         (d->m_tagFilterType == (int)eView::Tag::Unused && !file->isReferenced(*it)) ||
         (d->m_tagFilterType == (int)eView::Tag::Opened && !(*it).isClosed()) ||
         (d->m_tagFilterType == (int)eView::Tag::Closed && (*it).isClosed())) {
       KTagListItem* item = new KTagListItem(d->ui->m_tagsList, *it);
       if (item->tag().id() == id)
         currentItem = item;
       if (isSelected[item->tag().id()])
         item->setSelected(true);
     }
   }
   d->ui->m_tagsList->sortItems();
 
   if (currentItem) {
     d->ui->m_tagsList->setCurrentItem(currentItem);
     d->ui->m_tagsList->scrollToItem(currentItem);
   }
 
   slotSelectTag(0, 0);
   d->m_allowEditing = true;
 }
 
 void KTagsView::slotSelectTransaction()
 {
   Q_D(KTagsView);
   QList<KMyMoneyRegister::RegisterItem*> list = d->ui->m_register->selectedItems();
   if (!list.isEmpty()) {
     KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(list[0]);
     if (t)
       emit selectByVariant(QVariantList {QVariant(t->split().accountId()), QVariant(t->transaction().id())}, eView::Intent::ShowTransaction);
   }
 }
 
 void KTagsView::slotSelectTagAndTransaction(const QString& tagId, const QString& accountId, const QString& transactionId)
 {
   if (!isVisible())
     return;
 
   Q_D(KTagsView);
   try {
     // clear filter
     d->m_searchWidget->clear();
     d->m_searchWidget->updateSearch();
 
     // deselect all other selected items
     QList<QListWidgetItem *> selectedItems = d->ui->m_tagsList->selectedItems();
     QList<QListWidgetItem *>::const_iterator tagsIt = selectedItems.constBegin();
     while (tagsIt != selectedItems.constEnd()) {
       KTagListItem* item = dynamic_cast<KTagListItem*>(*tagsIt);
       if (item)
         item->setSelected(false);
       ++tagsIt;
     }
 
     // find the tag in the list
     QListWidgetItem* it;
     for (int i = 0; i < d->ui->m_tagsList->count(); ++i) {
       it = d->ui->m_tagsList->item(i);
       KTagListItem* item = dynamic_cast<KTagListItem *>(it);
       if (item && item->tag().id() == tagId) {
         d->ui->m_tagsList->scrollToItem(it, QAbstractItemView::PositionAtCenter);
 
         d->ui->m_tagsList->setCurrentItem(it);     // active item and deselect all others
         d->ui->m_tagsList->setCurrentRow(i, QItemSelectionModel::ClearAndSelect); // and select it
 
         //make sure the tag selection is updated and transactions are updated accordingly
         slotSelectTag();
 
         KMyMoneyRegister::RegisterItem *registerItem = 0;
         for (i = 0; i < d->ui->m_register->rowCount(); ++i) {
           registerItem = d->ui->m_register->itemAtRow(i);
           KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(registerItem);
           if (t) {
             if (t->transaction().id() == transactionId && t->transaction().accountReferenced(accountId)) {
               d->ui->m_register->selectItem(registerItem);
               d->ui->m_register->ensureItemVisible(registerItem);
               break;
             }
           }
         }
         // quit out of outer for() loop
         break;
       }
     }
   } catch (const MyMoneyException &e) {
-    qWarning("Unexpected exception in KTagsView::slotSelectTagAndTransaction %s", qPrintable(e.what()));
+    qWarning("Unexpected exception in KTagsView::slotSelectTagAndTransaction %s", e.what());
   }
 }
 
 void KTagsView::slotSelectTagAndTransaction(const QString& tagId)
 {
   slotSelectTagAndTransaction(tagId, QString(), QString());
 }
 
 void KTagsView::slotShowTagsMenu(const QPoint& /*ta*/)
 {
   Q_D(KTagsView);
   auto item = dynamic_cast<KTagListItem*>(d->ui->m_tagsList->currentItem());
   if (item) {
     slotSelectTag();
     pMenus[eMenu::Menu::Tag]->exec(QCursor::pos());
   }
 }
 
 void KTagsView::slotHelp()
 {
   KHelpClient::invokeHelp("details.tags.attributes");
   //FIXME-ALEX update help file
 }
 
 void KTagsView::slotChangeFilter(int index)
 {
   Q_D(KTagsView);
   //update the filter type then reload the tags list
   d->m_tagFilterType = index;
   loadTags();
 }
 
 void KTagsView::slotSelectTags(const QList<MyMoneyTag>& list)
 {
   Q_D(KTagsView);
   d->m_selectedTags = list;
   updateTagActions(list);
 }
 
 void KTagsView::slotNewTag()
 {
   QString id;
   KMyMoneyUtils::newTag(i18n("New Tag"), id);
   slotSelectTagAndTransaction(id);
 }
 
 void KTagsView::slotRenameTag()
 {
   Q_D(KTagsView);
   if (d->ui->m_tagsList->currentItem() && d->ui->m_tagsList->selectedItems().count() == 1) {
     slotStartRename(d->ui->m_tagsList->currentItem());
   }
 }
 
 void KTagsView::slotDeleteTag()
 {
   Q_D(KTagsView);
   if (d->m_selectedTags.isEmpty())
     return; // shouldn't happen
 
   const auto file = MyMoneyFile::instance();
 
   // first create list with all non-selected tags
   QList<MyMoneyTag> remainingTags = file->tagList();
   QList<MyMoneyTag>::iterator it_ta;
   for (it_ta = remainingTags.begin(); it_ta != remainingTags.end();) {
     if (d->m_selectedTags.contains(*it_ta)) {
       it_ta = remainingTags.erase(it_ta);
     } else {
       ++it_ta;
     }
   }
 
   // get confirmation from user
   QString prompt;
   if (d->m_selectedTags.size() == 1)
     prompt = i18n("<p>Do you really want to remove the tag <b>%1</b>?</p>", d->m_selectedTags.front().name());
   else
     prompt = i18n("Do you really want to remove all selected tags?");
 
   if (KMessageBox::questionYesNo(this, prompt, i18n("Remove Tag")) == KMessageBox::No)
     return;
 
   MyMoneyFileTransaction ft;
   try {
     // create a transaction filter that contains all tags selected for removal
     MyMoneyTransactionFilter f = MyMoneyTransactionFilter();
     for (QList<MyMoneyTag>::const_iterator it = d->m_selectedTags.constBegin();
          it != d->m_selectedTags.constEnd(); ++it) {
       f.addTag((*it).id());
     }
     // request a list of all transactions that still use the tags in question
     auto translist = file->transactionList(f);
 //     qDebug() << "[KTagsView::slotDeleteTag]  " << translist.count() << " transaction still assigned to tags";
 
     // now get a list of all schedules that make use of one of the tags
     QList<MyMoneySchedule> used_schedules;
     foreach (const auto schedule, file->scheduleList()) {
       // loop over all splits in the transaction of the schedule
       foreach (const auto split, schedule.transaction().splits()) {
         for (auto i = 0; i < split.tagIdList().size(); ++i) {
           // is the tag in the split to be deleted?
           if (d->tagInList(d->m_selectedTags, split.tagIdList()[i])) {
             used_schedules.push_back(schedule); // remember this schedule
             break;
           }
         }
       }
     }
 //     qDebug() << "[KTagsView::slotDeleteTag]  " << used_schedules.count() << " schedules use one of the selected tags";
 
     MyMoneyTag newTag;
     // if at least one tag is still referenced, we need to reassign its transactions first
     if (!translist.isEmpty() || !used_schedules.isEmpty()) {
       // show error message if no tags remain
       //FIXME-ALEX Tags are optional so we can delete all of them and simply delete every tagId from every transaction
       if (remainingTags.isEmpty()) {
         KMessageBox::sorry(this, i18n("At least one transaction/scheduled transaction is still referenced by a tag. "
                                       "Currently you have all tags selected. However, at least one tag must remain so "
                                       "that the transaction/scheduled transaction can be reassigned."));
         return;
       }
 
       // show transaction reassignment dialog
       auto dlg = new KTagReassignDlg(this);
       KMyMoneyMVCCombo::setSubstringSearchForChildren(dlg, !KMyMoneySettings::stringMatchFromStart());
       auto tag_id = dlg->show(remainingTags);
       delete dlg; // and kill the dialog
       if (tag_id.isEmpty())  //FIXME-ALEX Let the user choose to not reassign a to-be deleted tag to another one.
         return; // the user aborted the dialog, so let's abort as well
 
       newTag = file->tag(tag_id);
 
       // TODO : check if we have a report that explicitively uses one of our tags
       //        and issue an appropriate warning
       try {
         // now loop over all transactions and reassign tag
         for (auto& transaction : translist) {
           // create a copy of the splits list in the transaction
           // loop over all splits
           for (auto& split : transaction.splits()) {
             QList<QString> tagIdList = split.tagIdList();
             for (int i = 0; i < tagIdList.size(); ++i) {
               // if the split is assigned to one of the selected tags, we need to modify it
               if (d->tagInList(d->m_selectedTags, tagIdList[i])) {
                 tagIdList.removeAt(i);
                 if (tagIdList.indexOf(tag_id) == -1)
                   tagIdList.append(tag_id);
                 i = -1; // restart from the first element
               }
             }
             split.setTagIdList(tagIdList); // first modify tag list in current split
             // then modify the split in our local copy of the transaction list
             transaction.modifySplit(split); // this does not modify the list object 'splits'!
           } // for - Splits
           file->modifyTransaction(transaction);  // modify the transaction in the MyMoney object
         } // for - Transactions
 
         // now loop over all schedules and reassign tags
         for (auto& schedule : used_schedules) {
           // create copy of transaction in current schedule
           auto trans = schedule.transaction();
           // create copy of lists of splits
           for (auto& split : trans.splits()) {
             QList<QString> tagIdList = split.tagIdList();
             for (auto i = 0; i < tagIdList.size(); ++i) {
               if (d->tagInList(d->m_selectedTags, tagIdList[i])) {
                 tagIdList.removeAt(i);
                 if (tagIdList.indexOf(tag_id) == -1)
                   tagIdList.append(tag_id);
                 i = -1; // restart from the first element
               }
             }
             split.setTagIdList(tagIdList);
             trans.modifySplit(split); // does not modify the list object 'splits'!
           } // for - Splits
           // store transaction in current schedule
           schedule.setTransaction(trans);
           file->modifySchedule(schedule);  // modify the schedule in the MyMoney engine
         } // for - Schedules
 
       } catch (const MyMoneyException &e) {
-        KMessageBox::detailedSorry(this, i18n("Unable to reassign tag of transaction/split"),
-                                   i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+        KMessageBox::detailedSorry(this, i18n("Unable to reassign tag of transaction/split"), QString::fromLatin1(e.what()));
       }
     } // if !translist.isEmpty()
 
     // now loop over all selected tags and remove them
     for (QList<MyMoneyTag>::iterator it = d->m_selectedTags.begin();
          it != d->m_selectedTags.end(); ++it) {
       file->removeTag(*it);
     }
 
     ft.commit();
 
     // If we just deleted the tags, they sure don't exist anymore
     slotSelectTags(QList<MyMoneyTag>());
 
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(this, i18n("Unable to remove tag(s)"),
-                               i18n("%1 thrown in %2:%3", e.what(), e.file(), e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to remove tag(s)"), QString::fromLatin1(e.what()));
   }
 }
diff --git a/kmymoney/widgets/register.cpp b/kmymoney/widgets/register.cpp
index 1d316e7fd..d8b3b06c9 100644
--- a/kmymoney/widgets/register.cpp
+++ b/kmymoney/widgets/register.cpp
@@ -1,1892 +1,1892 @@
 /***************************************************************************
                              register.cpp  -  description
                              -------------------
     begin                : Fri Mar 10 2006
     copyright            : (C) 2006 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "register.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QToolTip>
 #include <QMouseEvent>
 #include <QList>
 #include <QKeyEvent>
 #include <QEvent>
 #include <QFrame>
 #include <QHeaderView>
 #include <QApplication>
 #include <QPushButton>
 #include <QTimer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 #include "mymoneyaccount.h"
 #include "stdtransactiondownloaded.h"
 #include "stdtransactionmatched.h"
 #include "selectedtransactions.h"
 #include "scheduledtransaction.h"
 #include "kmymoneysettings.h"
 #include "mymoneymoney.h"
 #include "mymoneyfile.h"
 #include "groupmarkers.h"
 #include "fancydategroupmarkers.h"
 #include "registeritemdelegate.h"
 #include "itemptrvector.h"
 #include "mymoneyenums.h"
 #include "widgetenums.h"
 
 using namespace KMyMoneyRegister;
 using namespace eWidgets;
 using namespace eMyMoney;
 
 namespace KMyMoneyRegister
 {
   class RegisterPrivate
   {
   public:
     RegisterPrivate() :
       m_selectAnchor(nullptr),
       m_focusItem(nullptr),
       m_ensureVisibleItem(nullptr),
       m_firstItem(nullptr),
       m_lastItem(nullptr),
       m_firstErroneous(nullptr),
       m_lastErroneous(nullptr),
       m_rowHeightHint(0),
       m_ledgerLensForced(false),
       m_selectionMode(QTableWidget::MultiSelection),
       m_needResize(true),
       m_listsDirty(false),
       m_ignoreNextButtonRelease(false),
       m_needInitialColumnResize(false),
       m_usedWithEditor(false),
       m_mouseButton(Qt::MouseButtons(Qt::NoButton)),
       m_modifiers(Qt::KeyboardModifiers(Qt::NoModifier)),
       m_lastCol(eTransaction::Column::Account),
       m_detailsColumnType(eRegister::DetailColumn::PayeeFirst)
     {
     }
 
     ~RegisterPrivate()
     {
     }
 
     ItemPtrVector                m_items;
     QVector<RegisterItem*>       m_itemIndex;
     RegisterItem*                m_selectAnchor;
     RegisterItem*                m_focusItem;
     RegisterItem*                m_ensureVisibleItem;
     RegisterItem*                m_firstItem;
     RegisterItem*                m_lastItem;
     RegisterItem*                m_firstErroneous;
     RegisterItem*                m_lastErroneous;
 
     int                          m_markErroneousTransactions;
     int                          m_rowHeightHint;
 
     MyMoneyAccount               m_account;
 
     bool                         m_ledgerLensForced;
     QAbstractItemView::SelectionMode m_selectionMode;
 
     bool                         m_needResize;
     bool                         m_listsDirty;
     bool                         m_ignoreNextButtonRelease;
     bool                         m_needInitialColumnResize;
     bool                         m_usedWithEditor;
     Qt::MouseButtons             m_mouseButton;
     Qt::KeyboardModifiers        m_modifiers;
     eTransaction::Column         m_lastCol;
     QList<SortField>             m_sortOrder;
     QRect                        m_lastRepaintRect;
     eRegister::DetailColumn      m_detailsColumnType;
 
   };
 
   Register::Register(QWidget *parent) :
     TransactionEditorContainer(parent),
     d_ptr(new RegisterPrivate)
   {
     // used for custom coloring with the help of the application's stylesheet
     setObjectName(QLatin1String("register"));
     setItemDelegate(new RegisterItemDelegate(this));
 
     setEditTriggers(QAbstractItemView::NoEditTriggers);
     setColumnCount((int)eTransaction::Column::LastColumn);
     setSelectionBehavior(QAbstractItemView::SelectRows);
     setAcceptDrops(true);
     setShowGrid(false);
     setContextMenuPolicy(Qt::DefaultContextMenu);
 
     setHorizontalHeaderItem((int)eTransaction::Column::Number, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Date, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Account, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Security, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Detail, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::ReconcileFlag, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Payment, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Deposit, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Quantity, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Price, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Value, new QTableWidgetItem());
     setHorizontalHeaderItem((int)eTransaction::Column::Balance, new QTableWidgetItem());
 
     // keep the following list in sync with KMyMoneyRegister::Column in transaction.h
     horizontalHeaderItem((int)eTransaction::Column::Number)->setText(i18nc("Cheque Number", "No."));
     horizontalHeaderItem((int)eTransaction::Column::Date)->setText(i18n("Date"));
     horizontalHeaderItem((int)eTransaction::Column::Account)->setText(i18n("Account"));
     horizontalHeaderItem((int)eTransaction::Column::Security)->setText(i18n("Security"));
     horizontalHeaderItem((int)eTransaction::Column::Detail)->setText(i18n("Details"));
     horizontalHeaderItem((int)eTransaction::Column::ReconcileFlag)->setText(i18n("C"));
     horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18n("Payment"));
     horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18n("Deposit"));
     horizontalHeaderItem((int)eTransaction::Column::Quantity)->setText(i18n("Quantity"));
     horizontalHeaderItem((int)eTransaction::Column::Price)->setText(i18n("Price"));
     horizontalHeaderItem((int)eTransaction::Column::Value)->setText(i18n("Value"));
     horizontalHeaderItem((int)eTransaction::Column::Balance)->setText(i18n("Balance"));
 
     verticalHeader()->hide();
 
     horizontalHeader()->setSectionResizeMode(QHeaderView::Fixed);
     horizontalHeader()->setSortIndicatorShown(false);
     horizontalHeader()->setSectionsMovable(false);
     horizontalHeader()->setSectionsClickable(false);
     horizontalHeader()->setContextMenuPolicy(Qt::CustomContextMenu);
 
     connect(this, &QTableWidget::cellClicked, this, static_cast<void (Register::*)(int, int)>(&Register::selectItem));
     connect(this, &QTableWidget::cellDoubleClicked, this, &Register::slotDoubleClicked);
   }
 
   Register::~Register()
   {
     Q_D(Register);
     clear();
     delete d;
   }
 
   bool Register::eventFilter(QObject* o, QEvent* e)
   {
     if (o == this && e->type() == QEvent::KeyPress) {
       auto ke = dynamic_cast<QKeyEvent*>(e);
       if (ke && ke->key() == Qt::Key_Menu) {
         emit openContextMenu();
         return true;
       }
     }
     return QTableWidget::eventFilter(o, e);
   }
 
   void Register::setupRegister(const MyMoneyAccount& account, const QList<eTransaction::Column>& cols)
   {
     Q_D(Register);
     d->m_account = account;
     setUpdatesEnabled(false);
 
     for (auto i = 0; i < (int)eTransaction::Column::LastColumn; ++i)
       hideColumn(i);
 
     d->m_needInitialColumnResize = true;
 
     d->m_lastCol = static_cast<eTransaction::Column>(0);
     QList<eTransaction::Column>::const_iterator it_c;
     for (it_c = cols.begin(); it_c != cols.end(); ++it_c) {
       if ((*it_c) > eTransaction::Column::LastColumn)
         continue;
       showColumn((int)*it_c);
       if (*it_c > d->m_lastCol)
         d->m_lastCol = *it_c;
     }
 
     setUpdatesEnabled(true);
   }
 
   void Register::setupRegister(const MyMoneyAccount& account, bool showAccountColumn)
   {
     Q_D(Register);
     d->m_account = account;
     setUpdatesEnabled(false);
 
     for (auto i = 0; i < (int)eTransaction::Column::LastColumn; ++i)
       hideColumn(i);
 
     horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18nc("Payment made from account", "Payment"));
     horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18nc("Deposit into account", "Deposit"));
 
     if (account.id().isEmpty()) {
       setUpdatesEnabled(true);
       return;
     }
 
     d->m_needInitialColumnResize = true;
 
     // turn on standard columns
     showColumn((int)eTransaction::Column::Date);
     showColumn((int)eTransaction::Column::Detail);
     showColumn((int)eTransaction::Column::ReconcileFlag);
 
     // balance
     switch (account.accountType()) {
       case Account::Type::Stock:
         break;
       default:
         showColumn((int)eTransaction::Column::Balance);
         break;
     }
 
     // Number column
     switch (account.accountType()) {
       case Account::Type::Savings:
       case Account::Type::Cash:
       case Account::Type::Loan:
       case Account::Type::AssetLoan:
       case Account::Type::Asset:
       case Account::Type::Liability:
       case Account::Type::Equity:
         if (KMyMoneySettings::alwaysShowNrField())
           showColumn((int)eTransaction::Column::Number);
         break;
 
       case Account::Type::Checkings:
       case Account::Type::CreditCard:
         showColumn((int)eTransaction::Column::Number);
         break;
 
       default:
         hideColumn((int)eTransaction::Column::Number);
         break;
     }
 
     switch (account.accountType()) {
       case Account::Type::Income:
       case Account::Type::Expense:
         showAccountColumn = true;
         break;
       default:
         break;
     }
 
     if (showAccountColumn)
       showColumn((int)eTransaction::Column::Account);
 
     // Security, activity, payment, deposit, amount, price and value column
     switch (account.accountType()) {
       default:
         showColumn((int)eTransaction::Column::Payment);
         showColumn((int)eTransaction::Column::Deposit);
         break;
 
       case Account::Type::Investment:
         showColumn((int)eTransaction::Column::Security);
         showColumn((int)eTransaction::Column::Quantity);
         showColumn((int)eTransaction::Column::Price);
         showColumn((int)eTransaction::Column::Value);
         break;
     }
 
     // headings
     switch (account.accountType()) {
       case Account::Type::CreditCard:
         horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18nc("Payment made with credit card", "Charge"));
         horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18nc("Payment towards credit card", "Payment"));
         break;
       case Account::Type::Asset:
       case Account::Type::AssetLoan:
         horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18nc("Decrease of asset/liability value", "Decrease"));
         horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18nc("Increase of asset/liability value", "Increase"));
         break;
       case Account::Type::Liability:
       case Account::Type::Loan:
         horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18nc("Increase of asset/liability value", "Increase"));
         horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18nc("Decrease of asset/liability value", "Decrease"));
         break;
       case Account::Type::Income:
       case Account::Type::Expense:
         horizontalHeaderItem((int)eTransaction::Column::Payment)->setText(i18n("Income"));
         horizontalHeaderItem((int)eTransaction::Column::Deposit)->setText(i18n("Expense"));
         break;
 
       default:
         break;
     }
 
     d->m_lastCol = eTransaction::Column::Balance;
 
     setUpdatesEnabled(true);
   }
 
   bool Register::focusNextPrevChild(bool next)
   {
     return QFrame::focusNextPrevChild(next);
   }
 
   void Register::setSortOrder(const QString& order)
   {
     Q_D(Register);
     const QStringList orderList = order.split(',', QString::SkipEmptyParts);
     QStringList::const_iterator it;
     d->m_sortOrder.clear();
     for (it = orderList.constBegin(); it != orderList.constEnd(); ++it) {
       d->m_sortOrder << static_cast<SortField>((*it).toInt());
     }
   }
 
   const QList<SortField>& Register::sortOrder() const
   {
     Q_D(const Register);
     return d->m_sortOrder;
   }
 
   void Register::sortItems()
   {
     Q_D(Register);
     if (d->m_items.count() == 0)
       return;
 
     // sort the array of pointers to the transactions
     d->m_items.sort();
 
     // update the next/prev item chains
     RegisterItem* prev = 0;
     RegisterItem* item;
     d->m_firstItem = d->m_lastItem = 0;
     for (QVector<RegisterItem*>::size_type i = 0; i < d->m_items.size(); ++i) {
       item = d->m_items[i];
       if (!item)
         continue;
 
       if (!d->m_firstItem)
         d->m_firstItem = item;
       d->m_lastItem = item;
       if (prev)
         prev->setNextItem(item);
       item->setPrevItem(prev);
       item->setNextItem(0);
       prev = item;
     }
 
     // update the balance visibility settings
     item = d->m_lastItem;
     bool showBalance = true;
     while (item) {
       auto t = dynamic_cast<Transaction*>(item);
       if (t) {
         t->setShowBalance(showBalance);
         if (!t->isVisible()) {
           showBalance = false;
         }
       }
       item = item->prevItem();
     }
 
     // force update of the item index (row to item array)
     d->m_listsDirty = true;
   }
 
   eTransaction::Column Register::lastCol() const
   {
     Q_D(const Register);
     return d->m_lastCol;
   }
 
   SortField Register::primarySortKey() const
   {
     Q_D(const Register);
     if (!d->m_sortOrder.isEmpty())
       return static_cast<SortField>(d->m_sortOrder.first());
     return SortField::Unknown;
   }
 
 
   void Register::clear()
   {
     Q_D(Register);
     d->m_firstErroneous = d->m_lastErroneous = 0;
     d->m_ensureVisibleItem = 0;
 
     d->m_items.clear();
 
     RegisterItem* p;
     while ((p = firstItem()) != 0) {
       delete p;
     }
 
     d->m_firstItem = d->m_lastItem = 0;
 
     d->m_listsDirty = true;
     d->m_selectAnchor = 0;
     d->m_focusItem = 0;
 
 #ifndef KMM_DESIGNER
     // recalculate row height hint
     QFontMetrics fm(KMyMoneySettings::listCellFontEx());
     d->m_rowHeightHint = fm.lineSpacing() + 6;
 #endif
 
     d->m_needInitialColumnResize = true;
     d->m_needResize = true;
     updateRegister(true);
   }
 
   void Register::insertItemAfter(RegisterItem*p, RegisterItem* prev)
   {
     Q_D(Register);
     RegisterItem* next = 0;
     if (!prev)
       prev = lastItem();
 
     if (prev) {
       next = prev->nextItem();
       prev->setNextItem(p);
     }
     if (next)
       next->setPrevItem(p);
 
     p->setPrevItem(prev);
     p->setNextItem(next);
 
     if (!d->m_firstItem)
       d->m_firstItem = p;
     if (!d->m_lastItem)
       d->m_lastItem = p;
 
     if (prev == d->m_lastItem)
       d->m_lastItem = p;
 
     d->m_listsDirty = true;
     d->m_needResize = true;
   }
 
   void Register::addItem(RegisterItem* p)
   {
     Q_D(Register);
     RegisterItem* q = lastItem();
     if (q)
       q->setNextItem(p);
     p->setPrevItem(q);
     p->setNextItem(0);
 
     d->m_items.append(p);
 
     if (!d->m_firstItem)
       d->m_firstItem = p;
     d->m_lastItem = p;
     d->m_listsDirty = true;
     d->m_needResize = true;
   }
 
   void Register::removeItem(RegisterItem* p)
   {
     Q_D(Register);
     // remove item from list
     if (p->prevItem())
       p->prevItem()->setNextItem(p->nextItem());
     if (p->nextItem())
       p->nextItem()->setPrevItem(p->prevItem());
 
     // update first and last pointer if required
     if (p == d->m_firstItem)
       d->m_firstItem = p->nextItem();
     if (p == d->m_lastItem)
       d->m_lastItem = p->prevItem();
 
     // make sure we don't do it twice
     p->setNextItem(0);
     p->setPrevItem(0);
 
     // remove it from the m_items array
     int i = d->m_items.indexOf(p);
     if (-1 != i) {
       d->m_items[i] = 0;
     }
     d->m_listsDirty = true;
     d->m_needResize = true;
   }
 
   RegisterItem* Register::firstItem() const
   {
     Q_D(const Register);
     return d->m_firstItem;
   }
 
   RegisterItem* Register::nextItem(RegisterItem* item) const
   {
     return item->nextItem();
   }
 
   RegisterItem* Register::lastItem() const
   {
     Q_D(const Register);
     return d->m_lastItem;
   }
 
   void Register::setupItemIndex(int rowCount)
   {
     Q_D(Register);
     // setup index array
     d->m_itemIndex.clear();
     d->m_itemIndex.reserve(rowCount);
 
     // fill index array
     rowCount = 0;
     RegisterItem* prev = 0;
     d->m_firstItem = d->m_lastItem = 0;
     for (QVector<RegisterItem*>::size_type i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* item = d->m_items[i];
       if (!item)
         continue;
       if (!d->m_firstItem)
         d->m_firstItem = item;
       d->m_lastItem = item;
       if (prev)
         prev->setNextItem(item);
       item->setPrevItem(prev);
       item->setNextItem(0);
       prev = item;
       for (int j = item->numRowsRegister(); j; --j) {
         d->m_itemIndex.push_back(item);
       }
     }
   }
 
   void Register::updateAlternate() const
   {
     Q_D(const Register);
     bool alternate = false;
     for (QVector<RegisterItem*>::size_type i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* item = d->m_items[i];
       if (!item)
         continue;
       if (item->isVisible()) {
         item->setAlternate(alternate);
         alternate ^= true;
       }
     }
   }
 
   void Register::suppressAdjacentMarkers()
   {
     bool lastWasGroupMarker = false;
     KMyMoneyRegister::RegisterItem* p = lastItem();
     auto t = dynamic_cast<KMyMoneyRegister::Transaction*>(p);
     if (t && t->transaction().id().isEmpty()) {
       lastWasGroupMarker = true;
       p = p->prevItem();
     }
     while (p) {
       auto m = dynamic_cast<KMyMoneyRegister::GroupMarker*>(p);
       if (m) {
         // make adjacent group marker invisible except those that show statement information
         if (lastWasGroupMarker && (dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(m) == 0)) {
           m->setVisible(false);
         }
         lastWasGroupMarker = true;
       } else if (p->isVisible())
         lastWasGroupMarker = false;
       p = p->prevItem();
     }
   }
 
   void Register::updateRegister(bool forceUpdateRowHeight)
   {
     Q_D(Register);
     if (d->m_listsDirty || forceUpdateRowHeight) {
       // don't get in here recursively
       d->m_listsDirty = false;
 
       int rowCount = 0;
       // determine the number of rows we need to display all items
       // while going through the list, check for erroneous transactions
       for (QVector<RegisterItem*>::size_type i = 0; i < d->m_items.size(); ++i) {
         RegisterItem* item = d->m_items[i];
         if (!item)
           continue;
         item->setStartRow(rowCount);
         item->setNeedResize();
         rowCount += item->numRowsRegister();
 
         if (item->isErroneous()) {
           if (!d->m_firstErroneous)
             d->m_firstErroneous = item;
           d->m_lastErroneous = item;
         }
       }
 
       updateAlternate();
 
       // create item index
       setupItemIndex(rowCount);
 
       bool needUpdateHeaders = (QTableWidget::rowCount() != rowCount) | forceUpdateRowHeight;
 
       // setup QTable.  Make sure to suppress screen updates for now
       setRowCount(rowCount);
 
       // if we need to update the headers, we do it now for all rows
       // again we make sure to suppress screen updates
       if (needUpdateHeaders) {
         for (auto i = 0; i < rowCount; ++i) {
           RegisterItem* item = itemAtRow(i);
           if (item->isVisible()) {
             showRow(i);
           } else {
             hideRow(i);
           }
           verticalHeader()->resizeSection(i, item->rowHeightHint());
         }
         verticalHeader()->setUpdatesEnabled(true);
       }
 
       // force resizeing of the columns if necessary
       if (d->m_needInitialColumnResize) {
         QTimer::singleShot(0, this, SLOT(resize()));
         d->m_needInitialColumnResize = false;
       } else {
         update();
 
         // if the number of rows changed, we might need to resize the register
         // to make sure we reflect the current visibility of the scrollbars.
         if (needUpdateHeaders)
           QTimer::singleShot(0, this, SLOT(resize()));
       }
     }
   }
 
   int Register::rowHeightHint() const
   {
     Q_D(const Register);
     if (!d->m_rowHeightHint) {
       qDebug("Register::rowHeightHint(): m_rowHeightHint is zero!!");
     }
     return d->m_rowHeightHint;
   }
 
   void Register::focusInEvent(QFocusEvent* ev)
   {
     Q_D(const Register);
     QTableWidget::focusInEvent(ev);
     if (d->m_focusItem) {
       d->m_focusItem->setFocus(true, false);
     }
   }
 
   bool Register::event(QEvent* event)
   {
     if (event->type() == QEvent::ToolTip) {
       QHelpEvent *helpEvent = static_cast<QHelpEvent *>(event);
 
       // get the row, if it's the header, then we're done
       // otherwise, adjust the row to be 0 based.
       int row = rowAt(helpEvent->y());
       if (!row)
         return true;
       --row;
 
       int col = columnAt(helpEvent->x());
       RegisterItem* item = itemAtRow(row);
       if (!item)
         return true;
 
       row = row - item->startRow();
 
       QString msg;
       QRect rect;
       if (!item->maybeTip(helpEvent->pos(), row, col, rect, msg))
         return true;
 
       if (!msg.isEmpty()) {
         QToolTip::showText(helpEvent->globalPos(), msg);
       } else {
         QToolTip::hideText();
         event->ignore();
       }
       return true;
     }
     return TransactionEditorContainer::event(event);
   }
 
   void Register::focusOutEvent(QFocusEvent* ev)
   {
     Q_D(Register);
     if (d->m_focusItem) {
       d->m_focusItem->setFocus(false, false);
     }
     QTableWidget::focusOutEvent(ev);
   }
 
   void Register::resizeEvent(QResizeEvent* ev)
   {
     TransactionEditorContainer::resizeEvent(ev);
     resize((int)eTransaction::Column::Detail, true);
   }
 
   void Register::resize()
   {
     resize((int)eTransaction::Column::Detail);
   }
 
   void Register::resize(int col, bool force)
   {
     Q_D(Register);
     if (!d->m_needResize && !force)
       return;
 
     d->m_needResize = false;
 
     // resize the register
     int w = viewport()->width();
 
     // TODO I was playing a bit with manual ledger resizing but could not get
     // a good solution. I just leave the code around, so that maybe others
     // pick it up again.  So far, it's not clear to me where to store the
     // size of the sections:
     //
     // a) with the account (as it is done now)
     // b) with the application for the specific account type
     // c) ????
     //
     // Ideas are welcome (ipwizard: 2007-07-19)
     // Note: currently there's no way to switch back to automatic
     // column sizing once the manual sizing option has been saved
 #if 0
     if (m_account.value("kmm-ledger-column-width").isEmpty()) {
 #endif
 
       // check which space we need
       if (columnWidth((int)eTransaction::Column::Number))
         adjustColumn((int)eTransaction::Column::Number);
       if (columnWidth((int)eTransaction::Column::Account))
         adjustColumn((int)eTransaction::Column::Account);
       if (columnWidth((int)eTransaction::Column::Payment))
         adjustColumn((int)eTransaction::Column::Payment);
       if (columnWidth((int)eTransaction::Column::Deposit))
         adjustColumn((int)eTransaction::Column::Deposit);
       if (columnWidth((int)eTransaction::Column::Quantity))
         adjustColumn((int)eTransaction::Column::Quantity);
       if (columnWidth((int)eTransaction::Column::Balance))
         adjustColumn((int)eTransaction::Column::Balance);
       if (columnWidth((int)eTransaction::Column::Price))
         adjustColumn((int)eTransaction::Column::Price);
       if (columnWidth((int)eTransaction::Column::Value))
         adjustColumn((int)eTransaction::Column::Value);
 
       // make amount columns all the same size
       // only extend the entry columns to make sure they fit
       // the widget
       int dwidth = 0;
       int ewidth = 0;
       if (ewidth < columnWidth((int)eTransaction::Column::Payment))
         ewidth = columnWidth((int)eTransaction::Column::Payment);
       if (ewidth < columnWidth((int)eTransaction::Column::Deposit))
         ewidth = columnWidth((int)eTransaction::Column::Deposit);
       if (ewidth < columnWidth((int)eTransaction::Column::Quantity))
         ewidth = columnWidth((int)eTransaction::Column::Quantity);
       if (dwidth < columnWidth((int)eTransaction::Column::Balance))
         dwidth = columnWidth((int)eTransaction::Column::Balance);
       if (ewidth < columnWidth((int)eTransaction::Column::Price))
         ewidth = columnWidth((int)eTransaction::Column::Price);
       if (dwidth < columnWidth((int)eTransaction::Column::Value))
         dwidth = columnWidth((int)eTransaction::Column::Value);
       int swidth = columnWidth((int)eTransaction::Column::Security);
       if (swidth > 0) {
         adjustColumn((int)eTransaction::Column::Security);
         swidth = columnWidth((int)eTransaction::Column::Security);
       }
 
       adjustColumn((int)eTransaction::Column::Date);
 
 #ifndef KMM_DESIGNER
       // Resize the date and money fields to either
       // a) the size required by the input widget if no transaction form is shown and the register is used with an editor
       // b) the adjusted value for the input widget if the transaction form is visible or an editor is not used
       if (d->m_usedWithEditor && !KMyMoneySettings::transactionForm()) {
         QPushButton *pushButton = new QPushButton;
         const int pushButtonSpacing = pushButton->sizeHint().width() + 5;
         setColumnWidth((int)eTransaction::Column::Date, columnWidth((int)eTransaction::Column::Date) + pushButtonSpacing + 4/* space for the spinbox arrows */);
         ewidth += pushButtonSpacing;
 
         if (swidth > 0) {
           // extend the security width to make space for the selector arrow
           swidth = columnWidth((int)eTransaction::Column::Security) + 40;
         }
         delete pushButton;
       }
 #endif
 
       if (columnWidth((int)eTransaction::Column::Payment))
         setColumnWidth((int)eTransaction::Column::Payment, ewidth);
       if (columnWidth((int)eTransaction::Column::Deposit))
         setColumnWidth((int)eTransaction::Column::Deposit, ewidth);
       if (columnWidth((int)eTransaction::Column::Quantity))
         setColumnWidth((int)eTransaction::Column::Quantity, ewidth);
       if (columnWidth((int)eTransaction::Column::Balance))
         setColumnWidth((int)eTransaction::Column::Balance, dwidth);
       if (columnWidth((int)eTransaction::Column::Price))
         setColumnWidth((int)eTransaction::Column::Price, ewidth);
       if (columnWidth((int)eTransaction::Column::Value))
         setColumnWidth((int)eTransaction::Column::Value, dwidth);
 
       if (columnWidth((int)eTransaction::Column::ReconcileFlag))
         setColumnWidth((int)eTransaction::Column::ReconcileFlag, 20);
 
       if (swidth > 0)
         setColumnWidth((int)eTransaction::Column::Security, swidth);
 #if 0
       // see comment above
     } else {
       QStringList colSizes = QStringList::split(",", m_account.value("kmm-ledger-column-width"), true);
       for (int i; i < colSizes.count(); ++i) {
         int colWidth = colSizes[i].toInt();
         if (colWidth == 0)
           continue;
         setColumnWidth(i, w * colWidth / 100);
       }
     }
 #endif
 
     for (auto i = 0; i < columnCount(); ++i) {
       if (i == col)
         continue;
 
       w -= columnWidth(i);
     }
     setColumnWidth(col, w);
   }
 
   void Register::forceUpdateLists()
   {
     Q_D(Register);
     d->m_listsDirty = true;
   }
 
   int Register::minimumColumnWidth(int col)
   {
     Q_D(Register);
     QHeaderView *topHeader = horizontalHeader();
     int w = topHeader->fontMetrics().width(horizontalHeaderItem(col) ? horizontalHeaderItem(col)->text() : QString()) + 10;
     w = qMax(w, 20);
 #ifdef KMM_DESIGNER
     return w;
 #else
     int maxWidth = 0;
     int minWidth = 0;
     QFontMetrics cellFontMetrics(KMyMoneySettings::listCellFontEx());
     switch (col) {
       case (int)eTransaction::Column::Date:
         minWidth = cellFontMetrics.width(QLocale().toString(QDate(6999, 12, 29), QLocale::ShortFormat) + "  ");
         break;
       default:
         break;
     }
 
     // scan through the transactions
     for (auto i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* const item = d->m_items[i];
       if (!item)
         continue;
       auto t = dynamic_cast<Transaction*>(item);
       if (t) {
         int nw = 0;
         try {
           nw = t->registerColWidth(col, cellFontMetrics);
         } catch (const MyMoneyException &) {
           // This should only be reached if the data in the file disappeared
           // from under us, such as when the account was deleted from a
           // different view, then this view is restored. In this case, new
           // data is about to be loaded into the view anyway, so just remove
           // the item from the register and swallow the exception.
-          //qDebug("%s", qPrintable(e.what()));
+          //qDebug("%s", e.what());
           removeItem(t);
         }
         w = qMax(w, nw);
         if (maxWidth) {
           if (w > maxWidth) {
             w = maxWidth;
             break;
           }
         }
         if (w < minWidth) {
           w = minWidth;
           break;
         }
       }
     }
 
     return w;
 #endif
   }
 
   void Register::adjustColumn(int col)
   {
     setColumnWidth(col, minimumColumnWidth(col));
   }
 
   void Register::clearSelection()
   {
     unselectItems();
     TransactionEditorContainer::clearSelection();
   }
 
   void Register::doSelectItems(int from, int to, bool selected)
   {
     Q_D(Register);
     int start, end;
     // make sure start is smaller than end
     if (from <= to) {
       start = from;
       end = to;
     } else {
       start = to;
       end = from;
     }
     // make sure we stay in bounds
     if (start < 0)
       start = 0;
     if ((end <= -1) || (end > (d->m_items.size() - 1)))
       end = d->m_items.size() - 1;
 
     RegisterItem* firstItem;
     RegisterItem* lastItem;
     firstItem = lastItem = 0;
     for (int i = start; i <= end; ++i) {
       RegisterItem* const item = d->m_items[i];
       if (item) {
         if (selected != item->isSelected()) {
           if (!firstItem)
             firstItem = item;
           item->setSelected(selected);
           lastItem = item;
         }
       }
     }
   }
 
   RegisterItem* Register::itemAtRow(int row) const
   {
     Q_D(const Register);
     if (row >= 0 && row < d->m_itemIndex.size()) {
       return d->m_itemIndex[row];
     }
     return 0;
   }
 
   int Register::rowToIndex(int row) const
   {
     Q_D(const Register);
     for (auto i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* const item = d->m_items[i];
       if (!item)
         continue;
       if (row >= item->startRow() && row < (item->startRow() + item->numRowsRegister()))
         return i;
     }
     return -1;
   }
 
   void Register::selectedTransactions(SelectedTransactions& list) const
   {
     Q_D(const Register);
     if (d->m_focusItem && d->m_focusItem->isSelected() && d->m_focusItem->isVisible()) {
       auto t = dynamic_cast<Transaction*>(d->m_focusItem);
       if (t) {
         QString id;
         if (t->isScheduled())
           id = t->transaction().id();
         SelectedTransaction s(t->transaction(), t->split(), id);
         list << s;
       }
     }
 
     for (auto i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* const item = d->m_items[i];
       // make sure, we don't include the focus item twice
       if (item == d->m_focusItem)
         continue;
       if (item && item->isSelected() && item->isVisible()) {
         auto t = dynamic_cast<Transaction*>(item);
         if (t) {
           QString id;
           if (t->isScheduled())
             id = t->transaction().id();
           SelectedTransaction s(t->transaction(), t->split(), id);
           list << s;
         }
       }
     }
   }
 
   QList<RegisterItem*> Register::selectedItems() const
   {
     Q_D(const Register);
     QList<RegisterItem*> list;
 
     RegisterItem* item = d->m_firstItem;
     while (item) {
       if (item && item->isSelected() && item->isVisible()) {
         list << item;
       }
       item = item->nextItem();
     }
     return list;
   }
 
   int Register::selectedItemsCount() const
   {
     Q_D(const Register);
     auto cnt = 0;
     RegisterItem* item = d->m_firstItem;
     while (item) {
       if (item->isSelected() && item->isVisible())
         ++cnt;
       item = item->nextItem();
     }
     return cnt;
   }
 
   void Register::mouseReleaseEvent(QMouseEvent *e)
   {
     Q_D(Register);
     if (e->button() == Qt::RightButton) {
       // see the comment in Register::contextMenuEvent
       // on Linux we never get here but on Windows this
       // event is fired before the contextMenuEvent which
       // causes the loss of the multiple selection; to avoid
       // this just ignore the event and act like on Linux
       return;
     }
     if (d->m_ignoreNextButtonRelease) {
       d->m_ignoreNextButtonRelease = false;
       return;
     }
     d->m_mouseButton = e->button();
     d->m_modifiers = QApplication::keyboardModifiers();
     QTableWidget::mouseReleaseEvent(e);
   }
 
   void Register::contextMenuEvent(QContextMenuEvent *e)
   {
     Q_D(Register);
     if (e->reason() == QContextMenuEvent::Mouse) {
       // since mouse release event is not called, we need
       // to reset the mouse button and the modifiers here
       d->m_mouseButton = Qt::NoButton;
       d->m_modifiers = Qt::NoModifier;
 
       // if a selected item is clicked don't change the selection
       RegisterItem* item = itemAtRow(rowAt(e->y()));
       if (item && !item->isSelected())
         selectItem(rowAt(e->y()), columnAt(e->x()));
     }
     openContextMenu();
   }
 
   void Register::unselectItems(int from, int to)
   {
     doSelectItems(from, to, false);
   }
 
   void Register::selectItems(int from, int to)
   {
     doSelectItems(from, to, true);
   }
 
   void Register::selectItem(int row, int col)
   {
     Q_D(Register);
     if (row >= 0 && row < d->m_itemIndex.size()) {
       RegisterItem* item = d->m_itemIndex[row];
 
       // don't support selecting when the item has an editor
       // or the item itself is not selectable
       if (item->hasEditorOpen() || !item->isSelectable()) {
         d->m_mouseButton = Qt::NoButton;
         return;
       }
       QString id = item->id();
       selectItem(item);
       // selectItem() might have changed the pointers, so we
       // need to reconstruct it here
       item = itemById(id);
       auto t = dynamic_cast<Transaction*>(item);
       if (t) {
         if (!id.isEmpty()) {
           if (t && col == (int)eTransaction::Column::ReconcileFlag && selectedItemsCount() == 1 && !t->isScheduled())
             emit reconcileStateColumnClicked(t);
         } else {
           emit emptyItemSelected();
         }
       }
     }
   }
 
   void Register::setAnchorItem(RegisterItem* anchorItem)
   {
     Q_D(Register);
     d->m_selectAnchor = anchorItem;
   }
 
   bool Register::setFocusItem(RegisterItem* focusItem)
   {
     Q_D(Register);
     if (focusItem && focusItem->canHaveFocus()) {
       if (d->m_focusItem) {
         d->m_focusItem->setFocus(false);
       }
       auto item = dynamic_cast<Transaction*>(focusItem);
       if (d->m_focusItem != focusItem && item) {
         emit focusChanged(item);
       }
 
       d->m_focusItem = focusItem;
       d->m_focusItem->setFocus(true);
       if (d->m_listsDirty)
         updateRegister(KMyMoneySettings::ledgerLens() | !KMyMoneySettings::transactionForm());
       ensureItemVisible(d->m_focusItem);
       return true;
     } else
       return false;
   }
 
   bool Register::setFocusToTop()
   {
     Q_D(Register);
     RegisterItem* rgItem = d->m_firstItem;
     while (rgItem) {
       if (setFocusItem(rgItem))
         return true;
       rgItem = rgItem->nextItem();
     }
     return false;
   }
 
   void Register::selectItem(RegisterItem* item, bool dontChangeSelections)
   {
     Q_D(Register);
     if (!item)
       return;
 
     Qt::MouseButtons buttonState = d->m_mouseButton;
     Qt::KeyboardModifiers modifiers = d->m_modifiers;
     d->m_mouseButton = Qt::NoButton;
     d->m_modifiers = Qt::NoModifier;
 
     if (d->m_selectionMode == NoSelection)
       return;
 
     if (item->isSelectable()) {
       QString id = item->id();
       QList<RegisterItem*> itemList = selectedItems();
       bool okToSelect = true;
       auto cnt = itemList.count();
       auto scheduledTransactionSelected = false;
       if (cnt > 0) {
         auto& r = *(itemList.front());
         scheduledTransactionSelected = (typeid(r) == typeid(StdTransactionScheduled));
       }
       if (buttonState & Qt::LeftButton) {
         if (!(modifiers & (Qt::ShiftModifier | Qt::ControlModifier))
             || (d->m_selectAnchor == 0)) {
           if ((cnt != 1) || ((cnt == 1) && !item->isSelected())) {
             emit aboutToSelectItem(item, okToSelect);
             if (okToSelect) {
               // pointer 'item' might have changed. reconstruct it.
               item = itemById(id);
               unselectItems();
               item->setSelected(true);
               setFocusItem(item);
             }
           }
           if (okToSelect)
             d->m_selectAnchor = item;
         }
 
         if (d->m_selectionMode == MultiSelection) {
           switch (modifiers & (Qt::ShiftModifier | Qt::ControlModifier)) {
             case Qt::ControlModifier:
               if (scheduledTransactionSelected || typeid(*item) == typeid(StdTransactionScheduled))
                 okToSelect = false;
               // toggle selection state of current item
               emit aboutToSelectItem(item, okToSelect);
               if (okToSelect) {
                 // pointer 'item' might have changed. reconstruct it.
                 item = itemById(id);
                 item->setSelected(!item->isSelected());
                 setFocusItem(item);
               }
               break;
 
             case Qt::ShiftModifier:
               if (scheduledTransactionSelected || typeid(*item) == typeid(StdTransactionScheduled))
                 okToSelect = false;
               emit aboutToSelectItem(item, okToSelect);
               if (okToSelect) {
                 // pointer 'item' might have changed. reconstruct it.
                 item = itemById(id);
                 unselectItems();
                 if (d->m_selectAnchor)
                   selectItems(rowToIndex(d->m_selectAnchor->startRow()), rowToIndex(item->startRow()));
                 setFocusItem(item);
               }
               break;
           }
         }
       } else {
         // we get here when called by application logic
         emit aboutToSelectItem(item, okToSelect);
         if (okToSelect) {
           // pointer 'item' might have changed. reconstruct it.
           item = itemById(id);
           if (!dontChangeSelections)
             unselectItems();
           item->setSelected(true);
           setFocusItem(item);
           d->m_selectAnchor = item;
         }
       }
       if (okToSelect) {
         SelectedTransactions list(this);
         emit transactionsSelected(list);
       }
     }
   }
 
   void Register::ensureFocusItemVisible()
   {
     Q_D(Register);
     ensureItemVisible(d->m_focusItem);
   }
 
   void Register::ensureItemVisible(RegisterItem* item)
   {
     Q_D(Register);
     if (!item)
       return;
 
     d->m_ensureVisibleItem = item;
     QTimer::singleShot(0, this, SLOT(slotEnsureItemVisible()));
   }
 
   void Register::slotDoubleClicked(int row, int)
   {
     Q_D(Register);
     if (row >= 0 && row < d->m_itemIndex.size()) {
       RegisterItem* p = d->m_itemIndex[row];
       if (p->isSelectable()) {
         d->m_ignoreNextButtonRelease = true;
         // double click to start editing only works if the focus
         // item is among the selected ones
         if (!focusItem()) {
           setFocusItem(p);
           if (d->m_selectionMode != NoSelection)
             p->setSelected(true);
         }
 
         if (d->m_focusItem->isSelected()) {
           // don't emit the signal right away but wait until
           // we come back to the Qt main loop
           QTimer::singleShot(0, this, SIGNAL(editTransaction()));
         }
       }
     }
   }
 
   void Register::slotEnsureItemVisible()
   {
     Q_D(Register);
     // if clear() has been called since the timer was
     // started, we just ignore the call
     if (!d->m_ensureVisibleItem)
       return;
 
     // make sure to catch latest changes
     setUpdatesEnabled(false);
     updateRegister();
     setUpdatesEnabled(true);
     // since the item will be made visible at the top of the viewport make the bottom index visible first to make the whole item visible
     scrollTo(model()->index(d->m_ensureVisibleItem->startRow() + d->m_ensureVisibleItem->numRowsRegister() - 1, (int)eTransaction::Column::Detail));
     scrollTo(model()->index(d->m_ensureVisibleItem->startRow(), (int)eTransaction::Column::Detail));
   }
 
   QString Register::text(int /*row*/, int /*col*/) const
   {
     return QString("a");
   }
 
   QWidget* Register::createEditor(int /*row*/, int /*col*/, bool /*initFromCell*/) const
   {
     return 0;
   }
 
   void Register::setCellContentFromEditor(int /*row*/, int /*col*/)
   {
   }
 
   void Register::endEdit(int /*row*/, int /*col*/, bool /*accept*/, bool /*replace*/)
   {
   }
 
   RegisterItem* Register::focusItem() const
   {
     Q_D(const Register);
     return d->m_focusItem;
   }
 
   RegisterItem* Register::anchorItem() const
   {
     Q_D(const Register);
     return d->m_selectAnchor;
   }
 
   void Register::arrangeEditWidgets(QMap<QString, QWidget*>& editWidgets, KMyMoneyRegister::Transaction* t)
   {
     t->arrangeWidgetsInRegister(editWidgets);
     ensureItemVisible(t);
     // updateContents();
   }
 
   void Register::tabOrder(QWidgetList& tabOrderWidgets, KMyMoneyRegister::Transaction* t) const
   {
     t->tabOrderInRegister(tabOrderWidgets);
   }
 
   void Register::removeEditWidgets(QMap<QString, QWidget*>& editWidgets)
   {
     // remove pointers from map
     QMap<QString, QWidget*>::iterator it;
     for (it = editWidgets.begin(); it != editWidgets.end();) {
       if ((*it)->parentWidget() == this) {
         editWidgets.erase(it);
         it = editWidgets.begin();
       } else
         ++it;
     }
 
     // now delete the widgets
     if (auto t = dynamic_cast<KMyMoneyRegister::Transaction*>(focusItem())) {
       for (int row = t->startRow(); row < t->startRow() + t->numRowsRegister(true); ++row) {
         for (int col = 0; col < columnCount(); ++col) {
           if (cellWidget(row, col)) {
             cellWidget(row, col)->hide();
             setCellWidget(row, col, 0);
           }
         }
         // make sure to reduce the possibly size to what it was before editing started
         setRowHeight(row, t->rowHeightHint());
       }
     }
   }
 
   RegisterItem* Register::itemById(const QString& id) const
   {
     Q_D(const Register);
     if (id.isEmpty())
       return d->m_lastItem;
 
     for (QVector<RegisterItem*>::size_type i = 0; i < d->m_items.size(); ++i) {
       RegisterItem* item = d->m_items[i];
       if (!item)
         continue;
       if (item->id() == id)
         return item;
     }
     return 0;
   }
 
   void Register::handleItemChange(RegisterItem* old, bool shift, bool control)
   {
     Q_D(Register);
     if (d->m_selectionMode == MultiSelection) {
       if (shift) {
         selectRange(d->m_selectAnchor ? d->m_selectAnchor : old,
                     d->m_focusItem, false, true, (d->m_selectAnchor && !control) ? true : false);
       } else if (!control) {
         selectItem(d->m_focusItem, false);
       }
     }
   }
 
   void Register::selectRange(RegisterItem* from, RegisterItem* to, bool invert, bool includeFirst, bool clearSel)
   {
     if (!from || !to)
       return;
     if (from == to && !includeFirst)
       return;
     bool swap = false;
     if (to == from->prevItem())
       swap = true;
 
     RegisterItem* item;
     if (!swap && from != to && from != to->prevItem()) {
       bool found = false;
       for (item = from; item; item = item->nextItem()) {
         if (item == to) {
           found = true;
           break;
         }
       }
       if (!found)
         swap = true;
     }
 
     if (swap) {
       item = from;
       from = to;
       to = item;
       if (!includeFirst)
         to = to->prevItem();
 
     } else if (!includeFirst) {
       from = from->nextItem();
     }
 
     if (clearSel) {
       for (item = firstItem(); item; item = item->nextItem()) {
         if (item->isSelected() && item->isVisible()) {
           item->setSelected(false);
         }
       }
     }
 
     for (item = from; item; item = item->nextItem()) {
       if (item->isSelectable()) {
         if (!invert) {
           if (!item->isSelected() && item->isVisible()) {
             item->setSelected(true);
           }
         } else {
           bool sel = !item->isSelected();
           if ((item->isSelected() != sel) && item->isVisible()) {
             item->setSelected(sel);
           }
         }
       }
       if (item == to)
         break;
     }
   }
 
   void Register::scrollPage(int key, Qt::KeyboardModifiers modifiers)
   {
     Q_D(Register);
     RegisterItem* oldFocusItem = d->m_focusItem;
 
     // make sure we have a focus item
     if (!d->m_focusItem)
       setFocusItem(d->m_firstItem);
     if (!d->m_focusItem && d->m_firstItem)
       setFocusItem(d->m_firstItem->nextItem());
     if (!d->m_focusItem)
       return;
 
     RegisterItem* item = d->m_focusItem;
     int height = 0;
 
     switch (key) {
       case Qt::Key_PageUp:
         while (height < viewport()->height() && item->prevItem()) {
           do {
             item = item->prevItem();
             if (item->isVisible())
               height += item->rowHeightHint();
           } while ((!item->isSelectable() || !item->isVisible()) && item->prevItem());
           while ((!item->isSelectable() || !item->isVisible()) && item->nextItem())
             item = item->nextItem();
         }
         break;
       case Qt::Key_PageDown:
         while (height < viewport()->height() && item->nextItem()) {
           do {
             if (item->isVisible())
               height += item->rowHeightHint();
             item = item->nextItem();
           } while ((!item->isSelectable() || !item->isVisible()) && item->nextItem());
           while ((!item->isSelectable() || !item->isVisible()) && item->prevItem())
             item = item->prevItem();
         }
         break;
 
       case Qt::Key_Up:
         if (item->prevItem()) {
           do {
             item = item->prevItem();
           } while ((!item->isSelectable() || !item->isVisible()) && item->prevItem());
         }
         break;
 
       case Qt::Key_Down:
         if (item->nextItem()) {
           do {
             item = item->nextItem();
           } while ((!item->isSelectable() || !item->isVisible()) && item->nextItem());
         }
         break;
 
       case Qt::Key_Home:
         item = d->m_firstItem;
         while ((!item->isSelectable() || !item->isVisible()) && item->nextItem())
           item = item->nextItem();
         break;
 
       case Qt::Key_End:
         item = d->m_lastItem;
         while ((!item->isSelectable() || !item->isVisible()) && item->prevItem())
           item = item->prevItem();
         break;
     }
 
     // make sure to avoid selecting a possible empty transaction at the end
     auto t = dynamic_cast<Transaction*>(item);
     if (t && t->transaction().id().isEmpty()) {
       if (t->prevItem()) {
         item = t->prevItem();
       }
     }
 
     if (!(modifiers & Qt::ShiftModifier) || !d->m_selectAnchor)
       d->m_selectAnchor = item;
 
     setFocusItem(item);
 
     if (item->isSelectable()) {
       handleItemChange(oldFocusItem, modifiers & Qt::ShiftModifier, modifiers & Qt::ControlModifier);
       // tell the world about the changes in selection
       SelectedTransactions list(this);
       emit transactionsSelected(list);
     }
 
     if (d->m_focusItem && !d->m_focusItem->isSelected() && d->m_selectionMode == SingleSelection)
       selectItem(item);
 
   }
 
   void Register::keyPressEvent(QKeyEvent* ev)
   {
     Q_D(Register);
     switch (ev->key()) {
       case Qt::Key_Space:
         if (d->m_selectionMode != NoSelection) {
           // get the state out of the event ...
           d->m_modifiers = ev->modifiers();
           // ... and pretend that we have pressed the left mouse button ;)
           d->m_mouseButton = Qt::LeftButton;
           selectItem(d->m_focusItem);
         }
         break;
 
       case Qt::Key_PageUp:
       case Qt::Key_PageDown:
       case Qt::Key_Home:
       case Qt::Key_End:
       case Qt::Key_Down:
       case Qt::Key_Up:
         scrollPage(ev->key(), ev->modifiers());
         break;
       case Qt::Key_Enter:
       case Qt::Key_Return:
         // don't emit the signal right away but wait until
         // we come back to the Qt main loop
         QTimer::singleShot(0, this, SIGNAL(editTransaction()));
         break;
 
       default:
         QTableWidget::keyPressEvent(ev);
         break;
     }
   }
 
   Transaction* Register::transactionFactory(Register *parent, const MyMoneyTransaction& transaction, const MyMoneySplit& split, int uniqueId)
   {
     Transaction* t = 0;
     MyMoneySplit s = split;
 
     if (parent->account() == MyMoneyAccount()) {
       t = new KMyMoneyRegister::StdTransaction(parent, transaction, s, uniqueId);
       return t;
     }
 
     switch (parent->account().accountType()) {
       case Account::Type::Checkings:
       case Account::Type::Savings:
       case Account::Type::Cash:
       case Account::Type::CreditCard:
       case Account::Type::Loan:
       case Account::Type::Asset:
       case Account::Type::Liability:
       case Account::Type::Currency:
       case Account::Type::Income:
       case Account::Type::Expense:
       case Account::Type::AssetLoan:
       case Account::Type::Equity:
         if (s.accountId().isEmpty())
           s.setAccountId(parent->account().id());
         if (s.isMatched())
           t = new KMyMoneyRegister::StdTransactionMatched(parent, transaction, s, uniqueId);
         else if (transaction.isImported())
           t = new KMyMoneyRegister::StdTransactionDownloaded(parent, transaction, s, uniqueId);
         else
           t = new KMyMoneyRegister::StdTransaction(parent, transaction, s, uniqueId);
         break;
 
       case Account::Type::Investment:
         if (s.isMatched())
           t = new KMyMoneyRegister::InvestTransaction/* Matched */(parent, transaction, s, uniqueId);
         else if (transaction.isImported())
           t = new KMyMoneyRegister::InvestTransactionDownloaded(parent, transaction, s, uniqueId);
         else
           t = new KMyMoneyRegister::InvestTransaction(parent, transaction, s, uniqueId);
         break;
 
       case Account::Type::CertificateDep:
       case Account::Type::MoneyMarket:
       case Account::Type::Stock:
       default:
         qDebug("Register::transactionFactory: invalid accountTypeE %d", (int)parent->account().accountType());
         break;
     }
     return t;
   }
 
   const MyMoneyAccount& Register::account() const
   {
     Q_D(const Register);
     return d->m_account;
   }
 
   void Register::addGroupMarkers()
   {
     Q_D(Register);
     QMap<QString, int> list;
     QMap<QString, int>::const_iterator it;
     KMyMoneyRegister::RegisterItem* p = firstItem();
     KMyMoneyRegister::Transaction* t;
     QString name;
     QDate today;
     QDate yesterday, thisWeek, lastWeek;
     QDate thisMonth, lastMonth;
     QDate thisYear;
     int weekStartOfs;
 
     switch (primarySortKey()) {
       case SortField::PostDate:
       case SortField::EntryDate:
         today = QDate::currentDate();
         thisMonth.setDate(today.year(), today.month(), 1);
         lastMonth = thisMonth.addMonths(-1);
         yesterday = today.addDays(-1);
         // a = QDate::dayOfWeek()         todays weekday (1 = Monday, 7 = Sunday)
         // b = QLocale().firstDayOfWeek() first day of week (1 = Monday, 7 = Sunday)
         weekStartOfs = today.dayOfWeek() - QLocale().firstDayOfWeek();
         if (weekStartOfs < 0) {
           weekStartOfs = 7 + weekStartOfs;
         }
         thisWeek = today.addDays(-weekStartOfs);
         lastWeek = thisWeek.addDays(-7);
         thisYear.setDate(today.year(), 1, 1);
         if (KMyMoneySettings::startDate().date() != QDate(1900, 1, 1))
           new KMyMoneyRegister::FancyDateGroupMarker(this, KMyMoneySettings::startDate().date(), i18n("Prior transactions possibly filtered"));
 
         if (KMyMoneySettings::showFancyMarker()) {
           if (d->m_account.lastReconciliationDate().isValid())
             new KMyMoneyRegister::StatementGroupMarker(this, eRegister::CashFlowDirection::Deposit, d->m_account.lastReconciliationDate(), i18n("Last reconciliation"));
 
           if (!d->m_account.value("lastImportedTransactionDate").isEmpty()
               && !d->m_account.value("lastStatementBalance").isEmpty()) {
             MyMoneyMoney balance(d->m_account.value("lastStatementBalance"));
             if (d->m_account.accountGroup() == Account::Type::Liability)
               balance = -balance;
             auto txt = i18n("Online Statement Balance: %1", balance.formatMoney(d->m_account.fraction()));
 
             KMyMoneyRegister::StatementGroupMarker *pGroupMarker = new KMyMoneyRegister::StatementGroupMarker(this, eRegister::CashFlowDirection::Deposit, QDate::fromString(d->m_account.value("lastImportedTransactionDate"), Qt::ISODate), txt);
 
             pGroupMarker->setErroneous(!MyMoneyFile::instance()->hasMatchingOnlineBalance(d->m_account));
           }
 
           new KMyMoneyRegister::FancyDateGroupMarker(this, thisYear, i18n("This year"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, lastMonth, i18n("Last month"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, thisMonth, i18n("This month"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, lastWeek, i18n("Last week"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, thisWeek, i18n("This week"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, yesterday, i18n("Yesterday"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, today, i18n("Today"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, today.addDays(1), i18n("Future transactions"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, thisWeek.addDays(7), i18n("Next week"));
           new KMyMoneyRegister::FancyDateGroupMarker(this, thisMonth.addMonths(1), i18n("Next month"));
 
         } else {
           new KMyMoneyRegister::SimpleDateGroupMarker(this, today.addDays(1), i18n("Future transactions"));
         }
         if (KMyMoneySettings::showFiscalMarker()) {
           QDate currentFiscalYear = KMyMoneySettings::firstFiscalDate();
           new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear, i18n("Current fiscal year"));
           new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear.addYears(-1), i18n("Previous fiscal year"));
           new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear.addYears(1), i18n("Next fiscal year"));
         }
         break;
 
       case SortField::Type:
         if (KMyMoneySettings::showFancyMarker()) {
           new KMyMoneyRegister::TypeGroupMarker(this, eRegister::CashFlowDirection::Deposit, d->m_account.accountType());
           new KMyMoneyRegister::TypeGroupMarker(this, eRegister::CashFlowDirection::Payment, d->m_account.accountType());
         }
         break;
 
       case SortField::ReconcileState:
         if (KMyMoneySettings::showFancyMarker()) {
           new KMyMoneyRegister::ReconcileGroupMarker(this, eMyMoney::Split::State::NotReconciled);
           new KMyMoneyRegister::ReconcileGroupMarker(this, eMyMoney::Split::State::Cleared);
           new KMyMoneyRegister::ReconcileGroupMarker(this, eMyMoney::Split::State::Reconciled);
           new KMyMoneyRegister::ReconcileGroupMarker(this, eMyMoney::Split::State::Frozen);
         }
         break;
 
       case SortField::Payee:
         if (KMyMoneySettings::showFancyMarker()) {
           while (p) {
             if ((t = dynamic_cast<KMyMoneyRegister::Transaction*>(p)))
               list[t->sortPayee()] = 1;
             p = p->nextItem();
           }
           for (it = list.constBegin(); it != list.constEnd(); ++it) {
             name = it.key();
             if (name.isEmpty()) {
               name = i18nc("Unknown payee", "Unknown");
             }
             new KMyMoneyRegister::PayeeGroupMarker(this, name);
           }
         }
         break;
 
       case SortField::Category:
         if (KMyMoneySettings::showFancyMarker()) {
           while (p) {
             if ((t = dynamic_cast<KMyMoneyRegister::Transaction*>(p)))
               list[t->sortCategory()] = 1;
             p = p->nextItem();
           }
           for (it = list.constBegin(); it != list.constEnd(); ++it) {
             name = it.key();
             if (name.isEmpty()) {
               name = i18nc("Unknown category", "Unknown");
             }
             new KMyMoneyRegister::CategoryGroupMarker(this, name);
           }
         }
         break;
 
       case SortField::Security:
         if (KMyMoneySettings::showFancyMarker()) {
           while (p) {
             if ((t = dynamic_cast<KMyMoneyRegister::InvestTransaction*>(p)))
               list[t->sortSecurity()] = 1;
             p = p->nextItem();
           }
           for (it = list.constBegin(); it != list.constEnd(); ++it) {
             name = it.key();
             if (name.isEmpty()) {
               name = i18nc("Unknown security", "Unknown");
             }
             new KMyMoneyRegister::CategoryGroupMarker(this, name);
           }
         }
         break;
 
       default: // no markers supported
         break;
     }
   }
 
   void Register::removeUnwantedGroupMarkers()
   {
     // remove all trailing group markers except statement markers
     KMyMoneyRegister::RegisterItem* q;
     KMyMoneyRegister::RegisterItem* p = lastItem();
     while (p) {
       q = p;
       if (dynamic_cast<KMyMoneyRegister::Transaction*>(p)
           || dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(p))
         break;
 
       p = p->prevItem();
       delete q;
     }
 
     // remove all adjacent group markers
     bool lastWasGroupMarker = false;
     p = lastItem();
     while (p) {
       q = p;
       auto m = dynamic_cast<KMyMoneyRegister::GroupMarker*>(p);
       p = p->prevItem();
       if (m) {
         m->markVisible(true);
         // make adjacent group marker invisible except those that show statement information
         if (lastWasGroupMarker && (dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(m) == 0)) {
           m->markVisible(false);
         }
         lastWasGroupMarker = true;
       } else if (q->isVisible())
         lastWasGroupMarker = false;
     }
   }
 
   void Register::setLedgerLensForced(bool forced)
   {
     Q_D(Register);
     d->m_ledgerLensForced = forced;
   }
 
   bool Register::ledgerLens() const
   {
     Q_D(const Register);
     return d->m_ledgerLensForced;
   }
 
   void Register::setSelectionMode(SelectionMode mode)
   {
     Q_D(Register);
     d->m_selectionMode = mode;
   }
 
   void Register::setUsedWithEditor(bool value)
   {
     Q_D(Register);
     d->m_usedWithEditor = value;
   }
 
   eRegister::DetailColumn Register::getDetailsColumnType() const
   {
     Q_D(const Register);
     return d->m_detailsColumnType;
   }
 
   void Register::setDetailsColumnType(eRegister::DetailColumn detailsColumnType)
   {
     Q_D(Register);
     d->m_detailsColumnType = detailsColumnType;
   }
 }
diff --git a/kmymoney/widgets/selectedtransaction.cpp b/kmymoney/widgets/selectedtransaction.cpp
index 71187129d..ac17d5be1 100644
--- a/kmymoney/widgets/selectedtransaction.cpp
+++ b/kmymoney/widgets/selectedtransaction.cpp
@@ -1,130 +1,130 @@
 /***************************************************************************
                           selectedtransaction.cpp  -  description
                              -------------------
     begin                : Fri Jun 2008
     copyright            : (C) 2000-2008 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "selectedtransaction.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 using namespace KMyMoneyRegister;
 
 namespace KMyMoneyRegister
 {
   class SelectedTransactionPrivate
   {
   public:
     MyMoneyTransaction      m_transaction;
     MyMoneySplit            m_split;
     QString                 m_scheduleId;
   };
 }
 
 SelectedTransaction::SelectedTransaction() :
   d_ptr(new SelectedTransactionPrivate)
 {
 }
 
 SelectedTransaction::SelectedTransaction(const MyMoneyTransaction& t, const MyMoneySplit& s, const QString& scheduleId = QString()) :
   d_ptr(new SelectedTransactionPrivate)
 {
   Q_D(SelectedTransaction);
   d->m_transaction = t;
   d->m_split = s;
   d->m_scheduleId = scheduleId;
 }
 
 SelectedTransaction::SelectedTransaction(const SelectedTransaction& other) :
   d_ptr(new SelectedTransactionPrivate(*other.d_func()))
 {
 }
 
 SelectedTransaction::~SelectedTransaction()
 {
   Q_D(SelectedTransaction);
   delete d;
 }
 
 MyMoneyTransaction& SelectedTransaction::transaction()
 {
   Q_D(SelectedTransaction);
   return d->m_transaction;
 }
 
 MyMoneyTransaction SelectedTransaction::transaction() const
 {
   Q_D(const SelectedTransaction);
   return d->m_transaction;
 }
 
 MyMoneySplit& SelectedTransaction::split()
 {
   Q_D(SelectedTransaction);
   return d->m_split;
 }
 
 MyMoneySplit SelectedTransaction::split() const
 {
   Q_D(const SelectedTransaction);
   return d->m_split;
 }
 
 bool SelectedTransaction::isScheduled() const
 {
   Q_D(const SelectedTransaction);
   return !d->m_scheduleId.isEmpty();
 }
 
 QString SelectedTransaction::scheduleId() const
 {
   Q_D(const SelectedTransaction);
   return d->m_scheduleId;
 }
 
 int SelectedTransaction::warnLevel() const
 {
   auto warnLevel = 0;
   foreach (const auto split, transaction().splits()) {
     try {
       auto acc = MyMoneyFile::instance()->account(split.accountId());
       if (acc.isClosed())
         warnLevel = 3;
       else if (split.reconcileFlag() == eMyMoney::Split::State::Frozen)
         warnLevel = 2;
       else if (split.reconcileFlag() == eMyMoney::Split::State::Reconciled && warnLevel < 1)
         warnLevel = 1;
     } catch (const MyMoneyException &) {
-      //qDebug("Exception in SelectedTransaction::warnLevel(): %s", qPrintable(e.what()));
+      //qDebug("Exception in SelectedTransaction::warnLevel(): %s", e.what());
       warnLevel = 0;
     }
   }
   return warnLevel;
 }
 
diff --git a/kmymoney/wizards/endingbalancedlg/kendingbalancedlg.cpp b/kmymoney/wizards/endingbalancedlg/kendingbalancedlg.cpp
index a3f978e68..0b77abd45 100644
--- a/kmymoney/wizards/endingbalancedlg/kendingbalancedlg.cpp
+++ b/kmymoney/wizards/endingbalancedlg/kendingbalancedlg.cpp
@@ -1,435 +1,435 @@
 /***************************************************************************
                           kendingbalancedlg.cpp
                              -------------------
     copyright            : (C) 2000,2003 by Michael Edwardes, Thomas Baumgart
     email                : mte@users.sourceforge.net
                            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 "kendingbalancedlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDate>
 #include <QList>
 #include <QBitArray>
 #include <QAbstractButton>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KStandardGuiItem>
 #include <KHelpClient>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kendingbalancedlg.h"
 #include "ui_checkingstatementinfowizardpage.h"
 #include "ui_interestchargecheckingswizardpage.h"
 
 #include "mymoneymoney.h"
 #include "mymoneyexception.h"
 #include "mymoneyutils.h"
 #include "mymoneytracer.h"
 #include "kmymoneyedit.h"
 #include "mymoneysplit.h"
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneypayee.h"
 #include "mymoneysecurity.h"
 #include "mymoneytransaction.h"
 #include "mymoneytransactionfilter.h"
 #include "kmymoneycategory.h"
 #include "kmymoneyaccountselector.h"
 #include "kmymoneyutils.h"
 #include "kcurrencycalculator.h"
 #include "kmymoneysettings.h"
 #include "knewaccountdlg.h"
 #include "mymoneyenums.h"
 
 class KEndingBalanceDlgPrivate
 {
   Q_DISABLE_COPY(KEndingBalanceDlgPrivate)
 
 public:
 
   KEndingBalanceDlgPrivate(int numPages) :
     ui(new Ui::KEndingBalanceDlg),
     m_pages(numPages, true)
   {
   }
 
   ~KEndingBalanceDlgPrivate()
   {
     delete ui;
   }
 
   Ui::KEndingBalanceDlg    *ui;
   MyMoneyTransaction        m_tInterest;
   MyMoneyTransaction        m_tCharges;
   MyMoneyAccount            m_account;
   QMap<QWidget*, QString>   m_helpAnchor;
   QBitArray m_pages;
 };
 
 KEndingBalanceDlg::KEndingBalanceDlg(const MyMoneyAccount& account, QWidget *parent) :
     QWizard(parent),
     d_ptr(new KEndingBalanceDlgPrivate(Page_InterestChargeCheckings + 1))
 {
   Q_D(KEndingBalanceDlg);
   setModal(true);
   QString value;
   MyMoneyMoney endBalance, startBalance;
 
   d->ui->setupUi(this);
   d->m_account = account;
 
   MyMoneySecurity currency = MyMoneyFile::instance()->security(account.currencyId());
   //FIXME: port
   d->ui->m_statementInfoPageCheckings->ui->m_enterInformationLabel->setText(QString("<qt>") + i18n("Please enter the following fields with the information as you find them on your statement. Make sure to enter all values in <b>%1</b>.", currency.name()) + QString("</qt>"));
 
   // If the previous reconciliation was postponed,
   // we show a different first page
   value = account.value("lastReconciledBalance");
   if (value.isEmpty()) {
     // if the last statement has been entered long enough ago (more than one month),
     // then take the last statement date and add one month and use that as statement
     // date.
     QDate lastStatementDate = account.lastReconciliationDate();
     if (lastStatementDate.addMonths(1) < QDate::currentDate()) {
       setField("statementDate", lastStatementDate.addMonths(1));
     }
 
     slotUpdateBalances();
 
     d->m_pages.clearBit(Page_PreviousPostpone);
   } else {
     d->m_pages.clearBit(Page_CheckingStart);
     d->m_pages.clearBit(Page_InterestChargeCheckings);
     //removePage(d->ui->m_interestChargeCheckings);
     // make sure, we show the correct start page
     setStartId(Page_PreviousPostpone);
 
     MyMoneyMoney factor(1, 1);
     if (d->m_account.accountGroup() == eMyMoney::Account::Type::Liability)
       factor = -factor;
 
     startBalance = MyMoneyMoney(value) * factor;
     value = account.value("statementBalance");
     endBalance = MyMoneyMoney(value) * factor;
 
     //FIXME: port
     d->ui->m_statementInfoPageCheckings->ui->m_previousBalance->setValue(startBalance);
     d->ui->m_statementInfoPageCheckings->ui->m_endingBalance->setValue(endBalance);
   }
 
   // We don't need to add the default into the list (see ::help() why)
   // m_helpAnchor[m_startPageCheckings] = QString(QString());
   d->m_helpAnchor[d->ui->m_interestChargeCheckings] = QString("details.reconcile.wizard.interest");
   d->m_helpAnchor[d->ui->m_statementInfoPageCheckings] = QString("details.reconcile.wizard.statement");
 
   value = account.value("statementDate");
   if (!value.isEmpty())
     setField("statementDate", QDate::fromString(value, Qt::ISODate));
 
   //FIXME: port
   d->ui->m_statementInfoPageCheckings->ui->m_lastStatementDate->setText(QString());
   if (account.lastReconciliationDate().isValid()) {
     d->ui->m_statementInfoPageCheckings->ui->m_lastStatementDate->setText(i18n("Last reconciled statement: %1", QLocale().toString(account.lastReconciliationDate())));
   }
 
   // connect the signals with the slots
   connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, this, &KEndingBalanceDlg::slotReloadEditWidgets);
   connect(d->ui->m_statementInfoPageCheckings->ui->m_statementDate, &KMyMoneyDateInput::dateChanged, this, &KEndingBalanceDlg::slotUpdateBalances);
   connect(d->ui->m_interestChargeCheckings->ui->m_interestCategoryEdit, &KMyMoneyCombo::createItem, this, &KEndingBalanceDlg::slotCreateInterestCategory);
   connect(d->ui->m_interestChargeCheckings->ui->m_chargesCategoryEdit, &KMyMoneyCombo::createItem, this, &KEndingBalanceDlg::slotCreateChargesCategory);
   connect(d->ui->m_interestChargeCheckings->ui->m_payeeEdit, &KMyMoneyMVCCombo::createItem, this, &KEndingBalanceDlg::slotNewPayee);
 
   KMyMoneyMVCCombo::setSubstringSearchForChildren(d->ui->m_interestChargeCheckings, !KMyMoneySettings::stringMatchFromStart());
 
   slotReloadEditWidgets();
 
   // preset payee if possible
   try {
     // if we find a payee with the same name as the institution,
     // than this is what we use as payee.
     if (!d->m_account.institutionId().isEmpty()) {
       MyMoneyInstitution inst = MyMoneyFile::instance()->institution(d->m_account.institutionId());
       MyMoneyPayee payee = MyMoneyFile::instance()->payeeByName(inst.name());
       setField("payeeEdit", payee.id());
     }
   } catch (const MyMoneyException &) {
   }
 
   KMyMoneyUtils::updateWizardButtons(this);
 
   // setup different text and icon on finish button
   setButtonText(QWizard::FinishButton, KStandardGuiItem::cont().text());
   button(QWizard::FinishButton)->setIcon(KStandardGuiItem::cont().icon());
 }
 
 KEndingBalanceDlg::~KEndingBalanceDlg()
 {
   Q_D(KEndingBalanceDlg);
   delete d;
 }
 
 void KEndingBalanceDlg::slotUpdateBalances()
 {
   Q_D(KEndingBalanceDlg);
   MYMONEYTRACER(tracer);
 
   // determine the beginning balance and ending balance based on the following
   // forumulas:
   //
   // end balance   = current balance - sum(all non cleared transactions)
   //                                 - sum(all cleared transactions posted
   //                                        after statement date)
   // start balance = end balance - sum(all cleared transactions
   //                                        up to statement date)
   MyMoneyTransactionFilter filter(d->m_account.id());
   filter.addState((int)eMyMoney::TransactionFilter::State::NotReconciled);
   filter.setReportAllSplits(true);
 
   QList<QPair<MyMoneyTransaction, MyMoneySplit> > transactionList;
   QList<QPair<MyMoneyTransaction, MyMoneySplit> >::const_iterator it;
 
   // retrieve the list from the engine
   MyMoneyFile::instance()->transactionList(transactionList, filter);
 
   //first retrieve the oldest not reconciled transaction
   QDate oldestTransactionDate;
   it = transactionList.constBegin();
   if (it != transactionList.constEnd()) {
     oldestTransactionDate = (*it).first.postDate();
     d->ui->m_statementInfoPageCheckings->ui->m_oldestTransactionDate->setText(i18n("Oldest unmarked transaction: %1", QLocale().toString(oldestTransactionDate)));
   }
 
   filter.addState((int)eMyMoney::TransactionFilter::State::Cleared);
 
   // retrieve the list from the engine to calculate the starting and ending balance
   MyMoneyFile::instance()->transactionList(transactionList, filter);
 
   MyMoneyMoney balance = MyMoneyFile::instance()->balance(d->m_account.id());
   MyMoneyMoney factor(1, 1);
   if (d->m_account.accountGroup() == eMyMoney::Account::Type::Liability)
     factor = -factor;
 
   MyMoneyMoney endBalance, startBalance;
   balance = balance * factor;
   endBalance = startBalance = balance;
 
   tracer.printf("total balance = %s", qPrintable(endBalance.formatMoney(QString(), 2)));
 
   for (it = transactionList.constBegin(); it != transactionList.constEnd(); ++it) {
     const MyMoneySplit& split = (*it).second;
     balance -= split.shares() * factor;
     if ((*it).first.postDate() > field("statementDate").toDate()) {
       tracer.printf("Reducing balances by %s because postdate of %s/%s(%s) is past statement date", qPrintable((split.shares() * factor).formatMoney(QString(), 2)), qPrintable((*it).first.id()), qPrintable(split.id()), qPrintable((*it).first.postDate().toString(Qt::ISODate)));
       endBalance -= split.shares() * factor;
       startBalance -= split.shares() * factor;
     } else {
       switch (split.reconcileFlag()) {
         case eMyMoney::Split::State::NotReconciled:
           tracer.printf("Reducing balances by %s because %s/%s(%s) is not reconciled", qPrintable((split.shares() * factor).formatMoney(QString(), 2)), qPrintable((*it).first.id()), qPrintable(split.id()), qPrintable((*it).first.postDate().toString(Qt::ISODate)));
           endBalance -= split.shares() * factor;
           startBalance -= split.shares() * factor;
           break;
         case eMyMoney::Split::State::Cleared:
           tracer.printf("Reducing start balance by %s because %s/%s(%s) is cleared", qPrintable((split.shares() * factor).formatMoney(QString(), 2)), qPrintable((*it).first.id()), qPrintable(split.id()), qPrintable((*it).first.postDate().toString(Qt::ISODate)));
           startBalance -= split.shares() * factor;
           break;
         default:
           break;
       }
     }
   }
   //FIXME: port
   d->ui->m_statementInfoPageCheckings->ui->m_previousBalance->setValue(startBalance);
   d->ui->m_statementInfoPageCheckings->ui->m_endingBalance->setValue(endBalance);
   tracer.printf("total balance = %s", qPrintable(endBalance.formatMoney(QString(), 2)));
   tracer.printf("start balance = %s", qPrintable(startBalance.formatMoney(QString(), 2)));
 
   setField("interestDateEdit", field("statementDate").toDate());
   setField("chargesDateEdit", field("statementDate").toDate());
 }
 
 void KEndingBalanceDlg::accept()
 {
   Q_D(KEndingBalanceDlg);
   if ((!field("interestEditValid").toBool() || createTransaction(d->m_tInterest, -1, field("interestEdit").value<MyMoneyMoney>(), field("interestCategoryEdit").toString(), field("interestDateEdit").toDate()))
       && (!field("chargesEditValid").toBool() || createTransaction(d->m_tCharges, 1, field("chargesEdit").value<MyMoneyMoney>(), field("chargesCategoryEdit").toString(), field("chargesDateEdit").toDate())))
     QWizard::accept();
 }
 
 void KEndingBalanceDlg::slotCreateInterestCategory(const QString& txt, QString& id)
 {
   createCategory(txt, id, MyMoneyFile::instance()->income());
 }
 
 void KEndingBalanceDlg::slotCreateChargesCategory(const QString& txt, QString& id)
 {
   createCategory(txt, id, MyMoneyFile::instance()->expense());
 }
 
 void KEndingBalanceDlg::createCategory(const QString& txt, QString& id, const MyMoneyAccount& parent)
 {
   MyMoneyAccount acc;
   acc.setName(txt);
 
   KNewAccountDlg::createCategory(acc, parent);
 
   id = acc.id();
 }
 
 void KEndingBalanceDlg::slotNewPayee(const QString& newnameBase, QString& id)
 {
   KMyMoneyUtils::newPayee(newnameBase, id);
 }
 
 MyMoneyMoney KEndingBalanceDlg::endingBalance() const
 {
   Q_D(const KEndingBalanceDlg);
   return adjustedReturnValue(d->ui->m_statementInfoPageCheckings->ui->m_endingBalance->value());
 }
 
 MyMoneyMoney KEndingBalanceDlg::previousBalance() const
 {
   Q_D(const KEndingBalanceDlg);
   return adjustedReturnValue(d->ui->m_statementInfoPageCheckings->ui->m_previousBalance->value());
 }
 
 QDate KEndingBalanceDlg::statementDate() const
 {
   return field("statementDate").toDate();
 }
 
 MyMoneyMoney KEndingBalanceDlg::adjustedReturnValue(const MyMoneyMoney& v) const
 {
   Q_D(const KEndingBalanceDlg);
   return d->m_account.accountGroup() == eMyMoney::Account::Type::Liability ? -v : v;
 }
 
 void KEndingBalanceDlg::slotReloadEditWidgets()
 {
   Q_D(KEndingBalanceDlg);
   QString payeeId, interestId, chargesId;
 
   // keep current selected items
   payeeId = field("payeeEdit").toString();
   interestId = field("interestCategoryEdit").toString();
   chargesId = field("chargesCategoryEdit").toString();
 
   // load the payee and category widgets with data from the engine
   //FIXME: port
   d->ui->m_interestChargeCheckings->ui->m_payeeEdit->loadPayees(MyMoneyFile::instance()->payeeList());
 
   // a user request to show all categories in both selectors due to a valid use case.
   AccountSet aSet;
   aSet.addAccountGroup(eMyMoney::Account::Type::Expense);
   aSet.addAccountGroup(eMyMoney::Account::Type::Income);
   //FIXME: port
   aSet.load(d->ui->m_interestChargeCheckings->ui->m_interestCategoryEdit->selector());
   aSet.load(d->ui->m_interestChargeCheckings->ui->m_chargesCategoryEdit->selector());
 
   // reselect currently selected items
   if (!payeeId.isEmpty())
     setField("payeeEdit", payeeId);
   if (!interestId.isEmpty())
     setField("interestCategoryEdit", interestId);
   if (!chargesId.isEmpty())
     setField("chargesCategoryEdit", chargesId);
 }
 
 MyMoneyTransaction KEndingBalanceDlg::interestTransaction()
 {
   Q_D(KEndingBalanceDlg);
   return d->m_tInterest;
 }
 
 MyMoneyTransaction KEndingBalanceDlg::chargeTransaction()
 {
   Q_D(KEndingBalanceDlg);
   return d->m_tCharges;
 }
 
 bool KEndingBalanceDlg::createTransaction(MyMoneyTransaction &t, const int sign, const MyMoneyMoney& amount, const QString& category, const QDate& date)
 {
   Q_D(KEndingBalanceDlg);
   t = MyMoneyTransaction();
 
   if (category.isEmpty() || !date.isValid())
     return true;
 
   MyMoneySplit s1, s2;
   MyMoneyMoney val = amount * MyMoneyMoney(sign, 1);
   try {
     t.setPostDate(date);
     t.setCommodity(d->m_account.currencyId());
 
     s1.setPayeeId(field("payeeEdit").toString());
     s1.setReconcileFlag(eMyMoney::Split::State::Cleared);
     s1.setAccountId(d->m_account.id());
     s1.setValue(-val);
     s1.setShares(-val);
 
     s2 = s1;
     s2.setAccountId(category);
     s2.setValue(val);
 
     t.addSplit(s1);
     t.addSplit(s2);
 
     QMap<QString, MyMoneyMoney> priceInfo; // just empty
     MyMoneyMoney shares;
     if (!KCurrencyCalculator::setupSplitPrice(shares, t, s2, priceInfo, this)) {
       t = MyMoneyTransaction();
       return false;
     }
 
     s2.setShares(shares);
     t.modifySplit(s2);
 
   } catch (const MyMoneyException &e) {
-    qDebug("%s", qPrintable(e.what()));
+    qDebug("%s", e.what());
     t = MyMoneyTransaction();
     return false;
   }
 
   return true;
 }
 
 void KEndingBalanceDlg::help()
 {
   Q_D(KEndingBalanceDlg);
   QString anchor = d->m_helpAnchor[currentPage()];
   if (anchor.isEmpty())
     anchor = QString("details.reconcile.whatis");
 
   KHelpClient::invokeHelp(anchor);
 }
 
 int KEndingBalanceDlg::nextId() const
 {
   Q_D(const KEndingBalanceDlg);
   // Starting from the current page, look for the first enabled page
   // and return that value
   // If the end of the list is encountered first, then return -1.
   for (int i = currentId() + 1; i < d->m_pages.size() && i < pageIds().size(); ++i) {
     if (d->m_pages.testBit(i))
       return pageIds()[i];
   }
   return -1;
 }
diff --git a/kmymoney/wizards/newaccountwizard/kloandetailspage.cpp b/kmymoney/wizards/newaccountwizard/kloandetailspage.cpp
index 6d8922c77..71feae450 100644
--- a/kmymoney/wizards/newaccountwizard/kloandetailspage.cpp
+++ b/kmymoney/wizards/newaccountwizard/kloandetailspage.cpp
@@ -1,424 +1,424 @@
 /***************************************************************************
                              kloandetailspage.cpp
                              -------------------
     begin                : Tue Sep 25 2006
     copyright            : (C) 2007 Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "kloandetailspage.h"
 #include "kloandetailspage_p.h"
 
 #include <qmath.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPushButton>
 #include <QSpinBox>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KComboBox>
 #include <KLineEdit>
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_kgeneralloaninfopage.h"
 #include "ui_kloandetailspage.h"
 
 #include "kmymoneyedit.h"
 #include "kmymoneyfrequencycombo.h"
 #include "knewaccountwizard.h"
 #include "knewaccountwizard_p.h"
 #include "kgeneralloaninfopage.h"
 #include "kgeneralloaninfopage_p.h"
 #include "kloanpaymentpage.h"
 #include "mymoneyenums.h"
 #include "mymoneyexception.h"
 #include "mymoneyfinancialcalculator.h"
 #include "mymoneymoney.h"
 #include "wizardpage.h"
 #include "kguiutils.h"
 
 using namespace eMyMoney;
 
 namespace NewAccountWizard
 {
   LoanDetailsPage::LoanDetailsPage(Wizard* wizard) :
     QWidget(wizard),
     WizardPage<Wizard>(*new LoanDetailsPagePrivate(wizard), StepPayments, this, wizard)
   {
     Q_D(LoanDetailsPage);
     d->m_needCalculate = true;
     d->ui->setupUi(this);
     // force the balloon payment to zero (default)
     d->ui->m_balloonAmount->setValue(MyMoneyMoney());
     // allow any precision for the interest rate
     d->ui->m_interestRate->setPrecision(-1);
 
     connect(d->ui->m_paymentDue, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, &LoanDetailsPage::slotValuesChanged);
 
     connect(d->ui->m_termAmount, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &LoanDetailsPage::slotValuesChanged);
     connect(d->ui->m_termUnit, static_cast<void (QComboBox::*)(int)>(&QComboBox::highlighted), this, &LoanDetailsPage::slotValuesChanged);
     connect(d->ui->m_loanAmount, &KMyMoneyEdit::textChanged, this, &LoanDetailsPage::slotValuesChanged);
     connect(d->ui->m_interestRate, &KMyMoneyEdit::textChanged, this, &LoanDetailsPage::slotValuesChanged);
     connect(d->ui->m_paymentAmount, &KMyMoneyEdit::textChanged, this, &LoanDetailsPage::slotValuesChanged);
     connect(d->ui->m_balloonAmount, &KMyMoneyEdit::textChanged, this, &LoanDetailsPage::slotValuesChanged);
 
     connect(d->ui->m_calculateButton, &QAbstractButton::clicked, this, &LoanDetailsPage::slotCalculate);
   }
 
   LoanDetailsPage::~LoanDetailsPage()
   {
   }
 
   void LoanDetailsPage::enterPage()
   {
     Q_D(LoanDetailsPage);
     // we need to remove a bunch of entries of the payment frequencies
     d->ui->m_termUnit->clear();
 
     d->m_mandatoryGroup->clear();
     if (!d->m_wizard->openingBalance().isZero()) {
         d->m_mandatoryGroup->add(d->ui->m_loanAmount->lineedit());
         if (d->ui->m_loanAmount->lineedit()->text().length() == 0) {
             d->ui->m_loanAmount->setValue(d->m_wizard->openingBalance().abs());
           }
       }
 
     switch (d->m_wizard->d_func()->m_generalLoanInfoPage->d_func()->ui->m_paymentFrequency->currentItem()) {
       default:
         d->ui->m_termUnit->insertItem(i18n("Payments"), (int)Schedule::Occurrence::Once);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Once);
         break;
       case Schedule::Occurrence::Monthly:
         d->ui->m_termUnit->insertItem(i18n("Months"), (int)Schedule::Occurrence::Monthly);
         d->ui->m_termUnit->insertItem(i18n("Years"), (int)Schedule::Occurrence::Yearly);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Monthly);
         break;
       case Schedule::Occurrence::Yearly:
         d->ui->m_termUnit->insertItem(i18n("Years"), (int)Schedule::Occurrence::Yearly);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Yearly);
         break;
       }
   }
 
   void LoanDetailsPage::slotValuesChanged()
   {
     Q_D(LoanDetailsPage);
     d->m_needCalculate = true;
     d->m_wizard->completeStateChanged();
   }
 
   void LoanDetailsPage::slotCalculate()
   {
     Q_D(LoanDetailsPage);
     MyMoneyFinancialCalculator calc;
     double val;
     int PF, CF;
     QString result;
     bool moneyBorrowed = d->m_wizard->moneyBorrowed();
     bool moneyLend = !moneyBorrowed;
 
     // FIXME: for now, we only support interest calculation at the end of the period
     calc.setBep();
     // FIXME: for now, we only support periodic compounding
     calc.setDisc();
 
     PF = d->m_wizard->d_func()->m_generalLoanInfoPage->d_func()->ui->m_paymentFrequency->eventsPerYear();
     CF = d->m_wizard->d_func()->m_generalLoanInfoPage->d_func()->ui->m_compoundFrequency->eventsPerYear();
 
     if (PF == 0 || CF == 0)
       return;
 
     calc.setPF(PF);
     calc.setCF(CF);
 
 
     if (!d->ui->m_loanAmount->lineedit()->text().isEmpty()) {
         val = d->ui->m_loanAmount->value().abs().toDouble();
         if (moneyBorrowed)
           val = -val;
         calc.setPv(val);
       }
 
     if (!d->ui->m_interestRate->lineedit()->text().isEmpty()) {
         val = d->ui->m_interestRate->value().abs().toDouble();
         calc.setIr(val);
       }
 
     if (!d->ui->m_paymentAmount->lineedit()->text().isEmpty()) {
         val = d->ui->m_paymentAmount->value().abs().toDouble();
         if (moneyLend)
           val = -val;
         calc.setPmt(val);
       }
 
     if (!d->ui->m_balloonAmount->lineedit()->text().isEmpty()) {
         val = d->ui->m_balloonAmount->value().abs().toDouble();
         if (moneyLend)
           val = -val;
         calc.setFv(val);
       }
 
     if (d->ui->m_termAmount->value() != 0) {
         calc.setNpp(term());
       }
 
     // setup of parameters is done, now do the calculation
     try {
       if (d->ui->m_loanAmount->lineedit()->text().isEmpty()) {
           // calculate the amount of the loan out of the other information
           val = calc.presentValue();
           d->ui->m_loanAmount->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
           result = i18n("KMyMoney has calculated the amount of the loan as %1.", d->ui->m_loanAmount->lineedit()->text());
 
         } else if (d->ui->m_interestRate->lineedit()->text().isEmpty()) {
           // calculate the interest rate out of the other information
           val = calc.interestRate();
 
           d->ui->m_interestRate->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney(QString(), 3));
           result = i18n("KMyMoney has calculated the interest rate to %1%.", d->ui->m_interestRate->lineedit()->text());
 
         } else if (d->ui->m_paymentAmount->lineedit()->text().isEmpty()) {
           // calculate the periodical amount of the payment out of the other information
           val = calc.payment();
           d->ui->m_paymentAmount->setValue(MyMoneyMoney(static_cast<double>(val)).abs());
           // reset payment as it might have changed due to rounding
           val = d->ui->m_paymentAmount->value().abs().toDouble();
           if (moneyLend)
             val = -val;
           calc.setPmt(val);
 
           result = i18n("KMyMoney has calculated a periodic payment of %1 to cover principal and interest.", d->ui->m_paymentAmount->lineedit()->text());
 
           val = calc.futureValue();
           if ((moneyBorrowed && val < 0 && qAbs(val) >= qAbs(calc.payment()))
               || (moneyLend && val > 0 && qAbs(val) >= qAbs(calc.payment()))) {
               calc.setNpp(calc.npp() - 1);
               // updateTermWidgets(calc.npp());
               val = calc.futureValue();
               MyMoneyMoney refVal(static_cast<double>(val));
               d->ui->m_balloonAmount->loadText(refVal.abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
               result += QString(" ");
               result += i18n("The number of payments has been decremented and the balloon payment has been modified to %1.", d->ui->m_balloonAmount->lineedit()->text());
             } else if ((moneyBorrowed && val < 0 && qAbs(val) < qAbs(calc.payment()))
                        || (moneyLend && val > 0 && qAbs(val) < qAbs(calc.payment()))) {
               d->ui->m_balloonAmount->loadText(MyMoneyMoney().formatMoney(QString(), d->m_wizard->d_func()->precision()));
             } else {
               MyMoneyMoney refVal(static_cast<double>(val));
               d->ui->m_balloonAmount->loadText(refVal.abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
               result += i18n("The balloon payment has been modified to %1.", d->ui->m_balloonAmount->lineedit()->text());
             }
 
         } else if (d->ui->m_termAmount->value() == 0) {
           // calculate the number of payments out of the other information
           val = calc.numPayments();
           if (val == 0)
-            throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+            throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
 
           // if the number of payments has a fractional part, then we
           // round it to the smallest integer and calculate the balloon payment
           result = i18n("KMyMoney has calculated the term of your loan as %1. ", updateTermWidgets(qFloor(val)));
 
           if (val != qFloor(val)) {
               calc.setNpp(qFloor(val));
               val = calc.futureValue();
               MyMoneyMoney refVal(static_cast<double>(val));
               d->ui->m_balloonAmount->loadText(refVal.abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
               result += i18n("The balloon payment has been modified to %1.", d->ui->m_balloonAmount->lineedit()->text());
             }
 
         } else {
           // calculate the future value of the loan out of the other information
           val = calc.futureValue();
 
           // we differentiate between the following cases:
           // a) the future value is greater than a payment
           // b) the future value is less than a payment or the loan is overpaid
           // c) all other cases
           //
           // a) means, we have paid more than we owed. This can't be
           // b) means, we paid more than we owed but the last payment is
           //    less in value than regular payments. That means, that the
           //    future value is to be treated as  (fully payed back)
           // c) the loan is not payed back yet
           if ((moneyBorrowed && val < 0 && qAbs(val) > qAbs(calc.payment()))
               || (moneyLend && val > 0 && qAbs(val) > qAbs(calc.payment()))) {
               // case a)
               qDebug("Future Value is %f", val);
-              throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+              throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
 
             } else if ((moneyBorrowed && val < 0 && qAbs(val) <= qAbs(calc.payment()))
                        || (moneyLend && val > 0 && qAbs(val) <= qAbs(calc.payment()))) {
               // case b)
               val = 0;
             }
 
           MyMoneyMoney refVal(static_cast<double>(val));
           result = i18n("KMyMoney has calculated a balloon payment of %1 for this loan.", refVal.abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
 
           if (!d->ui->m_balloonAmount->lineedit()->text().isEmpty()) {
               if ((d->ui->m_balloonAmount->value().abs() - refVal.abs()).abs().toDouble() > 1) {
-                  throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+                  throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
                 }
               result = i18n("KMyMoney has successfully verified your loan information.");
             }
           d->ui->m_balloonAmount->loadText(refVal.abs().formatMoney(QString(), d->m_wizard->d_func()->precision()));
         }
 
     } catch (const MyMoneyException &) {
       KMessageBox::error(0,
                          i18n("You have entered mis-matching information. Please modify "
                               "your figures or leave one value empty "
                               "to let KMyMoney calculate it for you"),
                          i18n("Calculation error"));
       return;
     }
 
     result += i18n("\n\nAccept this or modify the loan information and recalculate.");
 
     KMessageBox::information(0, result, i18n("Calculation successful"));
     d->m_needCalculate = false;
 
     // now update change
     d->m_wizard->completeStateChanged();
   }
 
   int LoanDetailsPage::term() const
   {
     Q_D(const LoanDetailsPage);
     int factor = 0;
 
     if (d->ui->m_termAmount->value() != 0) {
         factor = 1;
         switch (d->ui->m_termUnit->currentItem()) {
           case Schedule::Occurrence::Yearly: // years
             factor = 12;
             // intentional fall through
 
           case Schedule::Occurrence::Monthly: // months
             factor *= 30;
             factor *= d->ui->m_termAmount->value();
             // factor now is the duration in days. we divide this by the
             // payment frequency and get the number of payments
             factor /= d->m_wizard->d_func()->m_generalLoanInfoPage->d_func()->ui->m_paymentFrequency->daysBetweenEvents();
             break;
 
           default:
             qDebug("Unknown term unit %d in LoanDetailsPage::term(). Using payments.", (int)d->ui->m_termUnit->currentItem());
             // intentional fall through
 
           case Schedule::Occurrence::Once: // payments
             factor = d->ui->m_termAmount->value();
             break;
           }
       }
     return factor;
   }
 
   QString LoanDetailsPage::updateTermWidgets(const double val)
   {
     Q_D(LoanDetailsPage);
     long vl = qFloor(val);
 
     QString valString;
     Schedule::Occurrence unit = d->ui->m_termUnit->currentItem();
 
     if ((unit == Schedule::Occurrence::Monthly)
         && ((vl % 12) == 0)) {
         vl /= 12;
         unit = Schedule::Occurrence::Yearly;
       }
 
     switch (unit) {
       case Schedule::Occurrence::Monthly:
         valString = i18np("one month", "%1 months", vl);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Monthly);
         break;
       case Schedule::Occurrence::Yearly:
         valString = i18np("one year", "%1 years", vl);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Yearly);
         break;
       default:
         valString = i18np("one payment", "%1 payments", vl);
         d->ui->m_termUnit->setCurrentItem((int)Schedule::Occurrence::Once);
         break;
       }
     d->ui->m_termAmount->setValue(vl);
     return valString;
   }
 
   bool LoanDetailsPage::isComplete() const
   {
     Q_D(const LoanDetailsPage);
     // bool rc = KMyMoneyWizardPage::isComplete();
 
     int fieldCnt = 0;
 
     if (d->ui->m_loanAmount->lineedit()->text().length() > 0) {
         fieldCnt++;
       }
 
     if (d->ui->m_interestRate->lineedit()->text().length() > 0) {
         fieldCnt++;
       }
 
     if (d->ui->m_termAmount->value() != 0) {
         fieldCnt++;
       }
 
     if (d->ui->m_paymentAmount->lineedit()->text().length() > 0) {
         fieldCnt++;
       }
 
     if (d->ui->m_balloonAmount->lineedit()->text().length() > 0) {
         fieldCnt++;
       }
 
     d->ui->m_calculateButton->setEnabled(fieldCnt == 4 || (fieldCnt == 5 && d->m_needCalculate));
 
     d->ui->m_calculateButton->setAutoDefault(false);
     d->ui->m_calculateButton->setDefault(false);
     if (d->m_needCalculate && fieldCnt == 4) {
         d->m_wizard->d_func()->m_nextButton->setToolTip(i18n("Press Calculate to verify the values"));
         d->ui->m_calculateButton->setAutoDefault(true);
         d->ui->m_calculateButton->setDefault(true);
       } else if (fieldCnt != 5) {
         d->m_wizard->d_func()->m_nextButton->setToolTip(i18n("Not all details supplied"));
         d->ui->m_calculateButton->setAutoDefault(true);
         d->ui->m_calculateButton->setDefault(true);
       }
     d->m_wizard->d_func()->m_nextButton->setAutoDefault(!d->ui->m_calculateButton->autoDefault());
     d->m_wizard->d_func()->m_nextButton->setDefault(!d->ui->m_calculateButton->autoDefault());
 
     return (fieldCnt == 5) && !d->m_needCalculate;
   }
 
   QWidget* LoanDetailsPage::initialFocusWidget() const
   {
     Q_D(const LoanDetailsPage);
     return d->ui->m_paymentDue;
   }
 
   KMyMoneyWizardPage* LoanDetailsPage::nextPage() const
   {
     Q_D(const LoanDetailsPage);
     return d->m_wizard->d_func()->m_loanPaymentPage;
   }
 }
diff --git a/kmymoney/wizards/newaccountwizard/knewaccountwizard.cpp b/kmymoney/wizards/newaccountwizard/knewaccountwizard.cpp
index 0dda4df04..cf0d2bbf7 100644
--- a/kmymoney/wizards/newaccountwizard/knewaccountwizard.cpp
+++ b/kmymoney/wizards/newaccountwizard/knewaccountwizard.cpp
@@ -1,456 +1,456 @@
 /***************************************************************************
                              knewaccountwizard.cpp
                              -------------------
     begin                : Tue Sep 25 2006
     copyright            : (C) 2007 Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "knewaccountwizard.h"
 #include "knewaccountwizard_p.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QCheckBox>
 #include <QList>
 #include <QPointer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KLineEdit>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kaccountsummarypage.h"
 #include "kaccounttypepage.h"
 #include "kbrokeragepage.h"
 #include "kcreditcardschedulepage.h"
 #include "kgeneralloaninfopage.h"
 #include "khierarchypage.h"
 #include "kinstitutionpage.h"
 #include "kloandetailspage.h"
 #include "kloanpaymentpage.h"
 #include "kloanpayoutpage.h"
 #include "kloanschedulepage.h"
 
 #include "kaccounttypepage_p.h"
 #include "kbrokeragepage_p.h"
 #include "kcreditcardschedulepage_p.h"
 #include "kgeneralloaninfopage_p.h"
 #include "kinstitutionpage_p.h"
 #include "kloandetailspage_p.h"
 #include "kloanpayoutpage_p.h"
 #include "kloanschedulepage_p.h"
 
 #include "kmymoneycurrencyselector.h"
 #include "kcurrencycalculator.h"
 #include "kmymoneyutils.h"
 
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneyprice.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 using namespace NewAccountWizard;
 using namespace Icons;
 using namespace eMyMoney;
 
 namespace NewAccountWizard
 {
   Wizard::Wizard(QWidget *parent, bool modal, Qt::WindowFlags flags)
     : KMyMoneyWizard(*new WizardPrivate(this), parent, modal, flags)
   {
     Q_D(Wizard);
     setTitle(i18n("KMyMoney New Account Setup"));
     addStep(i18n("Institution"));
     addStep(i18n("Account"));
     addStep(i18n("Broker"));
     addStep(i18n("Details"));
     addStep(i18n("Payments"));
     addStep(i18n("Fees"));
     addStep(i18n("Schedule"));
     addStep(i18n("Payout"));
     addStep(i18n("Parent Account"));
     addStep(i18nc("Finish the wizard", "Finish"));
     d->setStepHidden(StepBroker);
     d->setStepHidden(StepSchedule);
     d->setStepHidden(StepPayout);
     d->setStepHidden(StepDetails);
     d->setStepHidden(StepPayments);
     d->setStepHidden(StepFees);
 
     d->m_institutionPage = new InstitutionPage(this);
     d->m_accountTypePage = new AccountTypePage(this);
     // Investment Pages
     d->m_brokeragepage = new BrokeragePage(this);
     // Credit Card Pages
     d->m_schedulePage = new CreditCardSchedulePage(this);
     // Loan Pages
     d->m_generalLoanInfoPage = new GeneralLoanInfoPage(this);
     d->m_loanDetailsPage = new LoanDetailsPage(this);
     d->m_loanPaymentPage = new LoanPaymentPage(this);
     d->m_loanSchedulePage = new LoanSchedulePage(this);
     d->m_loanPayoutPage = new LoanPayoutPage(this);
     // Not a loan page
     d->m_hierarchyPage = new HierarchyPage(this);
     // Finish
     d->m_accountSummaryPage = new AccountSummaryPage(this);
 
     d->setFirstPage(d->m_institutionPage);
     connect(this, &Wizard::createAccount, this, &Wizard::slotAccountNew);
   }
 
   Wizard::~Wizard()
   {
   }
 
   void Wizard::setAccount(const MyMoneyAccount& acc)
   {
     Q_D(Wizard);
     d->m_account = acc;
     d->m_accountTypePage->setAccount(d->m_account);
 
     if (!acc.institutionId().isEmpty()) {
       d->m_institutionPage->selectExistingInstitution(acc.institutionId());
     }
   }
 
   MyMoneyMoney Wizard::interestRate() const
   {
     Q_D(const Wizard);
     return d->m_loanDetailsPage->d_func()->ui->m_interestRate->value() / MyMoneyMoney(100, 1);
   }
 
 
 
   const MyMoneyAccount& Wizard::account()
   {
     Q_D(Wizard);
     d->m_account = MyMoneyAccountLoan();
     d->m_account.setName(d->m_accountTypePage->d_func()->ui->m_accountName->text());
     d->m_account.setOpeningDate(d->m_accountTypePage->d_func()->ui->m_openingDate->date());
     d->m_account.setAccountType(d->m_accountTypePage->accountType());
     d->m_account.setInstitutionId(d->m_institutionPage->institution().id());
     d->m_account.setNumber(d->m_institutionPage->d_func()->ui->m_accountNumber->text());
     d->m_account.setValue("iban", d->m_institutionPage->d_func()->ui->m_iban->text());
     if (d->m_accountTypePage->d_func()->ui->m_preferredAccount->isChecked())
       d->m_account.setValue("PreferredAccount", "Yes");
     else
       d->m_account.deletePair("PreferredAccount");
 
     d->m_account.setCurrencyId(d->currency().id());
     if (d->m_account.isLoan()) {
       // in case we lend the money we adjust the account type
       if (!moneyBorrowed())
         d->m_account.setAccountType(Account::Type::AssetLoan);
       d->m_account.setLoanAmount(d->m_loanDetailsPage->d_func()->ui->m_loanAmount->value());
       d->m_account.setInterestRate(d->m_loanSchedulePage->firstPaymentDueDate(), d->m_loanDetailsPage->d_func()->ui->m_interestRate->value());
       d->m_account.setInterestCalculation(d->m_loanDetailsPage->d_func()->ui->m_paymentDue->currentIndex() == 0 ? MyMoneyAccountLoan::paymentReceived : MyMoneyAccountLoan::paymentDue);
       d->m_account.setFixedInterestRate(d->m_generalLoanInfoPage->d_func()->ui->m_interestType->currentIndex() == 0);
       d->m_account.setFinalPayment(d->m_loanDetailsPage->d_func()->ui->m_balloonAmount->value());
       d->m_account.setTerm(d->m_loanDetailsPage->term());
       d->m_account.setPeriodicPayment(d->m_loanDetailsPage->d_func()->ui->m_paymentAmount->value());
       d->m_account.setPayee(d->m_generalLoanInfoPage->d_func()->ui->m_payee->selectedItem());
       d->m_account.setInterestCompounding((int)d->m_generalLoanInfoPage->d_func()->ui->m_compoundFrequency->currentItem());
 
       if (!d->m_account.fixedInterestRate()) {
         d->m_account.setNextInterestChange(d->m_generalLoanInfoPage->d_func()->ui->m_interestChangeDateEdit->date());
         d->m_account.setInterestChangeFrequency(d->m_generalLoanInfoPage->d_func()->ui->m_interestFrequencyAmountEdit->value(), d->m_generalLoanInfoPage->d_func()->ui->m_interestFrequencyUnitEdit->currentIndex());
       }
     }
     return d->m_account;
   }
 
   MyMoneyTransaction Wizard::payoutTransaction()
   {
     Q_D(Wizard);
     MyMoneyTransaction t;
     if (d->m_account.isLoan()                                      // we're creating a loan
         && openingBalance().isZero()                                // and don't have an opening balance
         && !d->m_loanPayoutPage->d_func()->ui->m_noPayoutTransaction->isChecked()) { // and the user wants to have a payout transaction
       t.setPostDate(d->m_loanPayoutPage->d_func()->ui->m_payoutDate->date());
       t.setCommodity(d->m_account.currencyId());
       MyMoneySplit s;
       s.setAccountId(d->m_account.id());
       s.setShares(d->m_loanDetailsPage->d_func()->ui->m_loanAmount->value());
       if (moneyBorrowed())
         s.setShares(-s.shares());
       s.setValue(s.shares());
       t.addSplit(s);
 
       s.clearId();
       s.setValue(-s.value());
       s.setAccountId(d->m_loanPayoutPage->payoutAccountId());
       MyMoneyMoney shares;
       KCurrencyCalculator::setupSplitPrice(shares, t, s, QMap<QString, MyMoneyMoney>(), this);
       s.setShares(shares);
       t.addSplit(s);
     }
     return t;
   }
 
   MyMoneyAccount Wizard::parentAccount()
   {
     Q_D(Wizard);
     return d->m_accountTypePage->allowsParentAccount()
         ? d->m_hierarchyPage->parentAccount()
         : (d->m_accountTypePage->accountType() == Account::Type::Loan
            ? d->m_generalLoanInfoPage->parentAccount()
            : d->m_accountTypePage->parentAccount());
   }
 
   MyMoneyAccount Wizard::brokerageAccount() const
   {
     Q_D(const Wizard);
     MyMoneyAccount account;
     if (d->m_account.accountType() == Account::Type::Investment
         && d->m_brokeragepage->d_func()->ui->m_createBrokerageButton->isChecked()) {
       account.setName(d->m_account.brokerageName());
       account.setAccountType(Account::Type::Checkings);
       account.setInstitutionId(d->m_account.institutionId());
       account.setOpeningDate(d->m_account.openingDate());
       account.setCurrencyId(d->m_brokeragepage->d_func()->ui->m_brokerageCurrency->security().id());
       if (d->m_brokeragepage->d_func()->ui->m_accountNumber->isEnabled() && !d->m_brokeragepage->d_func()->ui->m_accountNumber->text().isEmpty())
         account.setNumber(d->m_brokeragepage->d_func()->ui->m_accountNumber->text());
       if (d->m_brokeragepage->d_func()->ui->m_iban->isEnabled() && !d->m_brokeragepage->d_func()->ui->m_iban->text().isEmpty())
         account.setValue("iban", d->m_brokeragepage->d_func()->ui->m_iban->text());
     }
     return account;
   }
 
   const MyMoneySchedule& Wizard::schedule()
   {
     Q_D(Wizard);
     d->m_schedule = MyMoneySchedule();
 
     if (!d->m_account.id().isEmpty()) {
       if (d->m_schedulePage->d_func()->ui->m_reminderCheckBox->isChecked() && (d->m_account.accountType() == Account::Type::CreditCard)) {
         d->m_schedule.setName(d->m_schedulePage->d_func()->ui->m_name->text());
         d->m_schedule.setType(Schedule::Type::Transfer);
         d->m_schedule.setPaymentType(static_cast<Schedule::PaymentType>(d->m_schedulePage->d_func()->ui->m_method->currentItem()));
         d->m_schedule.setFixed(false);
         d->m_schedule.setOccurrencePeriod(Schedule::Occurrence::Monthly);
         d->m_schedule.setOccurrenceMultiplier(1);
         MyMoneyTransaction t;
         MyMoneySplit s;
         s.setPayeeId(d->m_schedulePage->d_func()->ui->m_payee->selectedItem());
         s.setAccountId(d->m_schedulePage->d_func()->ui->m_paymentAccount->selectedItem());
         s.setMemo(i18n("Credit card payment"));
         s.setShares(-d->m_schedulePage->d_func()->ui->m_amount->value());
         s.setValue(s.shares());
         t.addSplit(s);
 
         s.clearId();
         s.setAccountId(d->m_account.id());
         s.setShares(d->m_schedulePage->d_func()->ui->m_amount->value());
         s.setValue(s.shares());
         t.addSplit(s);
 
         // setup the next due date
         t.setPostDate(d->m_schedulePage->d_func()->ui->m_date->date());
         d->m_schedule.setTransaction(t);
 
       } else if (d->m_account.isLoan()) {
         d->m_schedule.setName(i18n("Loan payment for %1", d->m_accountTypePage->d_func()->ui->m_accountName->text()));
         d->m_schedule.setType(Schedule::Type::LoanPayment);
         if (moneyBorrowed())
           d->m_schedule.setPaymentType(Schedule::PaymentType::DirectDebit);
         else
           d->m_schedule.setPaymentType(Schedule::PaymentType::DirectDeposit);
 
         d->m_schedule.setFixed(true);
         d->m_schedule.setOccurrence(d->m_generalLoanInfoPage->d_func()->ui->m_paymentFrequency->currentItem());
 
         MyMoneyTransaction t;
         t.setCommodity(d->m_account.currencyId());
         MyMoneySplit s;
         // payment split
         s.setPayeeId(d->m_generalLoanInfoPage->d_func()->ui->m_payee->selectedItem());
         s.setAccountId(d->m_loanSchedulePage->d_func()->ui->m_paymentAccount->selectedItem());
         s.setMemo(i18n("Loan payment"));
         s.setValue(d->m_loanPaymentPage->basePayment() + d->m_loanPaymentPage->additionalFees());
         if (moneyBorrowed()) {
           s.setValue(-s.value());
         }
         s.setShares(s.value());
         if (d->m_account.id() != QLatin1String("Phony-ID")) {
           // if the real account is already set perform the currency conversion if it's necessary
           MyMoneyMoney paymentShares;
           KCurrencyCalculator::setupSplitPrice(paymentShares, t, s, QMap<QString, MyMoneyMoney>(), this);
           s.setShares(paymentShares);
         }
         t.addSplit(s);
 
         // principal split
         s.clearId();
         s.setAccountId(d->m_account.id());
         s.setShares(MyMoneyMoney::autoCalc);
         s.setValue(MyMoneyMoney::autoCalc);
         s.setMemo(i18n("Amortization"));
         s.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization));
         t.addSplit(s);
 
         // interest split
         //only add if interest is above zero
         if (!d->m_loanDetailsPage->d_func()->ui->m_interestRate->value().isZero()) {
           s.clearId();
           s.setAccountId(d->m_loanSchedulePage->d_func()->ui->m_interestCategory->selectedItem());
           s.setShares(MyMoneyMoney::autoCalc);
           s.setValue(MyMoneyMoney::autoCalc);
           s.setMemo(i18n("Interest"));
           s.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Interest));
           t.addSplit(s);
         }
 
         // additional fee splits
         QList<MyMoneySplit> additionalSplits;
         d->m_loanPaymentPage->additionalFeesSplits(additionalSplits);
         QList<MyMoneySplit>::const_iterator it;
         MyMoneyMoney factor(moneyBorrowed() ? 1 : -1, 1);
 
         for (it = additionalSplits.constBegin(); it != additionalSplits.constEnd(); ++it) {
           s = (*it);
           s.clearId();
           s.setShares(s.shares() * factor);
           s.setValue(s.value() * factor);
           t.addSplit(s);
         }
 
         // setup the next due date
         t.setPostDate(d->m_loanSchedulePage->firstPaymentDueDate());
         d->m_schedule.setTransaction(t);
       }
     }
     return d->m_schedule;
   }
 
   MyMoneyMoney Wizard::openingBalance() const
   {
     Q_D(const Wizard);
     // return 0 if account type does not support an opening balance
     if (!d->m_accountTypePage->accountTypeSupportsOpeningBalance(d->m_accountTypePage->accountType()))
       return MyMoneyMoney();
 
     if (d->m_accountTypePage->accountType() == Account::Type::Loan) {
       if (d->m_generalLoanInfoPage->recordAllPayments())
         return MyMoneyMoney();
       if (moneyBorrowed())
         return -(d->m_generalLoanInfoPage->d_func()->ui->m_openingBalance->value());
       return d->m_generalLoanInfoPage->d_func()->ui->m_openingBalance->value();
     }
     return d->m_accountTypePage->d_func()->ui->m_openingBalance->value();
   }
 
   MyMoneyPrice Wizard::conversionRate() const
   {
     Q_D(const Wizard);
     if (MyMoneyFile::instance()->baseCurrency().id() == d->m_accountTypePage->d_func()->ui->m_currencyComboBox->security().id())
       return MyMoneyPrice(MyMoneyFile::instance()->baseCurrency().id(),
                           d->m_accountTypePage->d_func()->ui->m_currencyComboBox->security().id(),
                           d->m_accountTypePage->d_func()->ui->m_openingDate->date(),
                           MyMoneyMoney::ONE,
                           i18n("User"));
     return MyMoneyPrice(MyMoneyFile::instance()->baseCurrency().id(),
                         d->m_accountTypePage->d_func()->ui->m_currencyComboBox->security().id(),
                         d->m_accountTypePage->d_func()->ui->m_openingDate->date(),
                         d->m_accountTypePage->d_func()->ui->m_conversionRate->value(),
                         i18n("User"));
   }
 
   void Wizard::newAccount(MyMoneyAccount& account)
   {
 
     QPointer<NewAccountWizard::Wizard> wizard = new NewAccountWizard::Wizard();
 
     wizard->setAccount(account);
 
     if (wizard->exec() == QDialog::Accepted) {
       auto acc = wizard->account();
       if (!(acc == MyMoneyAccount())) {
         MyMoneyFileTransaction ft;
         auto file = MyMoneyFile::instance();
         try {
           // create the account
           MyMoneyAccount parent = wizard->parentAccount();
           file->addAccount(acc, parent);
 
           // tell the wizard about the account id which it
           // needs to create a possible schedule and transactions
           wizard->setAccount(acc);
 
           // store a possible conversion rate for the currency
           if (acc.currencyId() != file->baseCurrency().id()) {
             file->addPrice(wizard->conversionRate());
           }
 
           // create the opening balance transaction if any
           file->createOpeningBalanceTransaction(acc, wizard->openingBalance());
           // create the payout transaction for loans if any
           MyMoneyTransaction payoutTransaction = wizard->payoutTransaction();
           if (payoutTransaction.splits().count() > 0) {
             file->addTransaction(payoutTransaction);
           }
 
           // create a brokerage account if selected
           MyMoneyAccount brokerageAccount = wizard->brokerageAccount();
           if (!(brokerageAccount == MyMoneyAccount())) {
             file->addAccount(brokerageAccount, parent);
           }
 
           // create a possible schedule
           MyMoneySchedule sch = wizard->schedule();
           if (!(sch == MyMoneySchedule())) {
             MyMoneyFile::instance()->addSchedule(sch);
             if (acc.isLoan()) {
               MyMoneyAccountLoan accLoan = MyMoneyFile::instance()->account(acc.id());
               accLoan.setSchedule(sch.id());
               acc = accLoan;
               MyMoneyFile::instance()->modifyAccount(acc);
             }
           }
           ft.commit();
           account = acc;
         } catch (const MyMoneyException &e) {
-          KMessageBox::error(nullptr, i18n("Unable to create account: %1", e.what()));
+          KMessageBox::error(nullptr, i18n("Unable to create account: %1", QString::fromLatin1(e.what())));
         }
       }
     }
     delete wizard;
 
   }
 
   void Wizard::slotPayeeNew(const QString& txt, QString& id)
   {
     KMyMoneyUtils::newPayee(txt, id);
   }
 
   void Wizard::slotAccountNew(MyMoneyAccount& account)
   {
     Wizard::newAccount(account);
   }
 
   bool Wizard::moneyBorrowed() const
   {
     Q_D(const Wizard);
     return d->m_generalLoanInfoPage->d_func()->ui->m_loanDirection->currentIndex() == 0;
   }
 }
diff --git a/kmymoney/wizards/newinvestmentwizard/knewinvestmentwizard.cpp b/kmymoney/wizards/newinvestmentwizard/knewinvestmentwizard.cpp
index d73ec358e..f4b21370d 100644
--- a/kmymoney/wizards/newinvestmentwizard/knewinvestmentwizard.cpp
+++ b/kmymoney/wizards/newinvestmentwizard/knewinvestmentwizard.cpp
@@ -1,325 +1,325 @@
 /***************************************************************************
                          knewinvestmentwizard  -  description
                             -------------------
    begin                : Sat Dec 4 2004
    copyright            : (C) 2004 by Thomas Baumgart
    email                : kmymoney-devel@kde.org
                           (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "knewinvestmentwizard.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QPointer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KHelpClient>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_knewinvestmentwizard.h"
 
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyfile.h"
 #include "webpricequote.h"
 #include "kmymoneyutils.h"
 #include "mymoneyexception.h"
 
 class KNewInvestmentWizardPrivate
 {
   Q_DISABLE_COPY(KNewInvestmentWizardPrivate)
   Q_DECLARE_PUBLIC(KNewInvestmentWizard)
 
 public:
   explicit KNewInvestmentWizardPrivate(KNewInvestmentWizard *qq) :
     q_ptr(qq),
     ui(new Ui::KNewInvestmentWizard),
     m_createAccount(false)
   {
   }
 
   ~KNewInvestmentWizardPrivate()
   {
     delete ui;
   }
 
   void init1()
   {
     Q_Q(KNewInvestmentWizard);
     ui->m_onlineUpdatePage->slotSourceChanged(false);
 
     // make sure, the back button does not clear fields
     q->setOption(QWizard::IndependentPages, true);
 
     // enable the help button
     q->setOption(q->HaveHelpButton, true);
     q->connect(q, &KNewInvestmentWizard::helpRequested, q, &KNewInvestmentWizard::slotHelp);
 
     m_createAccount = true;
 
     // Update label in case of edit
     if (!m_account.id().isEmpty()) {
       ui->m_investmentTypePage->setIntroLabelText(i18n("This wizard allows you to modify the selected investment."));
     }
     if (!m_security.id().isEmpty()) {
       ui->m_investmentTypePage->setIntroLabelText(i18n("This wizard allows you to modify the selected security."));
     }
 
     KMyMoneyUtils::updateWizardButtons(q);
   }
 
   void init2()
   {
     ui->m_investmentTypePage->init2(m_security);
     ui->m_investmentDetailsPage->init2(m_security);
     ui->m_onlineUpdatePage->init2(m_security);
     ui->m_onlineUpdatePage->slotCheckPage(m_security.value("kmm-online-source"));
   }
 
   KNewInvestmentWizard      *q_ptr;
   Ui::KNewInvestmentWizard  *ui;
 
   MyMoneyAccount    m_account;
   MyMoneySecurity   m_security;
   bool              m_createAccount;
 };
 
 KNewInvestmentWizard::KNewInvestmentWizard(QWidget *parent) :
     QWizard(parent),
     d_ptr(new KNewInvestmentWizardPrivate(this))
 {
   Q_D(KNewInvestmentWizard);
   d->ui->setupUi(this);
   d->init1();
   d->ui->m_onlineUpdatePage->slotCheckPage(QString());
 
   d->ui->m_investmentDetailsPage->setupInvestmentSymbol();
 
   connect(d->ui->m_investmentDetailsPage, &KInvestmentDetailsWizardPage::checkForExistingSymbol, this, &KNewInvestmentWizard::slotCheckForExistingSymbol);
 }
 
 KNewInvestmentWizard::KNewInvestmentWizard(const MyMoneyAccount& acc, QWidget *parent) :
     QWizard(parent),
     d_ptr(new KNewInvestmentWizardPrivate(this))
 {
   Q_D(KNewInvestmentWizard);
   d->ui->setupUi(this);
   d->m_account = acc;
   setWindowTitle(i18n("Investment detail wizard"));
   d->init1();
 
   // load the widgets with the data
   setName(d->m_account.name());
   d->m_security = MyMoneyFile::instance()->security(d->m_account.currencyId());
 
   d->init2();
 
   int priceMode = 0;
   if (!d->m_account.value("priceMode").isEmpty())
     priceMode = d->m_account.value("priceMode").toInt();
   d->ui->m_investmentDetailsPage->setCurrentPriceMode(priceMode);
 
 }
 
 KNewInvestmentWizard::KNewInvestmentWizard(const MyMoneySecurity& security, QWidget *parent) :
     QWizard(parent),
     d_ptr(new KNewInvestmentWizardPrivate(this))
 {
   Q_D(KNewInvestmentWizard);
   d->ui->setupUi(this);
   d->m_security = security;
   setWindowTitle(i18n("Security detail wizard"));
   d->init1();
   d->m_createAccount = false;
 
   // load the widgets with the data
   setName(security.name());
 
   d->init2();
 
   // no chance to change the price mode here
   d->ui->m_investmentDetailsPage->setCurrentPriceMode(0);
   d->ui->m_investmentDetailsPage->setPriceModeEnabled(false);
 }
 
 KNewInvestmentWizard::~KNewInvestmentWizard()
 {
 }
 
 void KNewInvestmentWizard::setName(const QString& name)
 {
   Q_D(KNewInvestmentWizard);
   d->ui->m_investmentDetailsPage->setName(name);
 }
 
 void KNewInvestmentWizard::slotCheckForExistingSymbol(const QString& symbol)
 {
   Q_D(KNewInvestmentWizard);
   Q_UNUSED(symbol);
 
   if (field("investmentName").toString().isEmpty()) {
     QList<MyMoneySecurity> list = MyMoneyFile::instance()->securityList();
     auto type = static_cast<eMyMoney::Security::Type>(field("securityType").toInt());
 
     foreach (const MyMoneySecurity& it_s, list) {
       if (it_s.securityType() == type
           && it_s.tradingSymbol() == field("investmentSymbol").toString()) {
         d->m_security = MyMoneySecurity();
         if (KMessageBox::questionYesNo(this, i18n("The selected symbol is already on file. Do you want to reuse the existing security?"), i18n("Security found")) == KMessageBox::Yes) {
           d->m_security = it_s;
           d->init2();
           d->ui->m_investmentDetailsPage->loadName(d->m_security.name());
         }
         break;
       }
     }
   }
 }
 
 void KNewInvestmentWizard::slotHelp()
 {
   KHelpClient::invokeHelp("details.investments.newinvestmentwizard");
 }
 
 void KNewInvestmentWizard::createObjects(const QString& parentId)
 {
   Q_D(KNewInvestmentWizard);
   auto file = MyMoneyFile::instance();
 
   auto type = static_cast<eMyMoney::Security::Type>(field("securityType").toInt());
   auto roundingMethod = static_cast<AlkValue::RoundingMethod>(field("roundingMethod").toInt());
   MyMoneyFileTransaction ft;
   try {
     // update all relevant attributes only, if we create a stock
     // account and the security is unknown or we modifiy the security
     MyMoneySecurity newSecurity(d->m_security);
     newSecurity.setName(field("investmentName").toString());
     newSecurity.setTradingSymbol(field("investmentSymbol").toString());
     newSecurity.setTradingMarket(field("tradingMarket").toString());
     newSecurity.setSmallestAccountFraction(field("fraction").value<MyMoneyMoney>().formatMoney("", 0, false).toUInt());
     newSecurity.setPricePrecision(MyMoneyMoney(field("pricePrecision").toUInt()).formatMoney("", 0, false).toUInt());
     newSecurity.setTradingCurrency(field("tradingCurrencyEdit").value<MyMoneySecurity>().id());
     newSecurity.setSecurityType(type);
     newSecurity.setRoundingMethod(roundingMethod);
     newSecurity.deletePair("kmm-online-source");
     newSecurity.deletePair("kmm-online-quote-system");
     newSecurity.deletePair("kmm-online-factor");
     newSecurity.deletePair("kmm-security-id");
 
     if (!field("onlineSourceCombo").toString().isEmpty()) {
       if (field("useFinanceQuote").toBool()) {
         FinanceQuoteProcess p;
         newSecurity.setValue("kmm-online-quote-system", "Finance::Quote");
         newSecurity.setValue("kmm-online-source", p.crypticName(field("onlineSourceCombo").toString()));
       } else {
         newSecurity.setValue("kmm-online-source", field("onlineSourceCombo").toString());
       }
     }
     if (d->ui->m_onlineUpdatePage->isOnlineFactorEnabled() && (field("onlineFactor").value<MyMoneyMoney>() != MyMoneyMoney::ONE))
       newSecurity.setValue("kmm-online-factor", field("onlineFactor").value<MyMoneyMoney>().toString());
     if (!field("investmentIdentification").toString().isEmpty())
       newSecurity.setValue("kmm-security-id", field("investmentIdentification").toString());
 
     if (d->m_security.id().isEmpty() || newSecurity != d->m_security) {
       d->m_security = newSecurity;
 
       // add or update it
       if (d->m_security.id().isEmpty()) {
         file->addSecurity(d->m_security);
       } else {
         file->modifySecurity(d->m_security);
       }
     }
 
     if (d->m_createAccount) {
       // now that the security exists, we can add the account to store it
       d->m_account.setName(field("investmentName").toString());
       if (d->m_account.accountType() == eMyMoney::Account::Type::Unknown)
         d->m_account.setAccountType(eMyMoney::Account::Type::Stock);
 
       d->m_account.setCurrencyId(d->m_security.id());
       switch (d->ui->m_investmentDetailsPage->priceMode()) {
         case 0:
           d->m_account.deletePair("priceMode");
           break;
         case 1:
         case 2:
           d->m_account.setValue("priceMode", QString("%1").arg(d->ui->m_investmentDetailsPage->priceMode()));
           break;
       }
       // update account's fraction in case its security fraction has changed
       // otherwise KMM restart is required because this won't happen automatically
       d->m_account.fraction(d->m_security);
       if (d->m_account.id().isEmpty()) {
         MyMoneyAccount parent = file->account(parentId);
         file->addAccount(d->m_account, parent);
       } else
         file->modifyAccount(d->m_account);
     }
     ft.commit();
   } catch (const MyMoneyException &e) {
-    KMessageBox::detailedSorry(0, i18n("Unable to create all objects for the investment"), QString("%1 caugt in %2:%3").arg(e.what()).arg(e.file()).arg(e.line()));
+    KMessageBox::detailedSorry(this, i18n("Unable to create all objects for the investment"), QString::fromLatin1(e.what()));
   }
 }
 
 void KNewInvestmentWizard::newInvestment(const MyMoneyAccount& parent)
 {
   QPointer<KNewInvestmentWizard> dlg = new KNewInvestmentWizard;
   if (dlg->exec() == QDialog::Accepted)
     dlg->createObjects(parent.id());
   delete dlg;
 }
 
 void KNewInvestmentWizard::newInvestment(MyMoneyAccount& account, const MyMoneyAccount& parent)
 {
   QString dontShowAgain = "CreateNewInvestments";
   if (KMessageBox::questionYesNo(nullptr,
                                  i18n("<qt>The security <b>%1</b> currently does not exist as sub-account of <b>%2</b>. "
                                                         "Do you want to create it?</qt>", account.name(), parent.name()), i18n("Create security"),
                                  KStandardGuiItem::yes(), KStandardGuiItem::no(), dontShowAgain) == KMessageBox::Yes) {
     QPointer<KNewInvestmentWizard> dlg = new KNewInvestmentWizard;
     dlg->setName(account.name());
     if (dlg->exec() == QDialog::Accepted) {
       dlg->createObjects(parent.id());
       account = dlg->account();
     }
     delete dlg;
   } else {
     // in case the user said no but turned on the don't show again selection, we will enable
     // the message no matter what. Otherwise, the user is not able to use this feature
     // in the future anymore.
     KMessageBox::enableMessage(dontShowAgain);
   }
 }
 
 void KNewInvestmentWizard::editInvestment(const MyMoneyAccount& parent)
 {
   QPointer<KNewInvestmentWizard> dlg = new KNewInvestmentWizard(parent);
   if (dlg->exec() == QDialog::Accepted)
     dlg->createObjects(parent.id());
   delete dlg;
 }
 
 MyMoneyAccount KNewInvestmentWizard::account() const
 {
   Q_D(const KNewInvestmentWizard);
   return d->m_account;
 }
diff --git a/kmymoney/wizards/newloanwizard/interestcategorywizardpage.cpp b/kmymoney/wizards/newloanwizard/interestcategorywizardpage.cpp
index dce5ccc28..5a861970c 100644
--- a/kmymoney/wizards/newloanwizard/interestcategorywizardpage.cpp
+++ b/kmymoney/wizards/newloanwizard/interestcategorywizardpage.cpp
@@ -1,114 +1,114 @@
 /***************************************************************************
                          interestcategorywizardpage  -  description
                             -------------------
    begin                : Sun Jul 4 2010
    copyright            : (C) 2010 by Fernando Vilas
    email                : kmymoney-devel@kde.org
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "interestcategorywizardpage.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QPointer>
 #include <QIcon>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_interestcategorywizardpage.h"
 
 #include "knewaccountdlg.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "icons/icons.h"
 #include "mymoneyexception.h"
 #include "mymoneyenums.h"
 
 using namespace Icons;
 
 InterestCategoryWizardPage::InterestCategoryWizardPage(QWidget *parent)
   : QWizardPage(parent),
     ui(new Ui::InterestCategoryWizardPage)
 {
   ui->setupUi(this);
   // Register the fields with the QWizard and connect the
   // appropriate signals to update the "Next" button correctly
   registerField("interestAccountEdit", ui->m_interestAccountEdit, "selectedItems");
 
   connect(ui->m_interestAccountEdit, &KMyMoneySelector::stateChanged, this, &QWizardPage::completeChanged);
   ui->m_interestAccountEdit->removeButtons();
 
   // load button icons
   KGuiItem createCategoryButtonItem(i18n("&Create..."),
                                     Icons::get(Icon::DocumentNew),
                                     i18n("Create a new category"),
                                     i18n("Use this to open the new account editor"));
   KGuiItem::assign(ui->m_createCategoryButton, createCategoryButtonItem);
   connect(ui->m_createCategoryButton, &QAbstractButton::clicked, this, &InterestCategoryWizardPage::slotCreateCategory);
 }
 
 InterestCategoryWizardPage::~InterestCategoryWizardPage()
 {
   delete ui;
 }
 
 /**
  * Update the "Next" button
  */
 bool InterestCategoryWizardPage::isComplete() const
 {
   return ui->m_interestAccountEdit->selectedItems().count() > 0;
 }
 
 void InterestCategoryWizardPage::slotCreateCategory()
 {
   MyMoneyAccount acc, base;
   MyMoneyFile* file = MyMoneyFile::instance();
 
   if (field("borrowButton").toBool()) {
     base = file->expense();
     acc.setAccountType(eMyMoney::Account::Type::Expense);
   } else {
     base = file->income();
     acc.setAccountType(eMyMoney::Account::Type::Income);
   }
   acc.setParentAccountId(base.id());
 
   QPointer<KNewAccountDlg> dlg = new KNewAccountDlg(acc, true, true, nullptr, QString());
   if (dlg->exec() == QDialog::Accepted) {
     acc = dlg->account();
 
     MyMoneyFileTransaction ft;
     try {
       QString id;
       id = file->createCategory(base, acc.name());
       if (id.isEmpty())
-        throw MYMONEYEXCEPTION("failure while creating the account hierarchy");
+        throw MYMONEYEXCEPTION_CSTRING("failure while creating the account hierarchy");
 
       ft.commit();
 
       ui->m_interestAccountEdit->setSelected(id);
 
     } catch (const MyMoneyException &e) {
-      KMessageBox::information(this, i18n("Unable to add account: %1", e.what()));
+      KMessageBox::information(this, i18n("Unable to add account: %1", QString::fromLatin1(e.what())));
     }
   }
   delete dlg;
 }
diff --git a/kmymoney/wizards/newloanwizard/keditloanwizard.cpp b/kmymoney/wizards/newloanwizard/keditloanwizard.cpp
index 7a5651dd5..379f0b378 100644
--- a/kmymoney/wizards/newloanwizard/keditloanwizard.cpp
+++ b/kmymoney/wizards/newloanwizard/keditloanwizard.cpp
@@ -1,546 +1,546 @@
 /***************************************************************************
                           keditloanwizard.cpp  -  description
                              -------------------
     begin                : Wed Nov 12 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>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "keditloanwizard.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QButtonGroup>
 #include <QRadioButton>
 #include <QLabel>
 #include <QList>
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_interesteditwizardpage.h"
 #include "ui_paymentfrequencywizardpage.h"
 #include "ui_paymenteditwizardpage.h"
 #include "ui_loanattributeswizardpage.h"
 #include "ui_effectivedatewizardpage.h"
 #include "ui_interesttypewizardpage.h"
 #include "ui_editselectionwizardpage.h"
 #include "ui_finalpaymentwizardpage.h"
 
 #include "knewloanwizard.h"
 #include "knewloanwizard_p.h"
 #include "kmymoneylineedit.h"
 #include "kmymoneyedit.h"
 #include "kmymoneyaccountselector.h"
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneypayee.h"
 #include "mymoneyschedule.h"
 #include "mymoneytransactionfilter.h"
 
 class KEditLoanWizardPrivate : public KNewLoanWizardPrivate
 {
   Q_DISABLE_COPY(KEditLoanWizardPrivate)
 
 public:
   KEditLoanWizardPrivate(KEditLoanWizard *qq) :
     KNewLoanWizardPrivate(qq),
     m_lastSelection(0),
     m_fullyRepayLoan(false)
   {
   }
 
   MyMoneySchedule     m_schedule;
   int                 m_lastSelection;
   bool                m_fullyRepayLoan;
 };
 
 KEditLoanWizard::KEditLoanWizard(const MyMoneyAccount& account, QWidget *parent) :
     KNewLoanWizard(*new KEditLoanWizardPrivate(this), parent)
 {
   Q_D(KEditLoanWizard);
   auto file = MyMoneyFile::instance();
 
   setWindowTitle(i18n("Edit loan wizard"));
 
   d->m_account = account;
   try {
     QString id = d->m_account.value("schedule");
     d->m_schedule = file->schedule(id);
   } catch (const MyMoneyException &) {
   }
   d->m_lastSelection = -1;
 
   loadWidgets(d->m_account);
 
   if (d->m_account.openingDate() > QDate::currentDate()) {
     //FIXME: port
     d->ui->m_effectiveDatePage->ui->m_effectiveDateNoteLabel->setText(QString("\n") + i18n(
           "Note: you will not be able to modify this account today, because the opening date \"%1\" is in the future. "
           "Please revisit this dialog when the time has come.", QLocale().toString(d->m_account.openingDate())));
   } else {
     d->ui->m_effectiveDatePage->ui->m_effectiveDateNoteLabel->hide();
   }
   // turn off all pages that are contained here for derived classes
   d->m_pages.clearBit(Page_Intro);
   d->m_pages.clearBit(Page_NewGeneralInfo);
   d->m_pages.clearBit(Page_LendBorrow);
   d->m_pages.clearBit(Page_Name);
   d->m_pages.clearBit(Page_NewCalculateLoan);
   d->m_pages.clearBit(Page_NewPayments);
   removePage(Page_AssetAccount);
   d->ui->m_assetAccountPage = 0;
 
   // turn on all pages that are contained here for derived classes
   d->m_pages.setBit(Page_EditIntro);
   d->m_pages.setBit(Page_EditSelection);
 
   // make sure, we show the correct start page
   setStartId(Page_EditIntro);
 }
 
 KEditLoanWizard::~KEditLoanWizard()
 {
 }
 
 void KEditLoanWizard::loadWidgets(const MyMoneyAccount& /* account */)
 {
   Q_D(KEditLoanWizard);
   auto file = MyMoneyFile::instance();
   QString paymentAccountId, interestAccountId;
 
   //FIXME: port
   d->ui->m_namePage->ui->m_nameEdit->loadText(d->m_account.name());
   d->ui->m_loanAmountPage->ui->m_loanAmountEdit->loadText(d->m_account.loanAmount().formatMoney(d->m_account.fraction(MyMoneyFile::instance()->security(d->m_account.currencyId()))));
   d->ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(d->m_account.finalPayment().formatMoney(d->m_account.fraction(MyMoneyFile::instance()->security(d->m_account.currencyId()))));
   setField("firstDueDateEdit", d->m_account.openingDate());
 
   //FIXME: port
   if (d->m_account.fixedInterestRate()) {
     d->ui->m_interestTypePage->ui->m_fixedInterestButton->click();
   } else {
     d->ui->m_interestTypePage->ui->m_variableInterestButton->click();
   }
 
   QString institutionName = file->institution(d->m_account.institutionId()).name();
   d->ui->m_loanAttributesPage->setInstitution(institutionName);
 
   MyMoneyMoney ir;
   if (d->m_schedule.startDate() > QDate::currentDate()) {
     ir = d->m_account.interestRate(d->m_schedule.startDate());
   } else {
     ir = d->m_account.interestRate(QDate::currentDate());
   }
   //FIXME: port
   d->ui->m_interestPage->ui->m_interestRateEdit->loadText(ir.formatMoney(QString(), 3));
   d->ui->m_interestPage->ui->m_interestRateEdit->setPrecision(3);
   d->ui->m_interestEditPage->ui->m_newInterestRateEdit->loadText(ir.formatMoney(QString(), 3));
   d->ui->m_interestEditPage->ui->m_newInterestRateEdit->setPrecision(3);
   d->ui->m_interestEditPage->ui->m_interestRateLabel->setText(QString(" ") + ir.formatMoney(QString(), 3) + QString("%"));
 
   d->ui->m_paymentFrequencyPage->ui->m_paymentFrequencyUnitEdit->setCurrentIndex(d->ui->m_paymentFrequencyPage->ui->m_paymentFrequencyUnitEdit->findData(QVariant((int)d->m_schedule.occurrencePeriod()), Qt::UserRole, Qt::MatchExactly));
   d->ui->m_durationPage->updateTermWidgets(d->m_account.term());
 
   // the base payment (amortization and interest) is determined
   // by adding all splits that are not automatically calculated.
   // If the loan is a liability, we reverse the sign at the end
   MyMoneyMoney basePayment;
   MyMoneyMoney addPayment;
 
   d->m_transaction = d->m_schedule.transaction();
 
   foreach (const MyMoneySplit& it_s, d->m_schedule.transaction().splits()) {
     MyMoneyAccount acc = file->account(it_s.accountId());
     // if it's the split that references the source/dest
     // of the money, we check if we borrow or loan money
     if (paymentAccountId.isEmpty()
         && acc.isAssetLiability() && !acc.isLoan()
         && it_s.value() != MyMoneyMoney::autoCalc) {
       if (it_s.value().isNegative()) {
         setField("lendButton", false);
         setField("borrowButton", true);
       } else {
         setField("lendButton", true);
         setField("borrowButton", false);
       }
       // we keep the amount of the full payment and subtract the
       // base payment later to get information about the additional payment
       addPayment = it_s.value();
       paymentAccountId = it_s.accountId();
       MyMoneyPayee payee;
       if (!it_s.payeeId().isEmpty()) {
         try {
           payee = file->payee(it_s.payeeId());
           setField("payeeEdit", payee.id());
         } catch (const MyMoneyException &) {
           qWarning("Payee for schedule has been deleted");
         }
       }
 
       // remove this split with one that will be replaced
       // later and has a phony id
       d->m_transaction.removeSplit(it_s);
       d->m_split.clearId();
       d->m_transaction.addSplit(d->m_split);
     }
 
     if (it_s.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
       interestAccountId = it_s.accountId();
     }
 
     if (it_s.value() != MyMoneyMoney::autoCalc) {
       basePayment += it_s.value();
     } else {
       // remove the splits which should not show up
       // for additional fees
       d->m_transaction.removeSplit(it_s);
     }
 
   }
   if (field("borrowButton").toBool()) {
     basePayment = -basePayment;
     addPayment = -addPayment;
   }
   // now make adjustment to get the amount of the additional fees
   addPayment -= basePayment;
 
   // load account selection widgets now that we know if
   // we borrow or lend money
   d->loadAccountList();
 
   int fraction = d->m_account.fraction(MyMoneyFile::instance()->security(d->m_account.currencyId()));
   //FIXME: port
   d->ui->m_paymentPage->ui->m_paymentEdit->loadText(basePayment.formatMoney(fraction));
   d->ui->m_paymentEditPage->ui->m_newPaymentEdit->loadText(basePayment.formatMoney(fraction));
   d->ui->m_paymentEditPage->ui->m_paymentLabel->setText(QString(" ") + basePayment.formatMoney(fraction));
 
   setField("additionalCost", addPayment.formatMoney(fraction));
   d->ui->m_interestCategoryPage->ui->m_interestAccountEdit->setSelected(interestAccountId);
   d->ui->m_schedulePage->ui->m_paymentAccountEdit->setSelected(paymentAccountId);
   setField("nextDueDateEdit", d->m_schedule.nextPayment());
 
   int changeFrequencyUnit;
   int amt = d->m_account.interestChangeFrequency(&changeFrequencyUnit);
   if (amt != -1) {
     setField("interestFrequencyAmountEdit", amt);
     setField("interestFrequencyUnitEdit", changeFrequencyUnit);
   }
 
   // keep track, if the loan should be fully repayed
   d->m_fullyRepayLoan = d->m_account.finalPayment() < basePayment;
 
   d->updateLoanInfo();
 }
 
 bool KEditLoanWizard::validateCurrentPage()
 {
   Q_D(KEditLoanWizard);
   auto dontLeavePage = false;
   //FIXME: port m_lastSelection
   QAbstractButton* button = d->ui->m_editSelectionPage->ui->m_selectionButtonGroup->button(d->m_lastSelection);
 
   if (currentPage() == d->ui->m_editSelectionPage) {
 
     if (button != 0
         && d->m_lastSelection != d->ui->m_editSelectionPage->ui->m_selectionButtonGroup->checkedId()) {
 
       QString errMsg = i18n(
                          "Your previous selection was \"%1\". If you select another option, "
                          "KMyMoney will dismiss the changes you have just entered. "
                          "Do you wish to proceed?", button->text());
 
       if (KMessageBox::questionYesNo(this, errMsg) == KMessageBox::No) {
         dontLeavePage = true;
       } else {
         loadWidgets(d->m_account);
       }
     }
 
     if (!dontLeavePage) {
       // turn off all pages except the summary at the end
       // and the one's we need for the selected option
       // and load the widgets with the current values
 
       // general info
       d->m_pages.clearBit(Page_Name);
       d->m_pages.clearBit(Page_InterestType);
       d->m_pages.clearBit(Page_PreviousPayments);
       d->m_pages.clearBit(Page_RecordPayment);
       d->m_pages.clearBit(Page_VariableInterestDate);
       d->m_pages.clearBit(Page_FirstPayment);
 
       // loan calculation
       d->m_pages.clearBit(Page_PaymentEdit);
       d->m_pages.clearBit(Page_InterestEdit);
       d->m_pages.clearBit(Page_PaymentFrequency);
       d->m_pages.clearBit(Page_InterestCalculation);
       d->m_pages.clearBit(Page_LoanAmount);
       d->m_pages.clearBit(Page_Interest);
       d->m_pages.clearBit(Page_Duration);
       d->m_pages.clearBit(Page_Payment);
       d->m_pages.clearBit(Page_FinalPayment);
       d->m_pages.clearBit(Page_CalculationOverview);
 
       // payment
       d->m_pages.clearBit(Page_InterestCategory);
       d->m_pages.clearBit(Page_AdditionalFees);
       d->m_pages.clearBit(Page_Schedule);
       d->m_pages.setBit(Page_Summary);
 
       // Attributes
       d->m_pages.clearBit(Page_LoanAttributes);
 
       d->m_pages.setBit(Page_EffectiveDate);
 
       if (page(Page_Summary) != 0) {
         removePage(Page_Summary);
       }
 
       if (field("editInterestRateButton").toBool()) {
         d->m_pages.setBit(Page_PaymentFrequency);
         d->m_pages.setBit(Page_InterestType);
         d->m_pages.setBit(Page_VariableInterestDate);
         d->m_pages.setBit(Page_PaymentEdit);
         d->m_pages.setBit(Page_InterestEdit);
         d->m_pages.setBit(Page_InterestCategory);
         d->m_pages.setBit(Page_Schedule);
         d->m_pages.setBit(Page_SummaryEdit);
 
       } else if (field("editOtherCostButton").toBool()) {
         d->m_pages.setBit(Page_PaymentFrequency);
         d->m_pages.setBit(Page_AdditionalFees);
         d->m_pages.setBit(Page_InterestCategory);
         d->m_pages.setBit(Page_Schedule);
         d->m_pages.setBit(Page_SummaryEdit);
 
       } else if (field("editOtherInfoButton").toBool()) {
         d->m_pages.setBit(Page_Name);
         d->m_pages.setBit(Page_InterestCalculation);
         d->m_pages.setBit(Page_Interest);
         d->m_pages.setBit(Page_Duration);
         d->m_pages.setBit(Page_Payment);
         d->m_pages.setBit(Page_FinalPayment);
         d->m_pages.setBit(Page_CalculationOverview);
         d->m_pages.setBit(Page_InterestCategory);
         d->m_pages.setBit(Page_AdditionalFees);
         d->m_pages.setBit(Page_Schedule);
         d->m_pages.clearBit(Page_SummaryEdit);
         setPage(Page_Summary, d->ui->m_summaryPage);
         d->m_pages.setBit(Page_Summary);
 
       } else if (field("editAttributesButton").toBool()) {
         d->m_pages.setBit(Page_LoanAttributes);
         d->m_pages.clearBit(Page_EffectiveDate);
       } else {
         qWarning("%s,%d: This should never happen", __FILE__, __LINE__);
       }
 
       d->m_lastSelection = d->ui->m_editSelectionPage->ui->m_selectionButtonGroup->checkedId();
     } // if(!dontLeavePage)
 
   } else if (currentPage() == d->ui->m_additionalFeesPage) {
     if (field("editOtherCostButton").toBool()) {
       d->updateLoanInfo();
       updateEditSummary();
     }
 
   } else if (currentPage() == d->ui->m_interestEditPage) {
     // copy the necessary data to the widgets used for calculation
     //FIXME: port to fields
     d->ui->m_interestPage->ui->m_interestRateEdit->setValue(field("newInterestRateEdit").value<MyMoneyMoney>());
     d->ui->m_paymentPage->ui->m_paymentEdit->setValue(field("newPaymentEdit").value<MyMoneyMoney>());
 
     // if interest rate and payment amount is given, then force
     // the term to be recalculated. The final payment is adjusted to
     // 0 if the loan was ment to be fully repayed
     d->ui->m_durationPage->updateTermWidgets(d->m_account.term());
     if (field("interestRateEditValid").toBool()
         && field("paymentEditValid").toBool()) {
       // if there's an amortization going on, we can evaluate
       // the new term. If the amortization is 0 (interest only
       // payments) then we keep the term as entered by the user.
       if (field("loanAmountEdit").value<MyMoneyMoney>() != field("finalPaymentEdit").value<MyMoneyMoney>()) {
         setField("durationValueEdit", 0);
       }
       if (d->m_fullyRepayLoan)
         d->ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(MyMoneyMoney().formatMoney(d->m_account.fraction(MyMoneyFile::instance()->security(d->m_account.currencyId()))));
     }
 
     /*
         // we need to calculate the balance at the time of the change
         // in order to accurately recalculate the term. A special
         // situation arises, when we keep track of all payments and
         // the full loan is not yet paid out. In this case, we take the
         // the loan amount minus all amortization payments as the current
         // balance.
         // FIXME: This needs some more thoughts. We leave it out for
         //        now and always calculate with the full loan amount.
         MyMoneyMoney balance = m_account.openingBalance();
 
         QList<MyMoneyTransaction> list;
         QList<MyMoneyTransaction>::ConstIterator it;
         MyMoneySplit split;
         MyMoneyTransactionFilter filter(m_account.id());
 
         filter.setDateFilter(QDate(), m_effectiveChangeDateEdit->date().addDays(-1));
         list = MyMoneyFile::instance()->transactionList(filter);
 
         for(it = list.begin(); it != list.end(); ++it) {
           try {
             split = (*it).splitByAccount(m_account.id());
             balance += split.value();
 
-          } catch(const MyMoneyException &e) {
+          } catch (const MyMoneyException &e) {
             // account is not referenced within this transaction
           }
         }
         m_loanAmountEdit->setText(balance.formatMoney());
     */
     // now re-calculate the figures
     dontLeavePage = !d->calculateLoan();
 
     // reset the original loan amount to the widget
     //FIXME: port to fields
     d->ui->m_loanAmountPage->ui->m_loanAmountEdit->setValue(d->m_account.loanAmount());
 
     if (!dontLeavePage) {
       d->updateLoanInfo();
       updateEditSummary();
     }
   }
 
   if (!dontLeavePage)
     dontLeavePage = ! KNewLoanWizard::validateCurrentPage();
 
   // These might have been set by KNewLoanWizard
   d->m_pages.clearBit(Page_PreviousPayments);
   d->m_pages.clearBit(Page_RecordPayment);
 
   if (dontLeavePage)
     return false;
 
   // we never need to show this page
   if (currentPage() == d->ui->m_previousPaymentsPage)
     dontLeavePage = KNewLoanWizard::validateCurrentPage();
 
   return ! dontLeavePage;
 }
 
 void KEditLoanWizard::updateEditSummary()
 {
   Q_D(KEditLoanWizard);
   // calculate the number of affected transactions
   MyMoneyTransactionFilter filter(d->m_account.id());
   filter.setDateFilter(field("effectiveChangeDateEdit").toDate(), QDate());
 
   int count = 0;
   QList<MyMoneyTransaction> list;
   list = MyMoneyFile::instance()->transactionList(filter);
 
   foreach (const MyMoneyTransaction& it, list) {
     int match = 0;
     foreach (const MyMoneySplit& it_s, it.splits()) {
       // we only count those transactions that have an interest
       // and amortization part
       if (it_s.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest))
         match |= 0x01;
       if (it_s.action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization))
         match |= 0x02;
     }
     if (match == 0x03)
       ++count;
   }
 
   setField("affectedPayments", QString().sprintf("%d", count));
 }
 
 const MyMoneySchedule KEditLoanWizard::schedule() const
 {
   Q_D(const KEditLoanWizard);
   MyMoneySchedule sched = d->m_schedule;
   sched.setTransaction(transaction());
   sched.setOccurrence(eMyMoney::Schedule::Occurrence(field("paymentFrequencyUnitEdit").toInt()));
   if (field("nextDueDateEdit").toDate() < d->m_schedule.startDate())
     sched.setStartDate(field("nextDueDateEdit").toDate());
 
   return sched;
 }
 
 const MyMoneyAccount KEditLoanWizard::account() const
 {
   Q_D(const KEditLoanWizard);
   MyMoneyAccountLoan acc(d->m_account);
 
   if (field("interestOnReceptionButton").toBool())
     acc.setInterestCalculation(MyMoneyAccountLoan::paymentReceived);
   else
     acc.setInterestCalculation(MyMoneyAccountLoan::paymentDue);
 
   auto file = MyMoneyFile::instance();
 
   QString institution = d->ui->m_loanAttributesPage->ui->m_qcomboboxInstitutions->currentText();
   if (institution != i18n("(No Institution)")) {
     const auto list = file->institutionList();
     for (const auto& testInstitution : list) {
       if (testInstitution.name() == institution) {
         acc.setInstitutionId(testInstitution.id());
         break;
       }
     }
   } else {
     acc.setInstitutionId(QString());
   }
 
   acc.setFixedInterestRate(field("fixedInterestButton").toBool());
   acc.setFinalPayment(field("finalPaymentEdit").value<MyMoneyMoney>());
   acc.setTerm(d->ui->m_durationPage->term());
   acc.setPeriodicPayment(field("paymentEdit").value<MyMoneyMoney>());
   acc.setInterestRate(field("effectiveChangeDateEdit").toDate(), field("interestRateEdit").value<MyMoneyMoney>());
 
   acc.setPayee(field("payeeEdit").toString());
 
   if (field("variableInterestButton").toBool()) {
     acc.setNextInterestChange(field("interestChangeDateEdit").toDate());
     acc.setInterestChangeFrequency(field("interestFrequencyAmountEdit").toInt(),
                                    field("interestFrequencyUnitEdit").toInt());
   }
 
   return acc;
 }
 
 const MyMoneyTransaction KEditLoanWizard::transaction() const
 {
   Q_D(const KEditLoanWizard);
   auto t = d->transaction();
   auto s = t.splitByAccount(QString("Phony-ID"));
 
   s.setAccountId(d->m_account.id());
   t.modifySplit(s);
 
   return t;
 }
diff --git a/kmymoney/wizards/newloanwizard/knewloanwizard_p.h b/kmymoney/wizards/newloanwizard/knewloanwizard_p.h
index e333a3670..0df519d72 100644
--- a/kmymoney/wizards/newloanwizard/knewloanwizard_p.h
+++ b/kmymoney/wizards/newloanwizard/knewloanwizard_p.h
@@ -1,542 +1,542 @@
 /***************************************************************************
                           knewloanwizard_p.cpp  -  description
                              -------------------
     copyright            : (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef KNEWLOANWIZARD_P_H
 #define KNEWLOANWIZARD_P_H
 
 #include "knewloanwizard.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QBitArray>
 #include <qmath.h>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_knewloanwizard.h"
 #include "ui_namewizardpage.h"
 #include "ui_firstpaymentwizardpage.h"
 #include "ui_loanamountwizardpage.h"
 #include "ui_interestwizardpage.h"
 #include "ui_paymenteditwizardpage.h"
 #include "ui_finalpaymentwizardpage.h"
 #include "ui_interestcategorywizardpage.h"
 #include "ui_assetaccountwizardpage.h"
 #include "ui_schedulewizardpage.h"
 #include "ui_paymentwizardpage.h"
 
 #include "kmymoneyutils.h"
 #include "kmymoneysettings.h"
 
 #include "mymoneyfinancialcalculator.h"
 #include "mymoneyfile.h"
 #include "mymoneyexception.h"
 #include "mymoneysecurity.h"
 #include "mymoneyaccountloan.h"
 #include "mymoneyschedule.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyenums.h"
 
 namespace Ui { class KNewLoanWizard; }
 
 class KNewLoanWizard;
 class KNewLoanWizardPrivate
 {
   Q_DISABLE_COPY(KNewLoanWizardPrivate)
   Q_DECLARE_PUBLIC(KNewLoanWizard)
 
 public:
   explicit KNewLoanWizardPrivate(KNewLoanWizard *qq) :
     q_ptr(qq),
     ui(new Ui::KNewLoanWizard)
   {
   }
 
   ~KNewLoanWizardPrivate()
   {
     delete ui;
   }
 
   void init()
   {
     Q_Q(KNewLoanWizard);
     ui->setupUi(q);
     m_pages = QBitArray(KNewLoanWizard::Page_Summary + 1, true);
     q->setModal(true);
 
     KMyMoneyMVCCombo::setSubstringSearchForChildren(ui->m_namePage, !KMyMoneySettings::stringMatchFromStart());
 
     // make sure, the back button does not clear fields
     q->setOption(QWizard::IndependentPages, true);
 
     // connect(m_payeeEdit, SIGNAL(newPayee(QString)), this, SLOT(slotNewPayee(QString)));
     q->connect(ui->m_namePage->ui->m_payeeEdit, &KMyMoneyMVCCombo::createItem, q, &KNewLoanWizard::slotNewPayee);
 
     q->connect(ui->m_additionalFeesPage, &AdditionalFeesWizardPage::newCategory, q, &KNewLoanWizard::slotNewCategory);
 
     q->connect(MyMoneyFile::instance(), &MyMoneyFile::dataChanged, q, &KNewLoanWizard::slotReloadEditWidgets);
 
     resetCalculator();
 
     q->slotReloadEditWidgets();
 
     // As default we assume a liability loan, with fixed interest rate,
     // with a first payment due on the 30th of this month. All payments
     // should be recorded and none have been made so far.
 
     //FIXME: port
     ui->m_firstPaymentPage->ui->m_firstDueDateEdit->loadDate(QDate(QDate::currentDate().year(), QDate::currentDate().month(), 30));
 
     // FIXME: we currently only support interest calculation on reception
     m_pages.clearBit(KNewLoanWizard::Page_InterestCalculation);
 
     // turn off all pages that are contained here for derived classes
     m_pages.clearBit(KNewLoanWizard::Page_EditIntro);
     m_pages.clearBit(KNewLoanWizard::Page_EditSelection);
     m_pages.clearBit(KNewLoanWizard::Page_EffectiveDate);
     m_pages.clearBit(KNewLoanWizard::Page_PaymentEdit);
     m_pages.clearBit(KNewLoanWizard::Page_InterestEdit);
     m_pages.clearBit(KNewLoanWizard::Page_SummaryEdit);
 
     // for now, we don't have online help :-(
     q->setOption(QWizard::HaveHelpButton, false);
 
     // setup a phony transaction for additional fee processing
     m_account = MyMoneyAccount("Phony-ID", MyMoneyAccount());
     m_split.setAccountId(m_account.id());
     m_split.setValue(MyMoneyMoney());
     m_transaction.addSplit(m_split);
 
     KMyMoneyUtils::updateWizardButtons(q);
   }
 
   void resetCalculator()
   {
     Q_Q(KNewLoanWizard);
     ui->m_loanAmountPage->resetCalculator();
     ui->m_interestPage->resetCalculator();
     ui->m_durationPage->resetCalculator();
     ui->m_paymentPage->resetCalculator();
     ui->m_finalPaymentPage->resetCalculator();
 
     q->setField("additionalCost", MyMoneyMoney().formatMoney(m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId()))));
   }
 
   void updateLoanAmount()
   {
     Q_Q(KNewLoanWizard);
     QString txt;
     //FIXME: port
     if (! q->field("loanAmountEditValid").toBool()) {
       txt = QString("<") + i18n("calculate") + QString(">");
     } else {
       txt = q->field("loanAmountEdit").value<MyMoneyMoney>().formatMoney(m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId())));
     }
     q->setField("loanAmount1", txt);
     q->setField("loanAmount2", txt);
     q->setField("loanAmount3", txt);
     q->setField("loanAmount4", txt);
     q->setField("loanAmount5", txt);
   }
 
   void updateInterestRate()
   {
     Q_Q(KNewLoanWizard);
     QString txt;
     //FIXME: port
     if (! q->field("interestRateEditValid").toBool()) {
       txt = QString("<") + i18n("calculate") + QString(">");
     } else {
       txt = q->field("interestRateEdit").value<MyMoneyMoney>().formatMoney(QString(), 3) + QString("%");
     }
     q->setField("interestRate1", txt);
     q->setField("interestRate2", txt);
     q->setField("interestRate3", txt);
     q->setField("interestRate4", txt);
     q->setField("interestRate5", txt);
   }
 
   void updateDuration()
   {
     Q_Q(KNewLoanWizard);
     QString txt;
     //FIXME: port
     if (q->field("durationValueEdit").toInt() == 0) {
       txt = QString("<") + i18n("calculate") + QString(">");
     } else {
       txt = QString().sprintf("%d ", q->field("durationValueEdit").toInt())
             + q->field("durationUnitEdit").toString();
     }
     q->setField("duration1", txt);
     q->setField("duration2", txt);
     q->setField("duration3", txt);
     q->setField("duration4", txt);
     q->setField("duration5", txt);
   }
 
   void updatePayment()
   {
     Q_Q(KNewLoanWizard);
     QString txt;
     //FIXME: port
     if (! q->field("paymentEditValid").toBool()) {
       txt = QString("<") + i18n("calculate") + QString(">");
     } else {
       txt = q->field("paymentEdit").value<MyMoneyMoney>().formatMoney(m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId())));
     }
     q->setField("payment1", txt);
     q->setField("payment2", txt);
     q->setField("payment3", txt);
     q->setField("payment4", txt);
     q->setField("payment5", txt);
     q->setField("basePayment", txt);
   }
 
   void updateFinalPayment()
   {
     Q_Q(KNewLoanWizard);
     QString txt;
     //FIXME: port
     if (! q->field("finalPaymentEditValid").toBool()) {
       txt = QString("<") + i18n("calculate") + QString(">");
     } else {
       txt = q->field("finalPaymentEdit").value<MyMoneyMoney>().formatMoney(m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId())));
     }
     q->setField("balloon1", txt);
     q->setField("balloon2", txt);
     q->setField("balloon3", txt);
     q->setField("balloon4", txt);
     q->setField("balloon5", txt);
   }
 
   void updateLoanInfo()
   {
     Q_Q(KNewLoanWizard);
     updateLoanAmount();
     updateInterestRate();
     updateDuration();
     updatePayment();
     updateFinalPayment();
     ui->m_additionalFeesPage->updatePeriodicPayment(m_account);
 
     QString txt;
 
     int fraction = m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId()));
     q->setField("loanAmount6", q->field("loanAmountEdit").value<MyMoneyMoney>().formatMoney(fraction));
     q->setField("interestRate6", QString(q->field("interestRateEdit").value<MyMoneyMoney>().formatMoney("", 3) + QString("%")));
     txt = QString().sprintf("%d ", q->field("durationValueEdit").toInt())
           + q->field("durationUnitEdit").toString();
     q->setField("duration6", txt);
     q->setField("payment6", q->field("paymentEdit").value<MyMoneyMoney>().formatMoney(fraction));
     q->setField("balloon6", q->field("finalPaymentEdit").value<MyMoneyMoney>().formatMoney(fraction));
   }
 
   int calculateLoan()
   {
     Q_Q(KNewLoanWizard);
     MyMoneyFinancialCalculator calc;
     double val;
     int PF;
     QString result;
 
     // FIXME: for now, we only support interest calculation at the end of the period
     calc.setBep();
     // FIXME: for now, we only support periodic compounding
     calc.setDisc();
 
     PF = MyMoneySchedule::eventsPerYear(eMyMoney::Schedule::Occurrence(q->field("paymentFrequencyUnitEdit").toInt()));
     if (PF == 0)
       return 0;
     calc.setPF(PF);
 
     // FIXME: for now we only support compounding frequency == payment frequency
     calc.setCF(PF);
 
     if (q->field("loanAmountEditValid").toBool()) {
       val = q->field("loanAmountEdit").value<MyMoneyMoney>().abs().toDouble();
       if (q->field("borrowButton").toBool())
         val = -val;
       calc.setPv(val);
     }
 
     if (q->field("interestRateEditValid").toBool()) {
       val = q->field("interestRateEdit").value<MyMoneyMoney>().abs().toDouble();
       calc.setIr(val);
     }
 
     if (q->field("paymentEditValid").toBool()) {
       val = q->field("paymentEdit").value<MyMoneyMoney>().abs().toDouble();
       if (q->field("lendButton").toBool())
         val = -val;
       calc.setPmt(val);
     }
 
     if (q->field("finalPaymentEditValid").toBool()) {
       val = q->field("finalPaymentEditValid").value<MyMoneyMoney>().abs().toDouble();
       if (q->field("lendButton").toBool())
         val = -val;
       calc.setFv(val);
     }
 
     if (q->field("durationValueEdit").toInt() != 0) {
       calc.setNpp(ui->m_durationPage->term());
     }
 
     int fraction = m_account.fraction(MyMoneyFile::instance()->security(m_account.currencyId()));
     // setup of parameters is done, now do the calculation
     try {
       //FIXME: port
       if (!q->field("loanAmountEditValid").toBool()) {
         // calculate the amount of the loan out of the other information
         val = calc.presentValue();
         ui->m_loanAmountPage->ui->m_loanAmountEdit->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney(fraction));
         result = i18n("KMyMoney has calculated the amount of the loan as %1.", ui->m_loanAmountPage->ui->m_loanAmountEdit->lineedit()->text());
 
       } else if (!q->field("interestRateEditValid").toBool()) {
         // calculate the interest rate out of the other information
         val = calc.interestRate();
 
         ui->m_interestPage->ui->m_interestRateEdit->loadText(MyMoneyMoney(static_cast<double>(val)).abs().formatMoney("", 3));
         result = i18n("KMyMoney has calculated the interest rate to %1%.", ui->m_interestPage->ui->m_interestRateEdit->lineedit()->text());
 
       } else if (!q->field("paymentEditValid").toBool()) {
         // calculate the periodical amount of the payment out of the other information
         val = calc.payment();
         q->setField("paymentEdit", QVariant::fromValue<MyMoneyMoney>(MyMoneyMoney(val).abs()));
         // reset payment as it might have changed due to rounding
         val = q->field("paymentEdit").value<MyMoneyMoney>().abs().toDouble();
         if (q->field("lendButton").toBool())
           val = -val;
         calc.setPmt(val);
 
         result = i18n("KMyMoney has calculated a periodic payment of %1 to cover principal and interest.", ui->m_paymentPage->ui->m_paymentEdit->lineedit()->text());
 
         val = calc.futureValue();
         if ((q->field("borrowButton").toBool() && val < 0 && qAbs(val) >= qAbs(calc.payment()))
             || (q->field("lendButton").toBool() && val > 0 && qAbs(val) >= qAbs(calc.payment()))) {
           calc.setNpp(calc.npp() - 1);
           ui->m_durationPage->updateTermWidgets(calc.npp());
           val = calc.futureValue();
           MyMoneyMoney refVal(static_cast<double>(val));
           ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(refVal.abs().formatMoney(fraction));
           result += QString(" ");
           result += i18n("The number of payments has been decremented and the final payment has been modified to %1.", ui->m_finalPaymentPage->ui->m_finalPaymentEdit->lineedit()->text());
         } else if ((q->field("borrowButton").toBool() && val < 0 && qAbs(val) < qAbs(calc.payment()))
                    || (q->field("lendButton").toBool() && val > 0 && qAbs(val) < qAbs(calc.payment()))) {
           ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(MyMoneyMoney().formatMoney(fraction));
         } else {
           MyMoneyMoney refVal(static_cast<double>(val));
           ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(refVal.abs().formatMoney(fraction));
           result += i18n("The final payment has been modified to %1.", ui->m_finalPaymentPage->ui->m_finalPaymentEdit->lineedit()->text());
         }
 
       } else if (q->field("durationValueEdit").toInt() == 0) {
         // calculate the number of payments out of the other information
         val = calc.numPayments();
         if (val == 0)
-          throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+          throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
 
         // if the number of payments has a fractional part, then we
         // round it to the smallest integer and calculate the balloon payment
         result = i18n("KMyMoney has calculated the term of your loan as %1. ", ui->m_durationPage->updateTermWidgets(qFloor(val)));
 
         if (val != qFloor(val)) {
           calc.setNpp(qFloor(val));
           val = calc.futureValue();
           MyMoneyMoney refVal(static_cast<double>(val));
           ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(refVal.abs().formatMoney(fraction));
           result += i18n("The final payment has been modified to %1.", ui->m_finalPaymentPage->ui->m_finalPaymentEdit->lineedit()->text());
         }
 
       } else {
         // calculate the future value of the loan out of the other information
         val = calc.futureValue();
 
         // we differentiate between the following cases:
         // a) the future value is greater than a payment
         // b) the future value is less than a payment or the loan is overpaid
         // c) all other cases
         //
         // a) means, we have paid more than we owed. This can't be
         // b) means, we paid more than we owed but the last payment is
         //    less in value than regular payments. That means, that the
         //    future value is to be treated as  (fully payed back)
         // c) the loan is not payed back yet
 
         if ((q->field("borrowButton").toBool() && val < 0 && qAbs(val) > qAbs(calc.payment()))
             || (q->field("lendButton").toBool() && val > 0 && qAbs(val) > qAbs(calc.payment()))) {
           // case a)
           qDebug("Future Value is %f", val);
-          throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+          throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
 
         } else if ((q->field("borrowButton").toBool() && val < 0 && qAbs(val) <= qAbs(calc.payment()))
                    || (q->field("lendButton").toBool() && val > 0 && qAbs(val) <= qAbs(calc.payment()))) {
           // case b)
           val = 0;
         }
 
         MyMoneyMoney refVal(static_cast<double>(val));
         result = i18n("KMyMoney has calculated a final payment of %1 for this loan.", refVal.abs().formatMoney(fraction));
 
         if (q->field("finalPaymentEditValid").toBool()) {
           if ((q->field("finalPaymentEdit").value<MyMoneyMoney>().abs() - refVal.abs()).abs().toDouble() > 1) {
-            throw MYMONEYEXCEPTION("incorrect fincancial calculation");
+            throw MYMONEYEXCEPTION_CSTRING("incorrect fincancial calculation");
           }
           result = i18n("KMyMoney has successfully verified your loan information.");
         }
         //FIXME: port
         ui->m_finalPaymentPage->ui->m_finalPaymentEdit->loadText(refVal.abs().formatMoney(fraction));
       }
 
     } catch (const MyMoneyException &) {
       KMessageBox::error(0,
                          i18n("You have entered mis-matching information. Please backup to the "
                               "appropriate page and update your figures or leave one value empty "
                               "to let KMyMoney calculate it for you"),
                          i18n("Calculation error"));
       return 0;
     }
 
     result += i18n("\n\nAccept this or modify the loan information and recalculate.");
 
     KMessageBox::information(0, result, i18n("Calculation successful"));
     return 1;
   }
 
   /**
     * This method returns the transaction that is stored within
     * the schedule. See schedule().
     *
     * @return MyMoneyTransaction object to be used within the schedule
     */
   MyMoneyTransaction transaction() const
   {
     Q_Q(const KNewLoanWizard);
     MyMoneyTransaction t;
     bool hasInterest = !q->field("interestRateEdit").value<MyMoneyMoney>().isZero();
 
     MyMoneySplit sPayment, sInterest, sAmortization;
     // setup accounts. at this point, we cannot fill in the id of the
     // account that the amortization will be performed on, because we
     // create the account. So the id is yet unknown.
     sPayment.setAccountId(q->field("paymentAccountEdit").toStringList().first());
 
 
     //Only create the interest split if not zero
     if (hasInterest) {
       sInterest.setAccountId(q->field("interestAccountEdit").toStringList().first());
       sInterest.setValue(MyMoneyMoney::autoCalc);
       sInterest.setShares(sInterest.value());
       sInterest.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Interest));
     }
 
     // values
     if (q->field("borrowButton").toBool()) {
       sPayment.setValue(-q->field("paymentEdit").value<MyMoneyMoney>());
     } else {
       sPayment.setValue(q->field("paymentEdit").value<MyMoneyMoney>());
     }
 
     sAmortization.setValue(MyMoneyMoney::autoCalc);
     // don't forget the shares
     sPayment.setShares(sPayment.value());
 
     sAmortization.setShares(sAmortization.value());
 
     // setup the commodity
     MyMoneyAccount acc = MyMoneyFile::instance()->account(sPayment.accountId());
     t.setCommodity(acc.currencyId());
 
     // actions
     sPayment.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization));
     sAmortization.setAction(MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization));
 
     // payee
     QString payeeId = q->field("payeeEdit").toString();
     sPayment.setPayeeId(payeeId);
     sAmortization.setPayeeId(payeeId);
 
     MyMoneyAccount account("Phony-ID", MyMoneyAccount());
     sAmortization.setAccountId(account.id());
 
     // IMPORTANT: Payment split must be the first one, because
     //            the schedule view expects it this way during display
     t.addSplit(sPayment);
     t.addSplit(sAmortization);
 
     if (hasInterest) {
       t.addSplit(sInterest);
     }
 
     // copy the splits from the other costs and update the payment split
     foreach (const MyMoneySplit& it, m_transaction.splits()) {
       if (it.accountId() != account.id()) {
         MyMoneySplit sp = it;
         sp.clearId();
         t.addSplit(sp);
         sPayment.setValue(sPayment.value() - sp.value());
         sPayment.setShares(sPayment.value());
         t.modifySplit(sPayment);
       }
     }
     return t;
   }
 
   void loadAccountList()
   {
     Q_Q(KNewLoanWizard);
     AccountSet interestSet, assetSet;
 
     if (q->field("borrowButton").toBool()) {
       interestSet.addAccountType(eMyMoney::Account::Type::Expense);
     } else {
       interestSet.addAccountType(eMyMoney::Account::Type::Income);
     }
     if (ui->m_interestCategoryPage)
       interestSet.load(ui->m_interestCategoryPage->ui->m_interestAccountEdit);
 
     assetSet.addAccountType(eMyMoney::Account::Type::Checkings);
     assetSet.addAccountType(eMyMoney::Account::Type::Savings);
     assetSet.addAccountType(eMyMoney::Account::Type::Cash);
     assetSet.addAccountType(eMyMoney::Account::Type::Asset);
     assetSet.addAccountType(eMyMoney::Account::Type::Currency);
     if (ui->m_assetAccountPage)
       assetSet.load(ui->m_assetAccountPage->ui->m_assetAccountEdit);
 
     assetSet.addAccountType(eMyMoney::Account::Type::CreditCard);
     assetSet.addAccountType(eMyMoney::Account::Type::Liability);
     if (ui->m_schedulePage)
       assetSet.load(ui->m_schedulePage->ui->m_paymentAccountEdit);
   }
 
   KNewLoanWizard       *q_ptr;
   Ui::KNewLoanWizard   *ui;
   MyMoneyAccountLoan    m_account;
   MyMoneyTransaction    m_transaction;
   MyMoneySplit          m_split;
   QBitArray             m_pages;
 };
 
 #endif
diff --git a/kmymoney/wizards/newloanwizard/loanattributeswizardpage.cpp b/kmymoney/wizards/newloanwizard/loanattributeswizardpage.cpp
index 4eaa83e81..c05de697d 100644
--- a/kmymoney/wizards/newloanwizard/loanattributeswizardpage.cpp
+++ b/kmymoney/wizards/newloanwizard/loanattributeswizardpage.cpp
@@ -1,116 +1,116 @@
 /***************************************************************************
 loanattributeswizardpage  -  description
 -------------------
 begin                : Mon Dec 30 2013
 copyright            : (C) 2013 by Jeremy Whiting
 email                : jpwhiting@kde.org
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "loanattributeswizardpage.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KMessageBox>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_loanattributeswizardpage.h"
 
 #include "knewbankdlg.h"
 #include "mymoneyfile.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyexception.h"
 
 LoanAttributesWizardPage::LoanAttributesWizardPage(QWidget *parent)
   : QWizardPage(parent),
     ui(new Ui::LoanAttributesWizardPage)
 {
   ui->setupUi(this);
 
   // Register the fields with the QWizard and connect the
   // appropriate signals to update the "Next" button correctly
   registerField("institution", ui->m_qcomboboxInstitutions);
   connect(ui->m_qcomboboxInstitutions, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &QWizardPage::completeChanged);
   connect(ui->m_qbuttonNew, &QAbstractButton::clicked, this, &LoanAttributesWizardPage::slotNewClicked);
 
   ui->m_qcomboboxInstitutions->clear();
 
   // Are we forcing the user to use institutions?
   ui->m_qcomboboxInstitutions->addItem(i18n("(No Institution)"));
   try {
     MyMoneyFile *file = MyMoneyFile::instance();
 
     auto list = file->institutionList();
     qSort(list);
 
     Q_FOREACH(const MyMoneyInstitution &institution, list) {
       ui->m_qcomboboxInstitutions->addItem(institution.name());
     }
   } catch (const MyMoneyException &e) {
-    qDebug("Exception in institution load: %s", qPrintable(e.what()));
+    qDebug("Exception in institution load: %s", e.what());
   }
 }
 
 LoanAttributesWizardPage::~LoanAttributesWizardPage()
 {
   delete ui;
 }
 
 /**
  * Update the "Next" button
  */
 bool LoanAttributesWizardPage::isComplete() const
 {
   return true;
 }
 
 void LoanAttributesWizardPage::initializePage()
 {
 }
 
 void LoanAttributesWizardPage::setInstitution(const QString &institutionName)
 {
   if (institutionName.isEmpty()) {
     ui->m_qcomboboxInstitutions->setCurrentItem(i18n("(No Institution)"));
   } else {
     ui->m_qcomboboxInstitutions->setCurrentItem(institutionName, false);
   }
 }
 
 void LoanAttributesWizardPage::slotNewClicked()
 {
   MyMoneyInstitution institution;
 
   QPointer<KNewBankDlg> dlg = new KNewBankDlg(institution, this);
   if (dlg->exec() && dlg != 0) {
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile *file = MyMoneyFile::instance();
 
       institution = dlg->institution();
       file->addInstitution(institution);
       ft.commit();
       initializePage();
       ui->m_qcomboboxInstitutions->setCurrentItem(institution.name(), false);
     } catch (const MyMoneyException &) {
       KMessageBox::information(this, i18n("Cannot add institution"));
     }
   }
   delete dlg;
 }
diff --git a/kmymoney/wizards/newloanwizard/summarywizardpage.cpp b/kmymoney/wizards/newloanwizard/summarywizardpage.cpp
index 65242cfc4..cd5996e24 100644
--- a/kmymoney/wizards/newloanwizard/summarywizardpage.cpp
+++ b/kmymoney/wizards/newloanwizard/summarywizardpage.cpp
@@ -1,114 +1,114 @@
 /***************************************************************************
                          summarywizardpage  -  description
                             -------------------
    begin                : Sun Jul 4 2010
    copyright            : (C) 2010 by Fernando Vilas
    email                : kmymoney-devel@kde.org
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "summarywizardpage.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QDate>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "ui_summarywizardpage.h"
 
 #include "mymoneyaccount.h"
 #include "mymoneyexception.h"
 #include "mymoneyfile.h"
 #include "mymoneypayee.h"
 #include "mymoneyschedule.h"
 
 SummaryWizardPage::SummaryWizardPage(QWidget *parent)
   : QWizardPage(parent),
     ui(new Ui::SummaryWizardPage)
 {
   ui->setupUi(this);
 
   // Register the fields with the QWizard and connect the
   // appropriate signals to update the "Next" button correctly
 }
 
 SummaryWizardPage::~SummaryWizardPage()
 {
   delete ui;
 }
 
 void SummaryWizardPage::initializePage()
 {
   // General
   if (field("borrowButton").toBool())
     ui->m_summaryLoanType->setText(i18n("borrowed"));
   else
     ui->m_summaryLoanType->setText(i18n("lend"));
 
   ui->m_summaryFirstPayment->setText(QLocale().toString(field("firstDueDateEdit").toDate()));
 
   const QString &payeeId = field("payeeEdit").toString();
   if (!payeeId.isEmpty()) {
     try {
       const MyMoneyPayee &payee = MyMoneyFile::instance()->payee(payeeId);
       ui->m_summaryPayee->setText(payee.name());
     } catch (const MyMoneyException &) {
       qWarning("Unable to load the payee name from the id");
     }
   } else {
     ui->m_summaryPayee->setText(i18n("not assigned"));
   }
 
   // Calculation
   if (field("interestOnReceptionButton").toBool())
     ui->m_summaryInterestDue->setText(i18n("on reception"));
   else
     ui->m_summaryInterestDue->setText(i18n("on due date"));
   ui->m_summaryPaymentFrequency->setText(MyMoneySchedule::occurrenceToString(eMyMoney::Schedule::Occurrence(field("paymentFrequencyUnitEdit").toInt())));
   ui->m_summaryAmount->setText(field("loanAmount6").toString());
   ui->m_summaryInterestRate->setText(field("interestRate6").toString());
   ui->m_summaryTerm->setText(field("duration6").toString());
   ui->m_summaryPeriodicPayment->setText(field("payment6").toString());
   ui->m_summaryBalloonPayment->setText(field("balloon6").toString());
 
   // Payment
   try {
     QStringList sel = field("interestAccountEdit").toStringList();
     if (sel.count() != 1)
-      throw MYMONEYEXCEPTION("Need a single selected interest category");
+      throw MYMONEYEXCEPTION_CSTRING("Need a single selected interest category");
     MyMoneyAccount acc = MyMoneyFile::instance()->account(sel.first());
     ui->m_summaryInterestCategory->setText(acc.name());
   } catch (const MyMoneyException &) {
     qWarning("Unable to determine interest category for loan account creation");
   }
   ui->m_summaryAdditionalFees->setText(field("additionalCost").toString());
   ui->m_summaryTotalPeriodicPayment->setText(field("periodicPayment").toString());
   ui->m_summaryNextPayment->setText(QLocale().toString(field("nextDueDateEdit").toDate()));
 
   try {
     QStringList sel = field("paymentAccountEdit").toStringList();
     if (sel.count() != 1)
-      throw MYMONEYEXCEPTION("Need a single selected payment account");
+      throw MYMONEYEXCEPTION_CSTRING("Need a single selected payment account");
     MyMoneyAccount acc = MyMoneyFile::instance()->account(sel.first());
     ui->m_summaryPaymentAccount->setText(acc.name());
   } catch (const MyMoneyException &) {
     qWarning("Unable to determine payment account for loan account creation");
   }
 
 }