diff --git a/kmymoney/views/kgloballedgerview.cpp b/kmymoney/views/kgloballedgerview.cpp
index 5f5221d67..409ffe271 100644
--- a/kmymoney/views/kgloballedgerview.cpp
+++ b/kmymoney/views/kgloballedgerview.cpp
@@ -1,2079 +1,2080 @@
 /***************************************************************************
                           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;
 
     case eView::Action::DisableViewDepenedendActions:
       pActions[Action::SelectAllTransactions]->setEnabled(false);
       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);
   }
 
   pActions[Action::SelectAllTransactions]->setEnabled(true);
   // 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::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);
 
   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'", 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;
     case eView::Intent::SelectRegisterTransactions:
       if (variant.count() == 1)
         updateLedgerActions(variant.at(0).value<KMyMoneyRegister::SelectedTransactions>());
       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->endEdit();
   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()), 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("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("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("Unable 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/widgets/register.cpp b/kmymoney/widgets/register.cpp
index e22d13bbb..679a28138 100644
--- a/kmymoney/widgets/register.cpp
+++ b/kmymoney/widgets/register.cpp
@@ -1,1892 +1,1894 @@
 /*
  * Copyright 2006-2018  Thomas Baumgart <tbaumgart@kde.org>
  * Copyright 2017-2018  Ł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 "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", 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*/)
+  void Register::endEdit()
   {
+    Q_D(Register);
+    d->m_ignoreNextButtonRelease = false;
   }
 
   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/register.h b/kmymoney/widgets/register.h
index 9648b2c68..c842dab06 100644
--- a/kmymoney/widgets/register.h
+++ b/kmymoney/widgets/register.h
@@ -1,366 +1,366 @@
 /*
  * Copyright 2006-2018  Thomas Baumgart <tbaumgart@kde.org>
  * Copyright 2017-2018  Ł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/>.
  */
 
 #ifndef REGISTER_H
 #define REGISTER_H
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "transactioneditorcontainer.h"
 
 class MyMoneyAccount;
 class MyMoneySplit;
 class MyMoneyTransaction;
 
 namespace eWidgets { enum class SortField;
                      namespace eTransaction { enum class Column; }
                      namespace eRegister { enum class DetailColumn;} }
 namespace eMyMoney { namespace Account { enum class Type; } }
 
 template <typename T> class QList;
 
 namespace KMyMoneyRegister
 {
   class RegisterItem;
   class Transaction;
   class SelectedTransactions;
 
   class RegisterPrivate;
   class Register : public TransactionEditorContainer
   {
     Q_OBJECT
     Q_DISABLE_COPY(Register)
 
     friend class Transaction;
     friend class StdTransaction;
     friend class InvestTransaction;
 
   public:
     explicit Register(QWidget* parent = nullptr);
     virtual ~Register();
 
     /**
     * add the item @a p to the register
     */
     void addItem(RegisterItem* p);
 
     /**
     * insert the item @a p into the register after item @a q
     */
     void insertItemAfter(RegisterItem* p, RegisterItem* q);
 
     /**
     * remove the item @p from the register
     */
     void removeItem(RegisterItem* p);
 
     /**
     * This method returns a list of pointers to all selected items
     * in the register
     *
     * @retval QList<RegisterItem*>
     */
     QList<RegisterItem*> selectedItems() const;
 
     /**
     * Construct a list of all currently selected transactions in the register.
     * If the current item carrying the focus (see focusItem() ) is selected
     * it will be the first one contained in the list.
     *
     * @param list reference to QList receiving the SelectedTransaction()'s
     */
     void selectedTransactions(SelectedTransactions&  list) const;
 
     QString text(int row, int col) const;
     QWidget* createEditor(int row, int col, bool initFromCell) const;
     void setCellContentFromEditor(int row, int col);
-    void endEdit(int row, int col, bool accept, bool replace);
+    void endEdit();
 
     RegisterItem* focusItem() const;
     RegisterItem* anchorItem() const;
 
     /**
     * set focus to specific item.
     * @return true if the item got focus
     */
     bool setFocusItem(RegisterItem* focusItem);
 
     void setAnchorItem(RegisterItem* anchorItem);
 
     /**
     * Set focus to the first focussable item
     * @return true if a focussable item was found
     */
     bool setFocusToTop();
 
     /**
     * Select @a item and unselect all others if @a dontChangeSelections
     * is @a false. If m_buttonState differs from Qt::NoButton (method is
     * called as a result of a mouse button press), then the setting of
     * @a dontChangeSelections has no effect.
     */
     void selectItem(RegisterItem* item, bool dontChangeSelections = false);
 
     /**
     * Clears all items in the register. All objects
     * added to the register will be deleted.
     */
     void clear();
 
     void updateRegister(bool forceUpdateRowHeight = false);
 
     /**
     * Assign all visible items an alternate background color
     */
     void updateAlternate() const;
 
     /**
     * make sure, we only show a single marker in a row
     * through hiding unused ones
     */
     void suppressAdjacentMarkers();
 
     /**
     * Adjusts column @a col so that all data fits in width.
     */
     void adjustColumn(int col);
 
     /**
     * Convenience method to setup the register to show the columns
     * based on the account type of @a account. If @a showAccountColumn
     * is @a true then the account column is shown independent of the
     * account type. If @a account does not have an @a id, all columns
     * will be hidden.
     */
     void setupRegister(const MyMoneyAccount& account, bool showAccountColumn = false);
 
     /**
     * Show the columns contained in @a cols for @a account. @a account
     * can be left empty ( MyMoneyAccount() ) e.g. for the search dialog.
     */
     void setupRegister(const MyMoneyAccount& account, const QList<eWidgets::eTransaction::Column>& cols);
 
     void setSortOrder(const QString& order);
     const QList<eWidgets::SortField>& sortOrder() const;
     eWidgets::SortField primarySortKey() const;
     void sortItems();
 
     /**
     * This member returns the last visible column that is used by the register
     * after it has been setup using setupRegister().
     *
     * @return last actively used column (base 0)
     */
     eWidgets::eTransaction::Column lastCol() const;
 
     RegisterItem* firstItem() const;
     RegisterItem* firstVisibleItem() const;
     RegisterItem* nextItem(RegisterItem*) const;
     RegisterItem* lastItem() const;
     RegisterItem* lastVisibleItem() const;
     RegisterItem* prevItem(RegisterItem*) const;
     RegisterItem* itemAtRow(int row) const;
 
     void resize(int col, bool force = false);
 
     void forceUpdateLists();
 
     void ensureItemVisible(RegisterItem* item);
 
     void arrangeEditWidgets(QMap<QString, QWidget*>& editWidgets, Transaction* t) override;
     void removeEditWidgets(QMap<QString, QWidget*>& editWidgets) override;
     void tabOrder(QWidgetList& tabOrderWidgets, KMyMoneyRegister::Transaction* t) const override;
 
     int rowHeightHint() const;
 
     void clearSelection();
 
     /**
     * This method creates a specific transaction according to the
     * transaction passed in @a transaction.
     *
     * @param parent pointer to register where the created object should be added
     * @param transaction the transaction which should be used to create the object
     * @param split the split of the transaction which should be used to create the object
     * @param uniqueId an int that will be used to construct the id of the item
     *
     * @return pointer to created object (0 upon failure)
     */
     static Transaction* transactionFactory(Register *parent, const MyMoneyTransaction& transaction, const MyMoneySplit& split, int uniqueId);
 
     const MyMoneyAccount& account() const;
 
     /**
     * This method creates group marker items and adds them to the register
     */
     void addGroupMarkers();
 
     /**
     * This method removes all trailing group markers and in a second
     * run reduces all adjacent group markers to show only one. In that
     * case the last one will remain.
     */
     void removeUnwantedGroupMarkers();
 
     void setLedgerLensForced(bool forced = true);
     bool ledgerLens() const;
 
     /**
     * Sets the selection mode to @a mode. Supported modes are QTable::Single and
     * QTable::Multi. QTable::Multi is the default when the object is created.
     */
     void setSelectionMode(SelectionMode mode);
 
     /**
     * This method sets a hint that the register instance will be used
     * with a transaction editor. This information is used while the column
     * sizes are being auto adjusted. If a transaction editor is used then
     * it's possible that it will need some extra space.
     */
     void setUsedWithEditor(bool value);
 
     eWidgets::eRegister::DetailColumn getDetailsColumnType() const;
     void setDetailsColumnType(eWidgets::eRegister::DetailColumn detailsColumnType);
 
   public Q_SLOTS:
       void ensureFocusItemVisible();
 
   protected:
 
     void mouseReleaseEvent(QMouseEvent *e) override;
     void contextMenuEvent(QContextMenuEvent *e) override;
 
     void unselectItems(int from = -1, int to = -1);
     void selectItems(int from, int to);
     void doSelectItems(int from, int to, bool selected);
     int selectedItemsCount() const;
 
     bool event(QEvent*) override;
     void focusOutEvent(QFocusEvent*) override;
     void focusInEvent(QFocusEvent*) override;
     void keyPressEvent(QKeyEvent*) override;
     void resizeEvent(QResizeEvent* ev) override;
 
     int rowToIndex(int row) const;
     void setupItemIndex(int rowCount);
 
     /**
     * This method determines the register item that is one page
     * further down or up in the ledger from the previous focus item.
     * The height to scroll is determined by visibleHeight()
     *
     * @param key Qt::Page_Up or Qt::Page_Down depending on the direction to scroll
     * @param modifiers state of Qt::ShiftModifier, Qt::ControlModifier, Qt::AltModifier and
     *              Qt::MetaModifier.
     */
     void scrollPage(int key, Qt::KeyboardModifiers modifiers);
 
     /**
     * This method determines the pointer to a RegisterItem
     * based on the item's @a id. If @a id is empty, this method
     * returns @a m_lastItem.
     *
     * @param id id of the item to be searched
     * @return pointer to RegisterItem or 0 if not found
     */
     RegisterItem* itemById(const QString& id) const;
 
     /**
     * Override logic and use standard QFrame behaviour
     */
     bool focusNextPrevChild(bool next) override;
 
     bool eventFilter(QObject* o, QEvent* e) override;
 
     void handleItemChange(RegisterItem* old, bool shift, bool control);
 
     void selectRange(RegisterItem* from, RegisterItem* to, bool invert, bool includeFirst, bool clearSel);
 
     /**
     * Returns the minimum column width based on the data in the header and the transactions.
     */
     int minimumColumnWidth(int col);
 
   protected Q_SLOTS:
     void resize();
 
     void selectItem(int row, int col);
     void slotEnsureItemVisible();
     void slotDoubleClicked(int row, int);
 
   Q_SIGNALS:
     void transactionsSelected(const KMyMoneyRegister::SelectedTransactions& list);
     /**
     * This signal is emitted when the focus and selection changes to @p item.
     *
     * @param item pointer to transaction that received the focus and was selected
     */
     void focusChanged(KMyMoneyRegister::Transaction* item);
 
     /**
     * This signal is emitted when the focus changes but the selection remains
     * the same. This usually happens when the focus is changed using the keyboard.
     */
     void focusChanged();
 
     /**
    * This signal is emitted when an @p item is about to be selected. The boolean
    * @p okToSelect is preset to @c true. If the @p item should not be selected
    * for whatever reason, the boolean @p okToSelect should be reset to @c false
    * by the connected slot.
    */
     void aboutToSelectItem(KMyMoneyRegister::RegisterItem* item, bool& okToSelect);
 
     void editTransaction();
 
     /**
     * This signal is sent out when the user clicks on the ReconcileStateColumn and
     * only a single transaction is selected.
     */
     void reconcileStateColumnClicked(KMyMoneyRegister::Transaction* item);
 
     /**
     * This signal is sent out, if an item without a transaction id has been selected.
     */
     void emptyItemSelected();
 
     /**
     * This signal is sent out, if the user selects an item with the right mouse button
     */
     void openContextMenu();
 
     /**
     * This signal is sent out when a new item has been added to the register
     */
     void itemAdded(RegisterItem* item);
 
   private:
     RegisterPrivate * const d_ptr;
     Q_DECLARE_PRIVATE(Register)
   };
 
 } // namespace
 
 #endif