diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6ab307a1..275c66045 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,391 +1,399 @@
 # The CMake version we require
 cmake_minimum_required(VERSION 3.1)
 
 # Setting the name of the main project
 project(KMyMoney VERSION "5.0.80" LANGUAGES CXX)
 
 # Determine the GIT reference (if we're based on GIT)
 if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/.git")
   execute_process(COMMAND git rev-parse --short HEAD WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}" OUTPUT_VARIABLE VERSION_SUFFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
   set(VERSION_SUFFIX "-${VERSION_SUFFIX}")
   # Add variables which are similar to the build in names of cmake
   set(PROJECT_VERSION_SUFFIX "${VERSION_SUFFIX}")
   set(${PROJECT_NAME}_VERSION_SUFFIX "${VERSION_SUFFIX}")
 endif()
 
 # Automoc all sources
 set(CMAKE_AUTOMOC TRUE)
 list(APPEND CMAKE_AUTOMOC_MACRO_NAMES "K_PLUGIN_FACTORY" "K_PLUGIN_FACTORY_WITH_JSON")
 
 if (POLICY CMP0063)
   cmake_policy(SET CMP0063 NEW) # Policy introduced in CMake version 3.3
 endif()
 if (POLICY CMP0071)
   # We do not require the old behaviour. It is only set to old, to prevent accidential use of
   # the new behavour. If the new behaviour becomes important, cmake_minimum_required has to be
   # set to "3.10".
   cmake_policy(SET CMP0071 OLD) # Policy introduced in CMake version 3.10
 endif()
 
 
 ######################### General Requirements ##########################
 
 if (CMAKE_COMPILER_IS_GNUCXX AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0.0)
     message(FATAL_ERROR "This version of KMyMoney requires at least gcc 6.0.0 to be built successfully")
 endif()
 
 find_package(ECM 5.10 REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(FeatureSummary)
 include(CMakeDependentOption)
 
 include(GenerateExportHeader)
 include(KMyMoneyMacros)
 
 find_package(PkgConfig)
 
 set (OPT_KF5_COMPONENTS DocTools Holidays Contacts Akonadi IdentityManagement Activities)
 find_package(Gpgmepp)
 if (Gpgmepp_FOUND)
   set(GPG_FOUND TRUE)
 else()
   set(GPG_FOUND FALSE)
   list(APPEND OPT_KF5_COMPONENTS Gpgmepp)
 endif()
 
 if (PkgConfig_FOUND)
   pkg_check_modules(SQLCIPHER sqlcipher)
 endif()
 
 find_package(Qt5 5.6 REQUIRED
   COMPONENTS Core DBus Widgets Svg Xml Test PrintSupport
   OPTIONAL_COMPONENTS Sql Concurrent QuickWidgets)
 
 find_package(KF5 5.2 REQUIRED
   COMPONENTS Archive CoreAddons Config ConfigWidgets I18n Completion KCMUtils ItemModels ItemViews Service Wallet IconThemes XmlGui TextWidgets Notifications KIO
   OPTIONAL_COMPONENTS ${OPT_KF5_COMPONENTS}
 )
-find_package(LibAlkimia5 8.0.0)
+
+if(LibAlkimia5_DIR)
+  set(_LibAlkimia5_DIR ${LibAlkimia5_DIR})
+endif()
+find_package(LibAlkimia5 8.0)
 if (NOT LibAlkimia5_FOUND)
-  find_package(LibAlkimia5 7.0.0 REQUIRED)
+  # restore LibAlkimia5_DIR set to NOTFOUND by first find_package call
+  if(_LibAlkimia5_DIR)
+    set(LibAlkimia5_DIR ${_LibAlkimia5_DIR})
+  endif()
+  find_package(LibAlkimia5 7.0 REQUIRED)
 endif()
 
 # Recent changes to LibAlkimia should allow us to remove this construct
 #if(CMAKE_SYSTEM_NAME MATCHES "Windows")
 #  include_directories(${GMP_INCLUDE_DIR})
 #endif()
 
 find_package(KChart 2.6.0)
 
 if(KF5Gpgmepp_FOUND)
   set(GPG_FOUND TRUE)
 endif()
 
 cmake_dependent_option(ENABLE_GPG "Enable GPG support." ON
                        "GPG_FOUND" OFF)
 
 add_feature_info("Encryption" ENABLE_GPG "Allows to store your financial data using strong GPG encryption.")
 
 add_definitions(-DQT_USE_QSTRINGBUILDER -DQT_NO_CAST_TO_ASCII -DQT_NO_URL_CAST_FROM_STRING)
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 # use DBus only on Linux
 if(CMAKE_SYSTEM_NAME MATCHES "Linux")
   set(KMM_DBUS 1)
 endif()
 
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 include_directories(${CMAKE_SOURCE_DIR} ${CMAKE_BINARY_DIR})
 
 # check for Doxygen
 find_package(Doxygen)
 if(DOXYGEN_FOUND)
   set(APIDOC_DIR ${CMAKE_CURRENT_BINARY_DIR}/apidocs)
 
   make_directory("${APIDOC_DIR}")
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/kmymoney.doxygen.in ${CMAKE_CURRENT_BINARY_DIR}/kmymoney.doxygen IMMEDIATE)
 
   add_custom_target(apidoc "${DOXYGEN}" "${CMAKE_CURRENT_BINARY_DIR}/kmymoney.doxygen")
 endif(DOXYGEN_FOUND)
 add_feature_info("Doxygen" DOXYGEN_FOUND "Generate API documentation with Doxygen (for devs only).")
 
 # check some include files exists
 set(CMAKE_REQUIRED_DEFINITIONS -D_XOPEN_SOURCE=500 -D_BSD_SOURCE)
 include (CheckIncludeFileCXX)
 check_include_file_cxx("unistd.h" HAVE_UNISTD_H)
 check_include_file_cxx("pwd.h" HAVE_PWD_H)
 check_include_file_cxx("windows.h" HAVE_WINDOWS_H)
 check_include_file_cxx("lmcons.h" HAVE_LMCONS_H)
 check_include_file_cxx("process.h" HAVE_PROCESS_H)
 
 # include check for members in structs
 include (CheckStructHasMember)
 
 ######################### Special Requirements ##########################
 
 # This is needed for QtSqlite and QtDesigner
 # (they'll install files to ${QT_INSTALL_DIR}/plugins/)
 get_filename_component(QT_BIN_DIR "${QT_MOC_EXECUTABLE}" PATH)
 get_filename_component(QT_DIR     ${QT_BIN_DIR}        PATH)
 set(QT_INSTALL_DIR ${QT_DIR} CACHE PATH
   "Qt install prefix defaults to the Qt prefix: ${QT_DIR}")
 
 cmake_dependent_option(ENABLE_ADDRESSBOOK "Enable addressbook support." ON
                        "KF5IdentityManagement_FOUND;KF5Akonadi_FOUND;KF5Contacts_FOUND" OFF)
 
 add_feature_info("Address book" ENABLE_ADDRESSBOOK "Allows fetching payee information from KDE PIM system.")
 
 cmake_dependent_option(ENABLE_HOLIDAYS "Enable addressbook support." ON
                        "KF5Holidays_FOUND" OFF)
 
 add_feature_info("Holidays" ENABLE_HOLIDAYS "Allows fetching holidays from KDE PIM system.")
 
 cmake_dependent_option(ENABLE_ACTIVITIES "Enable activities support." ON
                        "KF5Activities_FOUND" OFF)
 
 option(ENABLE_FORECASTVIEW "Enable forecast view" ON)
 add_feature_info("Forecast view" ENABLE_FORECASTVIEW "Adds possibility to calculate forecasts.")
 cmake_dependent_option(ENABLE_REPORTSVIEW "Enable reports view." ON
                        "KChart_FOUND" OFF)
 add_feature_info("Reports view" ENABLE_REPORTSVIEW "Adds possibility to display chart and table reports.")
 option(ENABLE_BUDGETVIEW "Enable budget view" ON)
 add_feature_info("Budget view" ENABLE_BUDGETVIEW "Adds possibility to plan a budget.")
 option(ENABLE_ONLINEJOBOUTBOXVIEW "Enable online job outbox view" ON)
 add_feature_info("Online job outbox view" ENABLE_ONLINEJOBOUTBOXVIEW "Adds outbox for sending online jobs.")
 
 cmake_dependent_option(ENABLE_SQLSTORAGE "Enable SQL storage support." ON
                        "Qt5Sql_FOUND" OFF)
 
 add_feature_info("SQL Storage" ENABLE_SQLSTORAGE "Allows storing your financial data in SQL database.")
 
 cmake_dependent_option(ENABLE_SQLCIPHER "Enable SQLCipher support." ON
                        "SQLCIPHER_FOUND" OFF)
 
 # Otherwise compilers halt on something like that:
 # ld: library not found for -lsqlcipher
 # on MS Windows, FreeBSD, macOS, and Ubuntu 14.04 (Ubuntu has CMake 3.5.1 but I'm not sure if it's the one to blame).
 if(ENABLE_SQLCIPHER AND (NOT CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_VERSION VERSION_LESS 3.5.2))
   link_directories(${SQLCIPHER_LIBRARY_DIRS})
 endif()
 
 add_feature_info("SQLCipher" ENABLE_SQLCIPHER "Allows encrypting your SQLite3 database.")
 
 cmake_dependent_option(ENABLE_IBANBICDATA "Enable IBAN/BIC data support." OFF
                        "Qt5Sql_FOUND" OFF)
 
 add_feature_info("IBAN/BIC data" ENABLE_IBANBICDATA "Adds predefined IBAN/BIC numbers to KMyMoney (note: doesn't work yet).")
 
 # check for optional QWebEngine
 option(ENABLE_WEBENGINE "Enable QWebEngine" OFF)
 if(ENABLE_WEBENGINE)
   find_package(Qt5WebEngineWidgets 5.8 REQUIRED)
   if(Qt5WebEngineWidgets_VERSION VERSION_GREATER 5.8.99 AND Qt5WebEngineWidgets_VERSION VERSION_LESS 5.9.3)
     message(WARNING "QWebEngine version ${Qt5WebEngineWidgets_VERSION} is known to be unstable with KMyMoney")
   endif()
 else(ENABLE_WEBENGINE)
   find_package(KF5WebKit REQUIRED)
 endif(ENABLE_WEBENGINE)
 
 # check for optional LibOFX support
 find_package(LibOfx)
 cmake_dependent_option(ENABLE_OFXIMPORTER "Enable OFX Importer" ON
                        "LIBOFX_FOUND" OFF)
 
 if(ENABLE_OFXIMPORTER)
   if(NOT LIBOFX_HAVE_CLIENTUID)
     set(PATH_TO_LIBOFX_HEADER "${LIBOFX_INCLUDE_DIR}/libofx/libofx.h")
     unset(LIBOFX_HAVE_CLIENTUID)
     unset(LIBOFX_HAVE_CLIENTUID CACHE) #not doing this will prevent updating below check
     check_struct_has_member("struct OfxFiLogin" clientuid ${PATH_TO_LIBOFX_HEADER} LIBOFX_HAVE_CLIENTUID LANGUAGE CXX)
   endif()
 
   if (LIBOFX_HAVE_CLIENTUID)
     set (nice_LIBOFX_HAVE_CLIENTUID "yes")
   else()
     set (nice_LIBOFX_HAVE_CLIENTUID "no")
   endif()
 
 else()
   set (nice_LIBOFX_HAVE_CLIENTUID "unknown")
   unset(LIBOFX_HAVE_CLIENTUID)
   unset(LIBOFX_HAVE_CLIENTUID CACHE)
 endif(ENABLE_OFXIMPORTER)
 
 add_feature_info("OFX Importer" ENABLE_OFXIMPORTER "Allows importing OFX files (have client uid version: ${nice_LIBOFX_HAVE_CLIENTUID})" )
 
 # check for optional KBanking support
 find_package(AQBANKING 5.6.5)
 find_package(gwenhywfar 4.15.3)
 find_package(gwengui-cpp)
 find_package(gwengui-qt5)
 
 cmake_dependent_option(ENABLE_KBANKING "Enable KBanking plugin" ON
                        "AQBANKING_FOUND;gwengui-cpp_FOUND;gwengui-qt5_FOUND;Qt5QuickWidgets_FOUND" OFF)
 
 add_feature_info(KBanking ENABLE_KBANKING "Interface for the following online banking protocols: HBCI, EBICS, OFX Direct Connect, Paypal")
 
 # check for optional Weboob support
 set(Python_ADDITIONAL_VERSIONS 2.7 2.6)
 find_package(PythonInterp 2.6)
 find_package(PythonLibs ${PYTHON_VERSION_STRING})
 
 if(PYTHONINTERP_FOUND AND PYTHONLIBS_FOUND)
   if(NOT PYTHON_VERSION_MAJOR VERSION_LESS 3)
     unset(PYTHONLIBS_FOUND)
     unset(PYTHONINTERP_FOUND)
     message(WARNING "Python 2 required, but Python 3 found.")
   else()
     include(FindPythonModule)
     find_python_module(weboob REQUIRED)
   endif()
 endif()
 
 cmake_dependent_option(ENABLE_WEBOOB "Enable Weboob plugin" ON
                        "PYTHONLIBS_FOUND;PYTHONINTERP_FOUND;PY_WEBOOB;Qt5Concurrent_FOUND" OFF)
 add_feature_info(Weboob ENABLE_WEBOOB "Online banking interface using Weboob.")
 
 
 # check for optional ical support
 find_package(Libical)
 cmake_dependent_option(ENABLE_LIBICAL "Enable Calendar plugin" ON
                        "LIBICAL_FOUND" OFF)
 add_feature_info(iCalendar ENABLE_LIBICAL "iCalendar integration.")
 
 
 option(ENABLE_QIFIMPORTER "Enable QIF Importer" ON)
 option(ENABLE_QIFEXPORTER "Enable QIF Exporter" ON)
 add_feature_info("QIF Importer" ENABLE_QIFIMPORTER "Allows importing QIF files.")
 add_feature_info("QIF Exporter" ENABLE_QIFEXPORTER "Allows exporting QIF files.")
 
 option(ENABLE_GNCIMPORTER "Enable GNC Importer" ON)
 add_feature_info("GNC Importer" ENABLE_GNCIMPORTER "Allows importing GNUCash files.")
 
 option(ENABLE_CSVIMPORTER "Enable CSV Importer" ON)
 option(ENABLE_CSVEXPORTER "Enable CSV Exporter" ON)
 add_feature_info("CSV Importer" ENABLE_CSVIMPORTER "Allows importing CSV files.")
 add_feature_info("CSV Exporter" ENABLE_CSVEXPORTER "Allows exporting CSV files.")
 
 option(ENABLE_UNFINISHEDFEATURES "For devs only" OFF)
 
 # TODO: this should be removed
 enable_testing()
 
 ######################### Settings ##########################
 
 # If no build type is set, use "Release with Debug Info"
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE RelWithDebInfo)
 endif(NOT CMAKE_BUILD_TYPE)
 
 set(CMAKE_BUILD_TYPE "${CMAKE_BUILD_TYPE}" CACHE STRING
   "Choose the type of build.
 Possible values are: 'Release' 'RelWithDebInfo' 'Debug' 'DebugKMM' 'Debugfull' 'Profile'
 The default value is: 'RelWithDebInfo'" FORCE)
 
 # tells gcc to enable exception handling
 include(KDECompilerSettings)
 kde_enable_exceptions()
 
 # Set linker flags
 
 # There is no way to detect linker in cmake (see https://gitlab.kitware.com/cmake/cmake/issues/17596)
 # and linkers aren't compatible with each other, so we need to assume something
 if(CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
   set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,-dead_strip -Wl,-undefined,error")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-dead_strip -Wl,-undefined,error -Wl,-mark_dead_strippable_dylib")
   set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS}    -Wl,-dead_strip -Wl,-undefined,error")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
   set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--as-needed")
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--as-needed")
   # TODO: remove multiple definitions of payeeIdentifierLoader::createPayeeIdentifierFromSqlDatabase
   set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed -Wl,--allow-multiple-definition")
   # CI builds are crashing on FreeBSD with --no-undefined. Probably because -DECM_ENABLE_SANITIZERS='address'
   # more can be read on the following site https://bugs.freedesktop.org/show_bug.cgi?id=100120
   if(NOT CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
     set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--no-undefined")
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
     set(CMAKE_EXE_LINKER_FLAGS    "${CMAKE_EXE_LINKER_FLAGS}    -Wl,--no-undefined")
   endif()
 
   # TODO: remove multiple definitions of payeeIdentifierLoader::hasItemEditDelegate
   if(CMAKE_SYSTEM_NAME MATCHES "Windows")
     set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} -Wl,--allow-multiple-definition")
     set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--allow-multiple-definition")
   endif()
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /FORCE:Multiple")
 endif()
 
 # Set compiler flags
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wlogical-op -Wno-null-dereference -Wshadow -Wunused -Wno-misleading-indentation -Wsuggest-override -Wcast-qual -Wformat=2 -fno-common")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -Wcast-qual -Wformat=2 -Wunreachable-code -fno-common")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /experimental:external /external:anglebrackets /external:W0 /W3")
 endif()
 
 
 # IDEA: Set on a per target base
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILER_ID MATCHES "AppleClang")
   # DebugKMM, Debugfull, Profile
   set(CMAKE_CXX_FLAGS_DEBUGKMM
       "-g -O2 -fno-reorder-blocks -fno-schedule-insns -fno-inline")
   set(CMAKE_CXX_FLAGS_DEBUGFULL
       "-g3 -fno-inline")
   set(CMAKE_CXX_FLAGS_PROFILE
       "-g3 -fno-inline -ftest-coverage -fprofile-arcs")
 
   # preprocessor definitions in case this is a debug build
   set(CMAKE_CXX_FLAGS_DEBUGFULL "${CMAKE_CXX_FLAGS_DEBUGFULL} -DQT_STRICT_ITERATORS -DKMM_DEBUG -DQT_FORCE_ASSERTS")
   set(CMAKE_CXX_FLAGS_DEBUGKMM  "${CMAKE_CXX_FLAGS_DEBUGFULL} -DKMM_DEBUG -DQT_FORCE_ASSERTS")
 endif()
 
 option(USE_MODELTEST
   "Compile with ModelTest code (default=OFF)" OFF)
 
 add_feature_info("Model test" USE_MODELTEST "Generate modeltest code (for devs only).")
 
 option(USE_QT_DESIGNER
   "Install KMyMoney specific widget library for Qt-Designer (default=OFF)" OFF)
 
 add_feature_info("QtDesigner" USE_QT_DESIGNER "Qt-Designer library support (for devs only).")
 
 ######################### The Actual Targets ##########################
 add_subdirectory( tools )
 add_subdirectory( kmymoney )
 if(KF5DocTools_FOUND)
   add_subdirectory( doc )
 endif()
 
 ######################### Output Results #############################
 
 # create the config.h file out of the config.h.cmake
 configure_file("config-kmymoney.h.cmake" "${CMAKE_CURRENT_BINARY_DIR}/config-kmymoney.h")
 configure_file("config-kmymoney-version.h.cmake" "${CMAKE_CURRENT_BINARY_DIR}/config-kmymoney-version.h")
 
 message("
 Build type: ${CMAKE_BUILD_TYPE}")
 
 feature_summary(WHAT REQUIRED_PACKAGES_NOT_FOUND
                 DESCRIPTION "The following REQUIRED packages have not been found:")
 
 feature_summary(WHAT OPTIONAL_PACKAGES_NOT_FOUND
                 DESCRIPTION "The following OPTIONAL packages have not been found:")
 
 feature_summary(WHAT ENABLED_FEATURES
                 DESCRIPTION "The following features have been enabled:")
 
 feature_summary(WHAT DISABLED_FEATURES
                 DESCRIPTION "The following features have been disabled:")
diff --git a/kmymoney/dialogs/investtransactioneditor.cpp b/kmymoney/dialogs/investtransactioneditor.cpp
index 642043c14..5ee33084e 100644
--- a/kmymoney/dialogs/investtransactioneditor.cpp
+++ b/kmymoney/dialogs/investtransactioneditor.cpp
@@ -1,1192 +1,1195 @@
 /*
  * Copyright 2007-2019  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 "investtransactioneditor.h"
 #include "transactioneditor_p.h"
 
 #include <typeinfo>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QLabel>
 #include <QList>
 #include <QPushButton>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KTextEdit>
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "kmymoneyreconcilecombo.h"
 #include "kmymoneyactivitycombo.h"
 #include "kmymoneytagcombo.h"
 #include "ktagcontainer.h"
 #include "investtransaction.h"
 #include "selectedtransactions.h"
 #include "transactioneditorcontainer.h"
 #include "kmymoneycategory.h"
 #include "kmymoneydateinput.h"
 #include "kmymoneyedit.h"
 #include "kmymoneyaccountselector.h"
 #include "kmymoneymvccombo.h"
 #include "mymoneyfile.h"
 #include "mymoneyexception.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "ksplittransactiondlg.h"
 #include "kcurrencycalculator.h"
 #include "kmymoneysettings.h"
 #include "investactivities.h"
 #include "kmymoneycompletion.h"
 #include "dialogenums.h"
 
 using namespace eMyMoney;
 using namespace KMyMoneyRegister;
 using namespace KMyMoneyTransactionForm;
 using namespace Invest;
 
 class InvestTransactionEditorPrivate : public TransactionEditorPrivate
 {
   Q_DISABLE_COPY(InvestTransactionEditorPrivate)
   Q_DECLARE_PUBLIC(InvestTransactionEditor)
   friend class Invest::Activity;
 
 public:
   explicit  InvestTransactionEditorPrivate(InvestTransactionEditor* qq) :
       TransactionEditorPrivate(qq),
       m_activity(0),
       m_phonyAccount(MyMoneyAccount("Phony-ID", MyMoneyAccount())),
       m_transactionType(eMyMoney::Split::InvestmentTransactionType::BuyShares)
   {
   }
 
   ~InvestTransactionEditorPrivate()
   {
     delete m_activity;
   }
 
   void showCategory(const QString& name, bool visible = true)
   {
     Q_Q(InvestTransactionEditor);
     if (auto cat = dynamic_cast<KMyMoneyCategory*>(q->haveWidget(name))) {
       if (Q_LIKELY(cat->splitButton())) {
         cat->parentWidget()->setVisible(visible);  // show or hide the enclosing QFrame;
       } else {
         cat->setVisible(visible);  // show or hide the enclosing QFrame;
       }
     }
   }
 
   void activityFactory(eMyMoney::Split::InvestmentTransactionType type)
   {
     Q_Q(InvestTransactionEditor);
     if (!m_activity || type != m_activity->type()) {
       delete m_activity;
       switch (type) {
         default:
         case eMyMoney::Split::InvestmentTransactionType::BuyShares:
           m_activity = new Buy(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::SellShares:
           m_activity = new Sell(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::Dividend:
         case eMyMoney::Split::InvestmentTransactionType::Yield:
           m_activity = new Div(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::ReinvestDividend:
           m_activity = new Reinvest(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::AddShares:
           m_activity = new Add(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::RemoveShares:
           m_activity = new Remove(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::SplitShares:
           m_activity = new Invest::Split(q);
           break;
         case eMyMoney::Split::InvestmentTransactionType::InterestIncome:
           m_activity = new IntInc(q);
           break;
       }
     }
   }
 
   MyMoneyMoney subtotal(const QList<MyMoneySplit>& splits) const
   {
     MyMoneyMoney sum;
 
     foreach (const auto split, splits)
       sum += split.value();
 
     return sum;
   }
 
   /**
    * This method creates a transaction to be used for the split fee/interest editor.
    * It has a reference to a phony account and the splits contained in @a splits .
    */
   bool createPseudoTransaction(MyMoneyTransaction& t, const QList<MyMoneySplit>& splits)
   {
     t.removeSplits();
 
     MyMoneySplit split;
     split.setAccountId(m_phonyAccount.id());
     split.setValue(-subtotal(splits));
     split.setShares(split.value());
     t.addSplit(split);
     m_phonySplit = split;
 
     foreach (const auto it_s, splits) {
       split = it_s;
       split.clearId();
       t.addSplit(split);
     }
     return true;
   }
 
   /**
    * Convenience method used by slotEditInterestSplits() and slotEditFeeSplits().
    *
    * @param categoryWidgetName name of the category widget
    * @param amountWidgetName name of the amount widget
    * @param splits the splits that make up the transaction to be edited
    * @param isIncome @c false for fees, @c true for interest
    * @param slotEditSplits name of the slot to be connected to the focusIn signal of the
    *                       category widget named @p categoryWidgetName in case of multiple splits
    *                       in @p splits .
    */
 
   int editSplits(const QString& categoryWidgetName,
                  const QString& amountWidgetName,
                  QList<MyMoneySplit>& splits,
                  bool isIncome,
                  const char* slotEditSplits)
   {
     Q_Q(InvestTransactionEditor);
     int rc = QDialog::Rejected;
 
     if (!m_openEditSplits) {
       // only get in here in a single instance
       m_openEditSplits = true;
 
       // force focus change to update all data
       auto category = dynamic_cast<KMyMoneyCategory*>(m_editWidgets[categoryWidgetName]);
       if (!category)
         return rc;
       QWidget* w = category->splitButton();
       if (w)
         w->setFocus();
 
       auto amount = dynamic_cast<KMyMoneyEdit*>(q->haveWidget(amountWidgetName));
       if (!amount)
         return rc;
 
       MyMoneyTransaction transaction;
       transaction.setCommodity(m_currency.id());
       if (splits.count() == 0 && !category->selectedItem().isEmpty()) {
         MyMoneySplit s;
         s.setAccountId(category->selectedItem());
         s.setShares(amount->value());
         s.setValue(s.shares());
         splits << s;
       }
       // use the transactions commodity as the currency indicator for the splits
       // this is used to allow some useful setting for the fractions in the amount fields
       try {
         m_phonyAccount.setCurrencyId(m_transaction.commodity());
         m_phonyAccount.fraction(MyMoneyFile::instance()->security(m_transaction.commodity()));
       } catch (const MyMoneyException &) {
         qDebug("Unable to setup precision");
       }
 
       if (createPseudoTransaction(transaction, splits)) {
         MyMoneyMoney value;
 
         QPointer<KSplitTransactionDlg> dlg = new KSplitTransactionDlg(transaction,
             m_phonySplit,
             m_phonyAccount,
             false,
             isIncome,
             MyMoneyMoney(),
             m_priceInfo,
             m_regForm);
         // q->connect(dlg, SIGNAL(newCategory(MyMoneyAccount&)), q, SIGNAL(newCategory(MyMoneyAccount&)));
 
         if ((rc = dlg->exec()) == QDialog::Accepted) {
           transaction = dlg->transaction();
           // collect splits out of the transaction
           splits.clear();
           MyMoneyMoney fees;
           foreach (const auto split, transaction.splits()) {
             if (split.accountId() == m_phonyAccount.id())
               continue;
             splits << split;
             fees += split.shares();
           }
           if (isIncome)
             fees = -fees;
 
           QString categoryId;
           q->setupCategoryWidget(category, splits, categoryId, slotEditSplits);
           amount->setValue(fees);
           q->slotUpdateTotalAmount();
         }
 
         delete dlg;
       }
 
       // focus jumps into the memo field
       if ((w = q->haveWidget("memo")) != 0) {
         w->setFocus();
       }
 
       m_openEditSplits = false;
     }
     return rc;
   }
 
   void updatePriceMode(const MyMoneySplit& split = MyMoneySplit())
   {
     Q_Q(InvestTransactionEditor);
     if (auto label = dynamic_cast<QLabel*>(q->haveWidget("price-label"))) {
       auto sharesEdit = dynamic_cast<KMyMoneyEdit*>(q->haveWidget("shares"));
       auto priceEdit = dynamic_cast<KMyMoneyEdit*>(q->haveWidget("price"));
 
       if (!sharesEdit || !priceEdit)
         return;
 
       MyMoneyMoney price;
       if (!split.id().isEmpty())
         price = split.price().reduce();
       else
         price = priceEdit->value().abs();
 
       if (q->priceMode() == eDialogs::PriceMode::PricePerTransaction) {
         priceEdit->setPrecision(m_currency.pricePrecision());
         label->setText(i18n("Transaction amount"));
         if (!sharesEdit->value().isZero())
           priceEdit->setValue(sharesEdit->value().abs() * price);
 
       } else if (q->priceMode() == eDialogs::PriceMode::PricePerShare) {
         priceEdit->setPrecision(m_security.pricePrecision());
         label->setText(i18n("Price/Share"));
         priceEdit->setValue(price);
       } else
         priceEdit->setValue(price);
     }
   }
 
   Activity*                        m_activity;
   MyMoneyAccount                   m_phonyAccount;
   MyMoneySplit                     m_phonySplit;
   MyMoneySplit                     m_assetAccountSplit;
   QList<MyMoneySplit>              m_interestSplits;
   QList<MyMoneySplit>              m_feeSplits;
   MyMoneySecurity                  m_security;
   MyMoneySecurity                  m_currency;
   eMyMoney::Split::InvestmentTransactionType m_transactionType;
 };
 
 
 InvestTransactionEditor::InvestTransactionEditor() :
   TransactionEditor(*new InvestTransactionEditorPrivate(this))
 {
   Q_D(InvestTransactionEditor);
   d->m_transactionType = eMyMoney::Split::InvestmentTransactionType::UnknownTransactionType;
 }
 
 InvestTransactionEditor::~InvestTransactionEditor()
 {
 }
 
 InvestTransactionEditor::InvestTransactionEditor(TransactionEditorContainer* regForm,
                                                  KMyMoneyRegister::InvestTransaction* item,
                                                  const KMyMoneyRegister::SelectedTransactions& list,
                                                  const QDate& lastPostDate) :
     TransactionEditor(*new InvestTransactionEditorPrivate(this),
                       regForm,
                       item,
                       list,
                       lastPostDate)
 {
   Q_D(InvestTransactionEditor);
   // after the geometries of the container are updated hide the widgets which are not needed by the current activity
   connect(d->m_regForm, &TransactionEditorContainer::geometriesUpdated, this, &InvestTransactionEditor::slotTransactionContainerGeometriesUpdated);
 
   // dissect the transaction into its type, splits, currency, security etc.
   KMyMoneyUtils::dissectTransaction(d->m_transaction, d->m_split,
                                     d->m_assetAccountSplit,
                                     d->m_feeSplits,
                                     d->m_interestSplits,
                                     d->m_security,
                                     d->m_currency,
                                     d->m_transactionType);
 
   // determine initial activity object
   d->activityFactory(d->m_transactionType);
 }
 
 void InvestTransactionEditor::createEditWidgets()
 {
   Q_D(InvestTransactionEditor);
   auto activity = new KMyMoneyActivityCombo();
   activity->setObjectName("activity");
   d->m_editWidgets["activity"] = activity;
   connect(activity, &KMyMoneyActivityCombo::activitySelected, this, &InvestTransactionEditor::slotUpdateActivity);
   connect(activity, &KMyMoneyActivityCombo::activitySelected, this, &InvestTransactionEditor::slotUpdateButtonState);
 
   d->m_editWidgets["postdate"] = new KMyMoneyDateInput;
 
   auto security = new KMyMoneySecurity;
   security->setObjectName("security");
   security->setPlaceholderText(i18n("Security"));
   d->m_editWidgets["security"] = security;
   connect(security, &KMyMoneyCombo::itemSelected, this, &InvestTransactionEditor::slotUpdateSecurity);
   connect(security, &QComboBox::editTextChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(security, &KMyMoneyCombo::createItem, this, &InvestTransactionEditor::slotCreateSecurity);
   connect(security, &KMyMoneyCombo::objectCreation, this, &InvestTransactionEditor::objectCreation);
 
   auto asset = new KMyMoneyCategory(false, nullptr);
   asset->setObjectName("asset-account");
   asset->setPlaceholderText(i18n("Asset account"));
   d->m_editWidgets["asset-account"] = asset;
   connect(asset, &QComboBox::editTextChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(asset, &KMyMoneyCombo::objectCreation, this, &InvestTransactionEditor::objectCreation);
 
   auto fees = new KMyMoneyCategory(true, nullptr);
   fees->setObjectName("fee-account");
   fees->setPlaceholderText(i18n("Fees"));
   d->m_editWidgets["fee-account"] = fees;
   connect(fees, &KMyMoneyCombo::itemSelected, this, &InvestTransactionEditor::slotUpdateFeeCategory);
   connect(fees, &QComboBox::editTextChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(fees, &KMyMoneyCombo::createItem, this, &InvestTransactionEditor::slotCreateFeeCategory);
   connect(fees, &KMyMoneyCombo::objectCreation, this, &InvestTransactionEditor::objectCreation);
   connect(fees->splitButton(), &QAbstractButton::clicked, this, &InvestTransactionEditor::slotEditFeeSplits);
 
   auto interest = new KMyMoneyCategory(true, nullptr);
   interest->setPlaceholderText(i18n("Interest"));
   interest->setObjectName("interest-account");
   d->m_editWidgets["interest-account"] = interest;
   connect(interest, &KMyMoneyCombo::itemSelected, this, &InvestTransactionEditor::slotUpdateInterestCategory);
   connect(interest, &QComboBox::editTextChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(interest, &KMyMoneyCombo::createItem, this, &InvestTransactionEditor::slotCreateInterestCategory);
   connect(interest, &KMyMoneyCombo::objectCreation, this, &InvestTransactionEditor::objectCreation);
   connect(interest->splitButton(), &QAbstractButton::clicked, this, &InvestTransactionEditor::slotEditInterestSplits);
 
   auto tag = new KTagContainer;
   tag->tagCombo()->setPlaceholderText(i18n("Tag"));
   tag->tagCombo()->setObjectName(QLatin1String("tag"));
   d->m_editWidgets["tag"] = tag;
   connect(tag->tagCombo(), &QComboBox::editTextChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(tag->tagCombo(), &KMyMoneyMVCCombo::createItem, this, &InvestTransactionEditor::slotNewTag);
   connect(tag->tagCombo(), &KMyMoneyMVCCombo::objectCreation, this, &InvestTransactionEditor::objectCreation);
 
   auto memo = new KTextEdit;
   memo->setObjectName("memo");
   memo->setTabChangesFocus(true);
   d->m_editWidgets["memo"] = memo;
   connect(memo, &QTextEdit::textChanged, this, &InvestTransactionEditor::slotUpdateInvestMemoState);
   connect(memo, &QTextEdit::textChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
 
   d->m_activity->memoText().clear();
   d->m_activity->memoChanged() = false;
 
   KMyMoneyEdit* value = new KMyMoneyEdit;
   value->setObjectName("shares");
   value->setPlaceholderText(i18n("Shares"));
   value->setResetButtonVisible(false);
   d->m_editWidgets["shares"] = value;
   connect(value, &KMyMoneyEdit::textChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(value, &KMyMoneyEdit::valueChanged, this, &InvestTransactionEditor::slotUpdateTotalAmount);
 
   value = new KMyMoneyEdit;
   value->setObjectName("price");
   value->setPlaceholderText(i18n("Price"));
   value->setResetButtonVisible(false);
   d->m_editWidgets["price"] = value;
   connect(value, &KMyMoneyEdit::textChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(value, &KMyMoneyEdit::valueChanged, this, &InvestTransactionEditor::slotUpdateTotalAmount);
 
   value = new KMyMoneyEdit;
   value->setObjectName("fee-amount");
   // TODO once we have the selected transactions as array of Transaction
   // we can allow multiple splits for fee and interest
   value->setResetButtonVisible(false);
   d->m_editWidgets["fee-amount"] = value;
   connect(value, &KMyMoneyEdit::textChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(value, &KMyMoneyEdit::valueChanged, this, &InvestTransactionEditor::slotUpdateTotalAmount);
 
   value = new KMyMoneyEdit;
   value->setObjectName("interest-amount");
   // TODO once we have the selected transactions as array of Transaction
   // we can allow multiple splits for fee and interest
   value->setResetButtonVisible(false);
   d->m_editWidgets["interest-amount"] = value;
   connect(value, &KMyMoneyEdit::textChanged, this, &InvestTransactionEditor::slotUpdateButtonState);
   connect(value, &KMyMoneyEdit::valueChanged, this, &InvestTransactionEditor::slotUpdateTotalAmount);
 
   auto reconcile = new KMyMoneyReconcileCombo;
   reconcile->setObjectName("reconcile");
   d->m_editWidgets["status"] = reconcile;
   connect(reconcile, &KMyMoneyMVCCombo::itemSelected, this, &InvestTransactionEditor::slotUpdateButtonState);
 
   KMyMoneyRegister::QWidgetContainer::iterator it_w;
   for (it_w = d->m_editWidgets.begin(); it_w != d->m_editWidgets.end(); ++it_w) {
     (*it_w)->installEventFilter(this);
   }
 
   QLabel* label;
 
   d->m_editWidgets["activity-label"] = label = new QLabel(i18n("Activity"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["postdate-label"] = label = new QLabel(i18n("Date"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["security-label"] = label = new QLabel(i18n("Security"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["shares-label"] = label = new QLabel(i18n("Shares"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["asset-label"] = label = new QLabel(i18n("Account"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["price-label"] = label = new QLabel(i18n("Price/share"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["fee-label"] = label = new QLabel(i18n("Fees"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["fee-amount-label"] = label = new QLabel("");
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["interest-label"] = label = new QLabel(i18n("Interest"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["interest-amount-label"] = label = new QLabel(i18n("Interest"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["memo-label"] = label = new QLabel(i18n("Memo"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["total"] = label = new QLabel("");
   label->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
 
   d->m_editWidgets["total-label"] = label = new QLabel(i18nc("Total value", "Total"));
   label->setAlignment(Qt::AlignVCenter);
 
   d->m_editWidgets["status-label"] = label = new QLabel(i18n("Status"));
   label->setAlignment(Qt::AlignVCenter);
 
   // if we don't have more than 1 selected transaction, we don't need
   // the "don't change" item in some of the combo widgets
   if (d->m_transactions.count() < 2) {
     reconcile->removeDontCare();
   }
 }
 
 int InvestTransactionEditor::slotEditFeeSplits()
 {
   Q_D(InvestTransactionEditor);
   return d->editSplits("fee-account", "fee-amount", d->m_feeSplits, false, SLOT(slotEditFeeSplits()));
 }
 
 int InvestTransactionEditor::slotEditInterestSplits()
 {
   Q_D(InvestTransactionEditor);
   return d->editSplits("interest-account", "interest-amount", d->m_interestSplits, true, SLOT(slotEditInterestSplits()));
 }
 
 void InvestTransactionEditor::slotCreateSecurity(const QString& name, QString& id)
 {
   Q_D(InvestTransactionEditor);
   MyMoneyAccount acc;
   QRegExp exp("([^:]+)");
   if (exp.indexIn(name) != -1) {
     acc.setName(exp.cap(1));
 
     slotNewInvestment(acc, d->m_account);
 
     // return id
     id = acc.id();
 
     if (!id.isEmpty()) {
       slotUpdateSecurity(id);
       slotReloadEditWidgets();
     }
   }
 }
 
 void InvestTransactionEditor::slotCreateFeeCategory(const QString& name, QString& id)
 {
   MyMoneyAccount acc;
   acc.setName(name);
 
   slotNewCategory(acc, MyMoneyFile::instance()->expense());
 
   // return id
   id = acc.id();
 }
 
 void InvestTransactionEditor::slotUpdateFeeCategory(const QString& id)
 {
   haveWidget("fee-amount")->setDisabled(id.isEmpty());
 }
 
 void InvestTransactionEditor::slotUpdateInterestCategory(const QString& id)
 {
   haveWidget("interest-amount")->setDisabled(id.isEmpty());
 }
 
 void InvestTransactionEditor::slotCreateInterestCategory(const QString& name, QString& id)
 {
   MyMoneyAccount acc;
   acc.setName(name);
 
   slotNewCategory(acc, MyMoneyFile::instance()->income());
 
   id = acc.id();
 }
 
 void InvestTransactionEditor::slotReloadEditWidgets()
 {
   Q_D(InvestTransactionEditor);
   auto interest = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
   auto fees = dynamic_cast<KMyMoneyCategory*>(haveWidget("fee-account"));
   auto security = dynamic_cast<KMyMoneySecurity*>(haveWidget("security"));
 
   if (!interest || !fees || !security)
     return;
 
   AccountSet aSet;
   QString id;
 
   // interest-account
   aSet.clear();
   aSet.addAccountGroup(Account::Type::Income);
   aSet.load(interest->selector());
   setupCategoryWidget(interest, d->m_interestSplits, id, SLOT(slotEditInterestSplits()));
 
   // fee-account
   aSet.clear();
   aSet.addAccountGroup(Account::Type::Expense);
   aSet.load(fees->selector());
   setupCategoryWidget(fees, d->m_feeSplits, id, SLOT(slotEditFeeSplits()));
 
   // security
   aSet.clear();
   aSet.load(security->selector(), i18n("Security"), d->m_account.accountList(), true);
 }
 
 void InvestTransactionEditor::loadEditWidgets(eWidgets::eRegister::Action)
 {
   loadEditWidgets();
 }
 
 void InvestTransactionEditor::loadEditWidgets()
 {
   Q_D(InvestTransactionEditor);
   QString id;
 
   auto postDate = dynamic_cast<KMyMoneyDateInput*>(haveWidget("postdate"));
   auto reconcile = dynamic_cast<KMyMoneyReconcileCombo*>(haveWidget("status"));
   auto security = dynamic_cast<KMyMoneySecurity*>(haveWidget("security"));
   auto activity = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
   auto asset = dynamic_cast<KMyMoneyCategory*>(haveWidget("asset-account"));
   auto memo = dynamic_cast<KTextEdit*>(d->m_editWidgets["memo"]);
   KMyMoneyEdit* value;
   auto interest = dynamic_cast<KMyMoneyCategory*>(haveWidget("interest-account"));
   auto fees = dynamic_cast<KMyMoneyCategory*>(haveWidget("fee-account"));
 
   if (!postDate || !reconcile || !security || !activity ||
       !asset || !memo || !interest || !fees)
     return;
 
   // check if the current transaction has a reference to an equity account
   auto haveEquityAccount = false;
   foreach (const auto split, d->m_transaction.splits()) {
     auto acc = MyMoneyFile::instance()->account(split.accountId());
     if (acc.accountType() == Account::Type::Equity) {
       haveEquityAccount = true;
       break;
     }
   }
 
   // asset-account
   AccountSet aSet;
   aSet.clear();
   aSet.addAccountType(Account::Type::Checkings);
   aSet.addAccountType(Account::Type::Savings);
   aSet.addAccountType(Account::Type::Cash);
   aSet.addAccountType(Account::Type::Asset);
   aSet.addAccountType(Account::Type::Currency);
   aSet.addAccountType(Account::Type::CreditCard);
   if (KMyMoneySettings::expertMode() || haveEquityAccount)
     aSet.addAccountGroup(Account::Type::Equity);
   aSet.load(asset->selector());
 
   // security
   security->setSuppressObjectCreation(false);    // allow object creation on the fly
   aSet.clear();
   aSet.load(security->selector(), i18n("Security"), d->m_account.accountList(), true);
 
   // memo
   memo->setText(d->m_split.memo());
   d->m_activity->memoText() = d->m_split.memo();
   d->m_activity->memoChanged() = false;
 
   if (!isMultiSelection()) {
     // date
     if (d->m_transaction.postDate().isValid())
       postDate->setDate(d->m_transaction.postDate());
     else if (d->m_lastPostDate.isValid())
       postDate->setDate(d->m_lastPostDate);
     else
       postDate->setDate(QDate::currentDate());
 
     // security (but only if it's not the investment account)
     if (d->m_split.accountId() != d->m_account.id()) {
       security->completion()->setSelected(d->m_split.accountId());
       security->slotItemSelected(d->m_split.accountId());
     }
 
     // activity
     activity->setActivity(d->m_activity->type());
     slotUpdateActivity(activity->activity());
 
     asset->completion()->setSelected(d->m_assetAccountSplit.accountId());
     asset->slotItemSelected(d->m_assetAccountSplit.accountId());
 
     // interest-account
     aSet.clear();
     aSet.addAccountGroup(Account::Type::Income);
     aSet.load(interest->selector());
     setupCategoryWidget(interest, d->m_interestSplits, id, SLOT(slotEditInterestSplits()));
 
     // fee-account
     aSet.clear();
     aSet.addAccountGroup(Account::Type::Expense);
     aSet.load(fees->selector());
     setupCategoryWidget(fees, d->m_feeSplits, id, SLOT(slotEditFeeSplits()));
 
     // shares
     // don't set the value if the number of shares is zero so that
     // we can see the hint
     value = dynamic_cast<KMyMoneyEdit*>(haveWidget("shares"));
     if (!value)
       return;
     if (typeid(*(d->m_activity)) != typeid(Invest::Split(this)))
       value->setPrecision(MyMoneyMoney::denomToPrec(d->m_security.smallestAccountFraction()));
     else
       value->setPrecision(-1);
 
     if (!d->m_split.shares().isZero())
       value->setValue(d->m_split.shares().abs());
 
     // price
     d->updatePriceMode(d->m_split);
 
     // fee amount
     value = dynamic_cast<KMyMoneyEdit*>(haveWidget("fee-amount"));
     if (!value)
       return;
     value->setValue(d->subtotal(d->m_feeSplits));
 
     // interest amount
     value = dynamic_cast<KMyMoneyEdit*>(haveWidget("interest-amount"));
     if (!value)
       return;
     value->setValue(-d->subtotal(d->m_interestSplits));
 
     // total
     slotUpdateTotalAmount();
 
     // status
     if (d->m_split.reconcileFlag() == eMyMoney::Split::State::Unknown)
       d->m_split.setReconcileFlag(eMyMoney::Split::State::NotReconciled);
     reconcile->setState(d->m_split.reconcileFlag());
 
   } else {
     postDate->loadDate(QDate());
     reconcile->setState(eMyMoney::Split::State::Unknown);
 
     // We don't allow to change the activity
     activity->setActivity(d->m_activity->type());
     slotUpdateActivity(activity->activity());
     activity->setDisabled(true);
 
     // scan the list of selected transactions and check that they have
     // the same activity.
     const QString& action = d->m_item->split().action();
     bool isNegative = d->m_item->split().shares().isNegative();
     bool allSameActivity = true;
     for (auto it_t = d->m_transactions.begin(); allSameActivity && (it_t != d->m_transactions.end()); ++it_t) {
       allSameActivity = (action == (*it_t).split().action() && (*it_t).split().shares().isNegative() == isNegative);
     }
 
     QStringList fields;
     fields << "shares" << "price" << "fee-amount" << "interest-amount";
     for (auto it_f = fields.constBegin(); it_f != fields.constEnd(); ++it_f) {
       value = dynamic_cast<KMyMoneyEdit*>(haveWidget((*it_f)));
       if (!value)
         return;
       value->setText("");
       value->setAllowEmpty();
     }
 
     // if we have transactions with different activities, disable some more widgets
     if (!allSameActivity) {
       fields << "asset-account" << "fee-account" << "interest-account";
       for (auto it_f = fields.constBegin(); it_f != fields.constEnd(); ++it_f) {
         haveWidget(*it_f)->setDisabled(true);
       }
     }
   }
 }
 
 QWidget* InvestTransactionEditor::firstWidget() const
 {
   return nullptr; // let the creator use the first widget in the tab order
 }
 
 bool InvestTransactionEditor::isComplete(QString& reason) const
 {
   Q_D(const InvestTransactionEditor);
   reason.clear();
   return d->m_activity->isComplete(reason);
 }
 
 void InvestTransactionEditor::slotUpdateSecurity(const QString& stockId)
 {
   Q_D(InvestTransactionEditor);
   auto file = MyMoneyFile::instance();
   MyMoneyAccount stock = file->account(stockId);
   d->m_security = file->security(stock.currencyId());
   d->m_currency = file->security(d->m_security.tradingCurrency());
   bool currencyKnown = !d->m_currency.id().isEmpty();
   if (!currencyKnown) {
     d->m_currency.setTradingSymbol("???");
   } else {
     auto sharesWidget = dynamic_cast<KMyMoneyEdit*>(haveWidget("shares"));
     if (sharesWidget) {
       if (typeid(*(d->m_activity)) != typeid(Invest::Split(this)))
         sharesWidget->setPrecision(MyMoneyMoney::denomToPrec(d->m_security.smallestAccountFraction()));
       else
         sharesWidget->setPrecision(-1);
     }
   }
 
   d->updatePriceMode();
 
   d->m_activity->preloadAssetAccount();
 
   haveWidget("shares")->setEnabled(currencyKnown);
   haveWidget("price")->setEnabled(currencyKnown);
   haveWidget("fee-amount")->setEnabled(currencyKnown);
   haveWidget("interest-amount")->setEnabled(currencyKnown);
 
   slotUpdateTotalAmount();
   slotUpdateButtonState();
   resizeForm();
 }
 
 bool InvestTransactionEditor::fixTransactionCommodity(const MyMoneyAccount& /* account */)
 {
   return true;
 }
 
 
 void InvestTransactionEditor::totalAmount(MyMoneyMoney& amount) const
 {
   auto activityCombo = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
   auto sharesEdit = dynamic_cast<KMyMoneyEdit*>(haveWidget("shares"));
   auto priceEdit = dynamic_cast<KMyMoneyEdit*>(haveWidget("price"));
   auto feesEdit = dynamic_cast<KMyMoneyEdit*>(haveWidget("fee-amount"));
   auto interestEdit = dynamic_cast<KMyMoneyEdit*>(haveWidget("interest-amount"));
 
   if (!activityCombo || !sharesEdit || !priceEdit ||
       !feesEdit || !interestEdit)
     return;
 
   if (priceMode() == eDialogs::PriceMode::PricePerTransaction)
     amount = priceEdit->value().abs();
   else
     amount = sharesEdit->value().abs() * priceEdit->value().abs();
 
   if (feesEdit->isVisible()) {
     MyMoneyMoney fee = feesEdit->value();
     MyMoneyMoney factor(-1, 1);
     switch (activityCombo->activity()) {
       case eMyMoney::Split::InvestmentTransactionType::BuyShares:
       case eMyMoney::Split::InvestmentTransactionType::ReinvestDividend:
         factor = MyMoneyMoney::ONE;
         break;
       default:
         break;
     }
     amount += (fee * factor);
   }
 
   if (interestEdit->isVisible()) {
     MyMoneyMoney interest = interestEdit->value();
     MyMoneyMoney factor(1, 1);
     switch (activityCombo->activity()) {
       case eMyMoney::Split::InvestmentTransactionType::BuyShares:
         factor = MyMoneyMoney::MINUS_ONE;
         break;
       default:
         break;
     }
     amount += (interest * factor);
   }
 }
 
 void InvestTransactionEditor::slotUpdateTotalAmount()
 {
   Q_D(InvestTransactionEditor);
   auto total = dynamic_cast<QLabel*>(haveWidget("total"));
 
   if (total && total->isVisible()) {
     MyMoneyMoney amount;
     totalAmount(amount);
     total->setText(amount.convert(d->m_currency.smallestAccountFraction(), d->m_security.roundingMethod())
                    .formatMoney(d->m_currency.tradingSymbol(), MyMoneyMoney::denomToPrec(d->m_currency.smallestAccountFraction())));
   }
 }
 
 void InvestTransactionEditor::slotTransactionContainerGeometriesUpdated()
 {
   Q_D(InvestTransactionEditor);
   // when the geometries of the transaction container are updated some edit widgets that were
   // previously hidden are being shown (see QAbstractItemView::updateEditorGeometries) so we
   // need to update the activity with the current activity in order to show only the widgets
   // which are needed by the current activity
   if (d->m_editWidgets.isEmpty())
     return;
   slotUpdateActivity(d->m_activity->type());
 }
 
 void InvestTransactionEditor::slotUpdateActivity(eMyMoney::Split::InvestmentTransactionType activity)
 {
   Q_D(InvestTransactionEditor);
   // create new activity object if required
   d->activityFactory(activity);
 
   // hide all dynamic widgets
   d->showCategory("interest-account", false);
   d->showCategory("fee-account", false);
 
   QStringList dynwidgets;
   dynwidgets << "total-label" << "asset-label" << "fee-label" << "fee-amount-label" << "interest-label" << "interest-amount-label" << "price-label" << "shares-label";
 
   // hiding labels works by clearing them. hide() does not do the job
   // as the underlying text in the QTable object will shine through
   QStringList::const_iterator it_s;
   for (it_s = dynwidgets.constBegin(); it_s != dynwidgets.constEnd(); ++it_s) {
     QLabel* w = dynamic_cast<QLabel*>(haveWidget(*it_s));
     if (w)
       w->setText(QStringLiteral(" "));
   }
 
   // real widgets can be hidden
   dynwidgets.clear();
   dynwidgets << "asset-account" << "interest-amount" << "fee-amount" << "shares" << "price" << "total";
 
   for (it_s = dynwidgets.constBegin(); it_s != dynwidgets.constEnd(); ++it_s) {
     QWidget* w = haveWidget(*it_s);
     if (w)
       w->hide();
   }
   d->m_activity->showWidgets();
   d->m_activity->preloadAssetAccount();
 }
 
 eDialogs::PriceMode InvestTransactionEditor::priceMode() const
 {
   Q_D(const InvestTransactionEditor);
   eDialogs::PriceMode mode = static_cast<eDialogs::PriceMode>(eDialogs::PriceMode::Price);
   auto sec = dynamic_cast<KMyMoneySecurity*>(d->m_editWidgets["security"]);
 
   QString accId;
   if (sec && !sec->currentText().isEmpty()) {
     accId = sec->selectedItem();
     if (accId.isEmpty())
       accId = d->m_account.id();
   }
   while (!accId.isEmpty() && mode == eDialogs::PriceMode::Price) {
     auto acc = MyMoneyFile::instance()->account(accId);
     if (acc.value("priceMode").isEmpty())
       accId = acc.parentAccountId();
     else
       mode = static_cast<eDialogs::PriceMode>(acc.value("priceMode").toInt());
   }
 
   // if mode is still <Price> then use that
   if (mode == eDialogs::PriceMode::Price)
     mode = eDialogs::PriceMode::PricePerShare;
   return mode;
 }
 
 MyMoneySecurity InvestTransactionEditor::security() const
 {
   Q_D(const InvestTransactionEditor);
   return d->m_security;
 }
 
 QList<MyMoneySplit> InvestTransactionEditor::feeSplits() const
 {
   Q_D(const InvestTransactionEditor);
   return d->m_feeSplits;
 }
 
 QList<MyMoneySplit> InvestTransactionEditor::interestSplits() const
 {
   Q_D(const InvestTransactionEditor);
   return d->m_interestSplits;
 }
 
 bool InvestTransactionEditor::setupPrice(const MyMoneyTransaction& t, MyMoneySplit& split)
 {
   Q_D(InvestTransactionEditor);
   auto file = MyMoneyFile::instance();
   auto acc = file->account(split.accountId());
   MyMoneySecurity toCurrency(file->security(acc.currencyId()));
   int fract = acc.fraction();
 
   if (acc.currencyId() != t.commodity()) {
     if (acc.currencyId().isEmpty())
       acc.setCurrencyId(t.commodity());
 
     QMap<QString, MyMoneyMoney>::Iterator it_p;
     QString key = t.commodity() + '-' + acc.currencyId();
     it_p = d->m_priceInfo.find(key);
 
     // if it's not found, then collect it from the user first
     MyMoneyMoney price;
     if (it_p == d->m_priceInfo.end()) {
       MyMoneySecurity fromCurrency = file->security(t.commodity());
       MyMoneyMoney fromValue, toValue;
 
       fromValue = split.value();
       const MyMoneyPrice &priceInfo = MyMoneyFile::instance()->price(fromCurrency.id(), toCurrency.id(), t.postDate());
       toValue = split.value() * priceInfo.rate(toCurrency.id());
 
       QPointer<KCurrencyCalculator> calc =
         new KCurrencyCalculator(fromCurrency,
                                 toCurrency,
                                 fromValue,
                                 toValue,
                                 t.postDate(),
                                 fract,
                                 d->m_regForm);
 
       if (calc->exec() == QDialog::Rejected) {
         delete calc;
         return false;
       }
       price = calc->price();
       delete calc;
       d->m_priceInfo[key] = price;
     } else {
       price = (*it_p);
     }
 
     // update shares if the transaction commodity is the currency
     // of the current selected account
     split.setShares(split.value() * price);
   } else {
     split.setShares(split.value());
   }
 
   return true;
 }
 
 bool InvestTransactionEditor::createTransaction(MyMoneyTransaction& t, const MyMoneyTransaction& torig, const MyMoneySplit& sorig, bool /* skipPriceDialog */)
 {
   Q_D(InvestTransactionEditor);
   auto file = MyMoneyFile::instance();
   // we start with the previous values, make sure we can add them later on
   t = torig;
   MyMoneySplit s0 = sorig;
   s0.clearId();
 
   auto sec = dynamic_cast<KMyMoneySecurity*>(d->m_editWidgets["security"]);
   if (sec && (!isMultiSelection() || !sec->currentText().isEmpty())) {
     QString securityId = sec->selectedItem();
     if (!securityId.isEmpty()) {
       s0.setAccountId(securityId);
       MyMoneyAccount stockAccount = file->account(securityId);
       QString currencyId = stockAccount.currencyId();
       MyMoneySecurity security = file->security(currencyId);
 
       t.setCommodity(security.tradingCurrency());
     } else {
       s0.setAccountId(d->m_account.id());
       t.setCommodity(d->m_account.currencyId());
     }
   }
 
   // extract price info from original transaction
   d->m_priceInfo.clear();
   if (!torig.id().isEmpty()) {
     foreach (const auto split, torig.splits()) {
       if (split.id() != sorig.id()) {
         auto cat = file->account(split.accountId());
         if (cat.currencyId() != d->m_account.currencyId()) {
           if (cat.currencyId().isEmpty())
             cat.setCurrencyId(d->m_account.currencyId());
           if (!split.shares().isZero() && !split.value().isZero()) {
             d->m_priceInfo[cat.currencyId()] = (split.shares() / split.value()).reduce();
           }
         }
       }
     }
   }
 
   t.removeSplits();
 
   auto postDate = dynamic_cast<KMyMoneyDateInput*>(d->m_editWidgets["postdate"]);
   if (postDate && postDate->date().isValid()) {
     t.setPostDate(postDate->date());
   }
 
   // memo and number field are special: if we have multiple transactions selected
   // and the edit field is empty, we treat it as "not modified".
   // FIXME a better approach would be to have a 'dirty' flag with the widgets
   //       which identifies if the originally loaded value has been modified
   //       by the user
   auto memo = dynamic_cast<KTextEdit*>(d->m_editWidgets["memo"]);
   if (memo) {
     if (!isMultiSelection() || d->m_activity->memoChanged())
       s0.setMemo(memo->toPlainText());
   }
 
   MyMoneySplit assetAccountSplit;
   QList<MyMoneySplit> feeSplits;
   QList<MyMoneySplit> interestSplits;
-  MyMoneySecurity security, currency;
+  MyMoneySecurity security;
+  MyMoneySecurity currency = file->security(t.commodity());
   eMyMoney::Split::InvestmentTransactionType transactionType;
 
-  // extract the splits from the original transaction
-  KMyMoneyUtils::dissectTransaction(torig, sorig,
+  // extract the splits from the original transaction, but only
+  // if there is one because otherwise the currency is overridden
+  if (t.commodity().isEmpty()) {
+    KMyMoneyUtils::dissectTransaction(torig, sorig,
                      assetAccountSplit,
                      feeSplits,
                      interestSplits,
                      security,
                      currency,
                      transactionType);
-
+  }
   // check if the trading currency is the same if the security has changed
   // in case it differs, check that we have a price (request from user)
   // and convert all splits
   // TODO
 
   // do the conversions here
   // TODO
 
   // keep the current activity object and create a new one
   // that can be destroyed later on
   auto activity = d->m_activity;
   d->m_activity = 0;      // make sure we create a new one
   d->activityFactory(activity->type());
 
   // if the activity is not set in the combo widget, we keep
   // the one which is used in the original transaction
   auto activityCombo = dynamic_cast<KMyMoneyActivityCombo*>(haveWidget("activity"));
   if (activityCombo && activityCombo->activity() == eMyMoney::Split::InvestmentTransactionType::UnknownTransactionType) {
     d->activityFactory(transactionType);
   }
 
   // if we mark the split reconciled here, we'll use today's date if no reconciliation date is given
   auto status = dynamic_cast<KMyMoneyReconcileCombo*>(d->m_editWidgets["status"]);
   if (status && status->state() != eMyMoney::Split::State::Unknown)
     s0.setReconcileFlag(status->state());
 
   if (s0.reconcileFlag() == eMyMoney::Split::State::Reconciled && !s0.reconcileDate().isValid())
     s0.setReconcileDate(QDate::currentDate());
 
   // call the creation logic for the current selected activity
   bool rc = d->m_activity->createTransaction(t, s0, assetAccountSplit, feeSplits, d->m_feeSplits, interestSplits, d->m_interestSplits, security, currency);
 
   // now switch back to the original activity
   delete d->m_activity;
   d->m_activity = activity;
 
   // add the splits to the transaction
   if (rc) {
     if (security.name().isEmpty())                                              // new transaction has no security filled...
       security = file->security(file->account(s0.accountId()).currencyId());    // ...so fetch it from s0 split
 
     QList<MyMoneySplit> resultSplits;  // concatenates splits for easy processing
 
     if (!assetAccountSplit.accountId().isEmpty())
       resultSplits.append(assetAccountSplit);
 
     if (!feeSplits.isEmpty())
       resultSplits.append(feeSplits);
 
     if (!interestSplits.isEmpty())
       resultSplits.append(interestSplits);
 
     AlkValue::RoundingMethod roundingMethod = AlkValue::RoundRound;
     if (security.roundingMethod() != AlkValue::RoundNever)
       roundingMethod = security.roundingMethod();
 
     int currencyFraction = currency.smallestAccountFraction();
     int securityFraction = security.smallestAccountFraction();
 
     // assuming that all non-stock splits are monetary
     foreach (auto split, resultSplits) {
       split.clearId();
       split.setShares(MyMoneyMoney(split.shares().convertDenominator(currencyFraction, roundingMethod)));
       split.setValue(MyMoneyMoney(split.value().convertDenominator(currencyFraction, roundingMethod)));
       t.addSplit(split);
     }
 
     // Don't do any rounding on a split factor
     if (d->m_activity->type() != eMyMoney::Split::InvestmentTransactionType::SplitShares) {
       s0.setShares(MyMoneyMoney(s0.shares().convertDenominator(securityFraction, roundingMethod))); // only shares variable from stock split isn't evaluated in currency
       s0.setValue(MyMoneyMoney(s0.value().convertDenominator(currencyFraction, roundingMethod)));
     }
     t.addSplit(s0);
   }
 
   return rc;
 }
 
 void InvestTransactionEditor::setupFinalWidgets()
 {
   addFinalWidget(haveWidget("memo"));
 }
 
 void InvestTransactionEditor::slotUpdateInvestMemoState()
 {
   Q_D(InvestTransactionEditor);
   auto memo = dynamic_cast<KTextEdit*>(d->m_editWidgets["memo"]);
   if (memo) {
     d->m_activity->memoChanged() = (memo->toPlainText() != d->m_activity->memoText());
   }
 }
diff --git a/kmymoney/kcreditswindow.cpp b/kmymoney/kcreditswindow.cpp
index 18e1dceff..f52311a60 100644
--- a/kmymoney/kcreditswindow.cpp
+++ b/kmymoney/kcreditswindow.cpp
@@ -1,80 +1,80 @@
 /***************************************************************************
                           kcreditswindow.cpp
                              -------------------
     copyright            : (C) 2000 by Michael Edwardes <mte@users.sourceforge.net>
                            (C) 2007 by Thomas Baumgart <ipwizard@users.sourceforge.net>
                            (C) 2017 by Łukasz Wojniłowicz <lukasz.wojnilowicz@gmail.com>
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kcreditswindow.h"
 #include <config-kmymoney.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 
 KAboutData initializeCreditsData()
 {
   KAboutData aboutData(KAboutData::applicationData());
   if (!aboutData.homepage().isEmpty())
     return aboutData;
   QStringList features;
 #ifdef ENABLE_GPG
   features << i18n("GPG encryption");
 #endif
 #ifdef ENABLE_ADDRESSBOOK
   features << i18n("Addressbook integration");
 #endif
 #ifdef ENABLE_HOLIDAYS
   features << i18n("Holiday regions integration");
 #endif
 
   aboutData.setShortDescription(i18n("\nKMyMoney, the Personal Finance Manager by KDE.\n\nPlease consider contributing to this project with code and/or suggestions."));
   aboutData.setLicense(KAboutLicense::GPL);
-  aboutData.setCopyrightStatement(i18n("(c) 2000-2018 The KMyMoney development team"));
+  aboutData.setCopyrightStatement(i18n("(c) 2000-2019 The KMyMoney development team"));
   aboutData.setHomepage(QStringLiteral("https://kmymoney.org/"));
   if (!features.empty())
     aboutData.setOtherText(i18n("Compiled with the following optional features:\n%1", features.join(QLatin1Char('\n'))));
 
   aboutData.addAuthor(i18n("Thomas Baumgart"),    i18n("Core engine, Release Manager, Project admin"), "ipwizard@users.sourceforge.net");
   aboutData.addAuthor(i18n("Łukasz Wojniłowicz"), i18n("Developer"), "lukasz.wojnilowicz@gmail.com");
   aboutData.addAuthor(i18n("Ralf Habacker"),      i18n("Developer"), "ralf.habacker@freenet.de");
   aboutData.addAuthor(i18n("Cristian Oneț"),      i18n("Developer"), "onet.cristian@gmail.com");
   aboutData.addAuthor(i18n("Christian Dávid"),    i18n("Developer"), "christian-david@web.de");
 
   aboutData.addAuthor(i18n("Michael Edwardes"), i18n("Inactive member. ") + i18n("Initial idea, much initial source code, Project admin"), "mte@users.sourceforge.net");
   aboutData.addAuthor(i18n("Alvaro Soliverez"), i18n("Inactive member. ") + i18n("Forecast, Reports"), "asoliverez@gmail.com");
   aboutData.addAuthor(i18n("Ace Jones"),        i18n("Inactive member. ") + i18n("Reporting logic, OFX Import"), "acejones@users.sourceforge.net");
   aboutData.addAuthor(i18n("Tony Bloomfield"),  i18n("Inactive member. ") + i18n("Database backend, maintainer stable branch"), "tonybloom@users.sourceforge.net");
   aboutData.addAuthor(i18n("Felix Rodriguez"),  i18n("Inactive member. ") + i18n("Project Admin"), "frodriguez@users.sourceforge.net");
   aboutData.addAuthor(i18n("John C"),           i18n("Inactive member. ") + i18n("Developer"), "tacoturtle@users.sourceforge.net");
   aboutData.addAuthor(i18n("Fernando Vilas"),   i18n("Inactive member. ") + i18n("Database backend"), "fvilas@iname.com");
 
   aboutData.addCredit(i18n("Jack Ostroff"),           i18n("Documentation and user support"), "ostroffjh@users.sourceforge.net");
   aboutData.addCredit(i18n("Kevin Tambascio"),        i18n("Initial investment support"), "ktambascio@users.sourceforge.net");
   aboutData.addCredit(i18n("Javier Campos Morales"),  i18n("Developer & Artist"), "javi_c@users.sourceforge.net");
   aboutData.addCredit(i18n("Robert Wadley"),          i18n("Icons & splash screen"), "rob@robntina.fastmail.us");
   aboutData.addCredit(i18n("Laurent Montel"),         i18n("Patches and port to kde4"), "montel@kde.org");
   aboutData.addCredit(i18n("Wolfgang Rohdewald"),     i18n("Patches"), "woro@users.sourceforge.net");
   aboutData.addCredit(i18n("Marko Käning"),           i18n("Patches, packaging and KF5-CI for OS X"), "mk-lists@email.de");
   aboutData.addCredit(i18n("Allan Anderson ✝"),       i18n("CSV import/export"), QString());
   return aboutData;
 }
diff --git a/kmymoney/mymoney/mymoneysecurity.h b/kmymoney/mymoney/mymoneysecurity.h
index 139ab68bb..594f9154a 100644
--- a/kmymoney/mymoney/mymoneysecurity.h
+++ b/kmymoney/mymoney/mymoneysecurity.h
@@ -1,183 +1,183 @@
 /*
  * Copyright 2005-2017  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 MYMONEYSECURITY_H
 #define MYMONEYSECURITY_H
 
 #include "kmm_mymoney_export.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QMetaType>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <alkimia/alkvalue.h>
 #include "mymoneyobject.h"
 #include "mymoneykeyvaluecontainer.h"
 
 class QString;
 
 namespace eMyMoney { namespace Security { enum class Type; } }
 
 /**
   * Class that holds all the required information about a security that the user
   * has entered information about. A security can be a stock, a mutual fund, a bond
   * or a currency.
   *
   * @author Kevin Tambascio
   * @author Thomas Baumgart
   * @author Łukasz Wojniłowicz
   */
 
 class MyMoneySecurityPrivate;
 class KMM_MYMONEY_EXPORT MyMoneySecurity : public MyMoneyObject, public MyMoneyKeyValueContainer
 {
   Q_DECLARE_PRIVATE_D(MyMoneyObject::d_ptr, MyMoneySecurity)
 
   KMM_MYMONEY_UNIT_TESTABLE
 
 public:
   MyMoneySecurity();
   explicit MyMoneySecurity(const QString &id);
 
   explicit MyMoneySecurity(const QString& id,
                            const QString& name,
                            const QString& symbol = QString(),
                            const int smallestCashFraction = 100,
-                           const int smallestAccountFraction = 100,
+                           const int smallestAccountFraction = 0,
                            const int pricePrecision = 4);
 
   MyMoneySecurity(const QString& id,
                   const MyMoneySecurity& other);
 
   MyMoneySecurity(const MyMoneySecurity & other);
   MyMoneySecurity(MyMoneySecurity && other);
   MyMoneySecurity & operator=(MyMoneySecurity other);
   friend void swap(MyMoneySecurity& first, MyMoneySecurity& second);
 
   ~MyMoneySecurity();
 
   bool operator < (const MyMoneySecurity&) const;
 
   /**
     * This operator tests for equality of two MyMoneySecurity objects
     */
   bool operator == (const MyMoneySecurity&) const;
 
   /**
     * This operator tests for inequality of this MyMoneySecurity object
     * and the one passed by @p r
     *
     * @param r the right side of the comparison
     */
   bool operator != (const MyMoneySecurity& r) const;
 
   QString name() const;
   void setName(const QString& str);
 
   QString tradingSymbol() const;
   void setTradingSymbol(const QString& str);
 
   eMyMoney::Security::Type securityType() const;
   void setSecurityType(const eMyMoney::Security::Type s);
 
   bool isCurrency() const;
 
   AlkValue::RoundingMethod roundingMethod() const;
   void setRoundingMethod(const AlkValue::RoundingMethod rnd);
 
   QString tradingMarket() const;
   void setTradingMarket(const QString& str);
 
   QString tradingCurrency() const;
   void setTradingCurrency(const QString& str);
 
   int smallestAccountFraction() const;
   void setSmallestAccountFraction(const int sf);
 
   int smallestCashFraction() const;
   void setSmallestCashFraction(const int cf);
 
   int pricePrecision() const;
   void setPricePrecision(const int pp);
 
   /**
    * This method checks if a reference to the given object exists. It returns,
    * a @p true if the object is referencing the one requested by the
    * parameter @p id. If it does not, this method returns @p false.
    *
    * @param id id of the object to be checked for references
    * @retval true This object references object with id @p id.
    * @retval false This object does not reference the object with id @p id.
    */
   bool hasReferenceTo(const QString& id) const override;
 
   /**
    * This method is used to convert the internal representation of
    * an security type into a human readable format
    *
    * @param securityType enumerated representation of the security type.
    *                     For possible values, see MyMoneySecurity::eSECURITYTYPE
    *
    * @return QString representing the human readable form
    */
   static QString securityTypeToString(const eMyMoney::Security::Type securityType);
 
   /**
    * This method is used to convert the internal representation of
    * an rounding method into a human readable format
    *
    * @param roundingMethod enumerated representation of the rouding method.
    *                     For possible values, see AlkValue::RoundingMethod
    *
    * @return QString representing the human readable form
    */
   static QString roundingMethodToString(const AlkValue::RoundingMethod roundingMethod);
 };
 
 inline void swap(MyMoneySecurity& first, MyMoneySecurity& second) // krazy:exclude=inline
 {
   using std::swap;
   swap(first.MyMoneyObject::d_ptr, second.MyMoneyObject::d_ptr);
   swap(first.MyMoneyKeyValueContainer::d_ptr, second.MyMoneyKeyValueContainer::d_ptr);
 }
 
 inline MyMoneySecurity::MyMoneySecurity(MyMoneySecurity && other) : MyMoneySecurity() // krazy:exclude=inline
 {
   swap(*this, other);
 }
 
 inline MyMoneySecurity & MyMoneySecurity::operator=(MyMoneySecurity other) // krazy:exclude=inline
 {
   swap(*this, other);
   return *this;
 }
 
 
 /**
   * Make it possible to hold @ref MyMoneySecurity objects inside @ref QVariant objects.
   */
 Q_DECLARE_METATYPE(MyMoneySecurity)
 
 #endif
diff --git a/kmymoney/plugins/views/reports/core/querytable.cpp b/kmymoney/plugins/views/reports/core/querytable.cpp
index 377c7a59f..775461b48 100644
--- a/kmymoney/plugins/views/reports/core/querytable.cpp
+++ b/kmymoney/plugins/views/reports/core/querytable.cpp
@@ -1,1972 +1,1975 @@
 /*
  * Copyright 2005       Ace Jones <acejones@users.sourceforge.net>
  * 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 "querytable.h"
 
 #include <cmath>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QList>
 #include <QDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KLocalizedString>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "cashflowlist.h"
 #include "mymoneyfile.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyprice.h"
 #include "mymoneypayee.h"
 #include "mymoneytag.h"
 #include "mymoneysplit.h"
 #include "mymoneytransaction.h"
 #include "mymoneyreport.h"
 #include "mymoneyexception.h"
 #include "kmymoneyutils.h"
 #include "reportaccount.h"
 #include "mymoneyenums.h"
 
 namespace reports
 {
 
 // ****************************************************************************
 //
 // QueryTable implementation
 //
 // ****************************************************************************
 
 /**
   * TODO
   *
   * - Collapse 2- & 3- groups when they are identical
   * - Way more test cases (especially splits & transfers)
   * - Option to collapse splits
   * - Option to exclude transfers
   *
   */
 
 QueryTable::QueryTable(const MyMoneyReport& _report): ListTable(_report)
 {
   // separated into its own method to allow debugging (setting breakpoints
   // directly in ctors somehow does not work for me (ipwizard))
   // TODO: remove the init() method and move the code back to the ctor
   init();
 }
 
 void QueryTable::init()
 {
   m_columns.clear();
   m_group.clear();
   m_subtotal.clear();
   m_postcolumns.clear();
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::AccountByTopAccount:
     case eMyMoney::Report::RowType::EquityType:
     case eMyMoney::Report::RowType::AccountType:
     case eMyMoney::Report::RowType::Institution:
       constructAccountTable();
       m_columns << ctAccount;
       break;
 
     case eMyMoney::Report::RowType::Account:
       constructTransactionTable();
       m_columns << ctAccountID << ctPostDate;
       break;
 
     case eMyMoney::Report::RowType::Payee:
     case eMyMoney::Report::RowType::Tag:
     case eMyMoney::Report::RowType::Month:
     case eMyMoney::Report::RowType::Week:
       constructTransactionTable();
       m_columns << ctPostDate << ctAccount;
       break;
     case eMyMoney::Report::RowType::CashFlow:
       constructSplitsTable();
       m_columns << ctPostDate;
       break;
     default:
       constructTransactionTable();
       m_columns << ctPostDate;
   }
 
   // Sort the data to match the report definition
   m_subtotal << ctValue;
 
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::CashFlow:
       m_group << ctCategoryType << ctTopCategory << ctCategory;
       break;
     case eMyMoney::Report::RowType::Category:
       m_group << ctCategoryType << ctTopCategory << ctCategory;
       break;
     case eMyMoney::Report::RowType::TopCategory:
       m_group << ctCategoryType << ctTopCategory;
       break;
     case eMyMoney::Report::RowType::TopAccount:
       m_group << ctTopAccount << ctAccount;
       break;
     case eMyMoney::Report::RowType::Account:
       m_group << ctAccount;
       break;
     case eMyMoney::Report::RowType::AccountReconcile:
       m_group << ctAccount << ctReconcileFlag;
       break;
     case eMyMoney::Report::RowType::Payee:
       m_group << ctPayee;
       break;
     case eMyMoney::Report::RowType::Tag:
       m_group << ctTag;
       break;
     case eMyMoney::Report::RowType::Month:
       m_group << ctMonth;
       break;
     case eMyMoney::Report::RowType::Week:
       m_group << ctWeek;
       break;
     case eMyMoney::Report::RowType::AccountByTopAccount:
       m_group << ctTopAccount;
       break;
     case eMyMoney::Report::RowType::EquityType:
       m_group << ctEquityType;
       break;
     case eMyMoney::Report::RowType::AccountType:
       m_group << ctType;
       break;
     case eMyMoney::Report::RowType::Institution:
       m_group << ctInstitution << ctTopAccount;
       break;
     default:
       throw MYMONEYEXCEPTION_CSTRING("QueryTable::QueryTable(): unhandled row type");
   }
 
   QVector<cellTypeE> sort = QVector<cellTypeE>::fromList(m_group) << QVector<cellTypeE>::fromList(m_columns) << ctID << ctRank;
 
   m_columns.clear();
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::AccountByTopAccount:
     case eMyMoney::Report::RowType::EquityType:
     case eMyMoney::Report::RowType::AccountType:
     case eMyMoney::Report::RowType::Institution:
       m_columns << ctAccount;
       break;
 
     default:
       m_columns << ctPostDate;
   }
 
   unsigned qc = m_config.queryColumns();
 
   if (qc & eMyMoney::Report::QueryColumn::Number)
     m_columns << ctNumber;
   if (qc & eMyMoney::Report::QueryColumn::Payee)
     m_columns << ctPayee;
   if (qc & eMyMoney::Report::QueryColumn::Tag)
     m_columns << ctTag;
   if (qc & eMyMoney::Report::QueryColumn::Category)
     m_columns << ctCategory;
   if (qc & eMyMoney::Report::QueryColumn::Account)
     m_columns << ctAccount;
   if (qc & eMyMoney::Report::QueryColumn::Reconciled)
     m_columns << ctReconcileFlag;
   if (qc & eMyMoney::Report::QueryColumn::Memo)
     m_columns << ctMemo;
   if (qc & eMyMoney::Report::QueryColumn::Action)
     m_columns << ctAction;
   if (qc & eMyMoney::Report::QueryColumn::Shares)
     m_columns << ctShares;
   if (qc & eMyMoney::Report::QueryColumn::Price)
     m_columns << ctPrice;
   if (qc & eMyMoney::Report::QueryColumn::Performance) {
     m_subtotal.clear();
     switch (m_config.investmentSum()) {
       case eMyMoney::Report::InvestmentSum::OwnedAndSold:
         m_columns << ctBuys << ctSells << ctReinvestIncome << ctCashIncome
                   << ctEndingBalance << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctSells << ctReinvestIncome << ctCashIncome
                    << ctEndingBalance << ctReturn << ctReturnInvestment;
         break;
       case eMyMoney::Report::InvestmentSum::Owned:
         m_columns << ctBuys << ctReinvestIncome << ctMarketValue
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctReinvestIncome << ctMarketValue
                    << ctReturn << ctReturnInvestment;
         break;
       case eMyMoney::Report::InvestmentSum::Sold:
         m_columns << ctBuys << ctSells << ctCashIncome
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctBuys << ctSells << ctCashIncome
                    << ctReturn << ctReturnInvestment;
         break;
       case eMyMoney::Report::InvestmentSum::Period:
       default:
         m_columns << ctStartingBalance << ctBuys << ctSells
                   << ctReinvestIncome << ctCashIncome << ctEndingBalance
                   << ctReturn << ctReturnInvestment;
         m_subtotal << ctStartingBalance << ctBuys << ctSells
                    << ctReinvestIncome << ctCashIncome << ctEndingBalance
                    << ctReturn << ctReturnInvestment;
         break;
     }
   }
   if (qc & eMyMoney::Report::QueryColumn::CapitalGain) {
     m_subtotal.clear();
     switch (m_config.investmentSum()) {
       case eMyMoney::Report::InvestmentSum::Owned:
         m_columns << ctShares << ctBuyPrice << ctLastPrice
                   << ctBuys << ctMarketValue << ctPercentageGain
                   << ctCapitalGain;
         m_subtotal << ctShares << ctBuyPrice << ctLastPrice
                    << ctBuys << ctMarketValue << ctPercentageGain
                    << ctCapitalGain;
         break;
       case eMyMoney::Report::InvestmentSum::Sold:
       default:
         m_columns << ctBuys << ctSells << ctCapitalGain;
         m_subtotal << ctBuys << ctSells << ctCapitalGain;
         if (m_config.isShowingSTLTCapitalGains()) {
           m_columns << ctBuysST << ctSellsST << ctCapitalGainST
                     << ctBuysLT << ctSellsLT << ctCapitalGainLT;
           m_subtotal << ctBuysST << ctSellsST << ctCapitalGainST
                      << ctBuysLT << ctSellsLT << ctCapitalGainLT;
         }
         break;
     }
   }
   if (qc & eMyMoney::Report::QueryColumn::Loan) {
     m_columns << ctPayment << ctInterest << ctFees;
     m_postcolumns << ctBalance;
   }
   if (qc & eMyMoney::Report::QueryColumn::Balance)
     m_postcolumns << ctBalance;
 
   TableRow::setSortCriteria(sort);
   qSort(m_rows);
   if (m_config.isShowingColumnTotals())
     constructTotalRows(); // adds total rows to m_rows
 }
 
 void QueryTable::constructTotalRows()
 {
   if (m_rows.isEmpty())
     return;
 
   // qSort places grand total at last position, because it doesn't belong to any group
   for (int i = 0; i < m_rows.count(); ++i) {
     if (m_rows.at(0)[ctRank] == QLatin1String("4") || m_rows.at(0)[ctRank] == QLatin1String("5")) // it should be unlikely that total row is at the top of rows, so...
       m_rows.move(0, m_rows.count() - 1 - i);                       // ...move it at the bottom
     else
       break;
   }
 
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<cellTypeE> subtotals = m_subtotal;
   QList<cellTypeE> groups = m_group;
   QList<cellTypeE> columns = m_columns;
   if (!m_subtotal.isEmpty() && subtotals.count() == 1)
     columns.append(m_subtotal);
   QList<cellTypeE> postcolumns = m_postcolumns;
   if (!m_postcolumns.isEmpty())
     columns.append(postcolumns);
 
   QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>> totalCurrency;
   QList<QMap<cellTypeE, MyMoneyMoney>> totalGroups;
   QMap<cellTypeE, MyMoneyMoney> totalsValues;
 
   // initialize all total values under summed columns to be zero
   foreach (auto subtotal, subtotals) {
     totalsValues.insert(subtotal, MyMoneyMoney());
   }
   totalsValues.insert(ctRowsCount, MyMoneyMoney());
 
   // create total groups containing totals row for each group
   totalGroups.append(totalsValues);  // prepend with extra group for grand total
   for (int j = 0; j < groups.count(); ++j) {
     totalGroups.append(totalsValues);
   }
 
   QList<TableRow> stashedTotalRows;
   int iCurrentRow, iNextRow;
   for (iCurrentRow = 0; iCurrentRow < m_rows.count();) {
     iNextRow = iCurrentRow + 1;
 
     // total rows are useless at summing so remove whole block of them at once
     while (iNextRow != m_rows.count() && (m_rows.at(iNextRow).value(ctRank) == QLatin1String("4") || m_rows.at(iNextRow).value(ctRank) == QLatin1String("5"))) {
       stashedTotalRows.append(m_rows.takeAt(iNextRow)); // ...but stash them just in case
     }
 
     bool lastRow = (iNextRow == m_rows.count());
 
     // sum all subtotal values for lowest group
     QString currencyID = m_rows.at(iCurrentRow).value(ctCurrency);
     if (m_rows.at(iCurrentRow).value(ctRank) == QLatin1String("1")) { // don't sum up on balance (rank = 0 || rank = 3) and minor split (rank = 2)
       foreach (auto subtotal, subtotals) {
         if (!totalCurrency.contains(currencyID))
           totalCurrency[currencyID].append(totalGroups);
         totalCurrency[currencyID].last()[subtotal] += MyMoneyMoney(m_rows.at(iCurrentRow)[subtotal]);
       }
       totalCurrency[currencyID].last()[ctRowsCount] += MyMoneyMoney::ONE;
     }
 
     // iterate over groups from the lowest to the highest to find group change
     for (int i = groups.count() - 1; i >= 0 ; --i) {
       // if any of groups from next row changes (or next row is the last row), then it's time to put totals row
       if (lastRow || m_rows.at(iCurrentRow)[groups.at(i)] != m_rows.at(iNextRow)[groups.at(i)]) {
         bool isMainCurrencyTotal = true;
         QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>>::iterator currencyGrp = totalCurrency.begin();
         while (currencyGrp != totalCurrency.end()) {
           if (!MyMoneyMoney((*currencyGrp).at(i + 1).value(ctRowsCount)).isZero()) {    // if no rows summed up, then no totals row
             TableRow totalsRow;
             // sum all subtotal values for higher groups (excluding grand total) and reset lowest group values
             QMap<cellTypeE, MyMoneyMoney>::iterator upperGrp = (*currencyGrp)[i].begin();
             QMap<cellTypeE, MyMoneyMoney>::iterator lowerGrp = (*currencyGrp)[i + 1].begin();
 
             while(upperGrp != (*currencyGrp)[i].end()) {
               totalsRow[lowerGrp.key()] = lowerGrp.value().toString();  // fill totals row with subtotal values...
               (*upperGrp) += (*lowerGrp);
               //          (*lowerGrp) = MyMoneyMoney();
               ++upperGrp;
               ++lowerGrp;
             }
 
             // custom total values calculations
             foreach (auto subtotal, subtotals) {
               if (subtotal == ctReturnInvestment)
                 totalsRow[subtotal] = helperROI((*currencyGrp).at(i + 1).value(ctBuys) - (*currencyGrp).at(i + 1).value(ctReinvestIncome), (*currencyGrp).at(i + 1).value(ctSells),
                                                 (*currencyGrp).at(i + 1).value(ctStartingBalance), (*currencyGrp).at(i + 1).value(ctEndingBalance) + (*currencyGrp).at(i + 1).value(ctMarketValue),
                                                 (*currencyGrp).at(i + 1).value(ctCashIncome));
-              else if (subtotal == ctPercentageGain)
-                totalsRow[subtotal] = (((*currencyGrp).at(i + 1).value(ctBuys) + (*currencyGrp).at(i + 1).value(ctMarketValue)) / (*currencyGrp).at(i + 1).value(ctBuys).abs()).toString();
-              else if (subtotal == ctPrice)
+              else if (subtotal == ctPercentageGain) {
+                const MyMoneyMoney denominator = (*currencyGrp).at(i + 1).value(ctBuys).abs();
+                totalsRow[subtotal] = denominator.isZero() ? QString():
+                    (((*currencyGrp).at(i + 1).value(ctBuys) + (*currencyGrp).at(i + 1).value(ctMarketValue)) / denominator).toString();
+              } else if (subtotal == ctPrice)
                 totalsRow[subtotal] = MyMoneyMoney((*currencyGrp).at(i + 1).value(ctPrice) / (*currencyGrp).at(i + 1).value(ctRowsCount)).toString();
             }
 
             // total values that aren't calculated here, but are taken untouched from external source, e.g. constructPerformanceRow
             if (!stashedTotalRows.isEmpty()) {
               for (int j = 0; j < stashedTotalRows.count(); ++j) {
                 if (stashedTotalRows.at(j).value(ctCurrency) != currencyID)
                   continue;
                 foreach (auto subtotal, subtotals) {
                   if (subtotal == ctReturn)
                     totalsRow[ctReturn] = stashedTotalRows.takeAt(j)[ctReturn];
                 }
                 break;
               }
             }
 
             (*currencyGrp).replace(i + 1, totalsValues);
             for (int j = 0; j < groups.count(); ++j) {
               totalsRow[groups.at(j)] = m_rows.at(iCurrentRow)[groups.at(j)];   // ...and identification
             }
 
             currencyID = currencyGrp.key();
             if (currencyID.isEmpty() && totalCurrency.count() > 1)
               currencyID = file->baseCurrency().id();
             totalsRow[ctCurrency] = currencyID;
             if (isMainCurrencyTotal) {
               totalsRow[ctRank] = QLatin1Char('4');
               isMainCurrencyTotal = false;
             } else
               totalsRow[ctRank] = QLatin1Char('5');
             totalsRow[ctDepth] = QString::number(i);
             totalsRow.remove(ctRowsCount);
 
             m_rows.insert(iNextRow++, totalsRow);  // iCurrentRow and iNextRow can diverge here by more than one
           }
           ++currencyGrp;
         }
       }
     }
 
     // code to put grand total row
     if (lastRow) {
       bool isMainCurrencyTotal = true;
       QMap<QString, QList<QMap<cellTypeE, MyMoneyMoney>>>::iterator currencyGrp = totalCurrency.begin();
       while (currencyGrp != totalCurrency.end()) {
         TableRow totalsRow;
         QMap<cellTypeE, MyMoneyMoney>::const_iterator grandTotalGrp = (*currencyGrp)[0].constBegin();
         while(grandTotalGrp != (*currencyGrp)[0].constEnd()) {
           totalsRow[grandTotalGrp.key()] = grandTotalGrp.value().toString();
           ++grandTotalGrp;
         }
 
         foreach (auto subtotal, subtotals) {
           if (subtotal == ctReturnInvestment)
             totalsRow[subtotal] = helperROI((*currencyGrp).at(0).value(ctBuys) - (*currencyGrp).at(0).value(ctReinvestIncome), (*currencyGrp).at(0).value(ctSells),
                                             (*currencyGrp).at(0).value(ctStartingBalance), (*currencyGrp).at(0).value(ctEndingBalance) + (*currencyGrp).at(0).value(ctMarketValue),
                                             (*currencyGrp).at(0).value(ctCashIncome));
           else if (subtotal == ctPercentageGain)
             totalsRow[subtotal] = (((*currencyGrp).at(0).value(ctBuys) + (*currencyGrp).at(0).value(ctMarketValue)) / (*currencyGrp).at(0).value(ctBuys).abs()).toString();
           else if (subtotal == ctPrice)
             totalsRow[subtotal] = MyMoneyMoney((*currencyGrp).at(0).value(ctPrice) / (*currencyGrp).at(0).value(ctRowsCount)).toString();
         }
 
         if (!stashedTotalRows.isEmpty()) {
           for (int j = 0; j < stashedTotalRows.count(); ++j) {
             foreach (auto subtotal, subtotals) {
               if (subtotal == ctReturn)
                 totalsRow[ctReturn] = stashedTotalRows.takeAt(j)[ctReturn];
             }
           }
         }
 
         for (int j = 0; j < groups.count(); ++j) {
           totalsRow[groups.at(j)] = QString();      // no identification
         }
 
         currencyID = currencyGrp.key();
         if (currencyID.isEmpty() && totalCurrency.count() > 1)
           currencyID = file->baseCurrency().id();
         totalsRow[ctCurrency] = currencyID;
         if (isMainCurrencyTotal) {
           totalsRow[ctRank] = QLatin1Char('4');
           isMainCurrencyTotal = false;
         } else
           totalsRow[ctRank] = QLatin1Char('5');
         totalsRow[ctDepth] = QString();
 
         m_rows.append(totalsRow);
         ++currencyGrp;
       }
       break;                                      // no use to loop further
     }
     iCurrentRow = iNextRow;                             // iCurrent makes here a leap forward by at least one
   }
 }
 
 void QueryTable::constructTransactionTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   MyMoneyReport report(m_config);
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
 
   bool use_transfers;
   bool use_summary;
   bool hide_details;
   bool tag_special_case = false;
 
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::Category:
     case eMyMoney::Report::RowType::TopCategory:
       use_summary = false;
       use_transfers = false;
       hide_details = false;
       break;
     case eMyMoney::Report::RowType::Payee:
       use_summary = false;
       use_transfers = false;
       hide_details = (m_config.detailLevel() == eMyMoney::Report::DetailLevel::None);
       break;
     case eMyMoney::Report::RowType::Tag:
       use_summary = false;
       use_transfers = false;
       hide_details = (m_config.detailLevel() == eMyMoney::Report::DetailLevel::None);
       tag_special_case = true;
       break;
     default:
       use_summary = true;
       use_transfers = true;
       hide_details = (m_config.detailLevel() == eMyMoney::Report::DetailLevel::None);
       break;
   }
 
   // support for opening and closing balances
   QMap<QString, MyMoneyAccount> accts;
 
   //get all transactions for this report
   QList<MyMoneyTransaction> transactions = file->transactionList(report);
   for (QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin(); it_transaction != transactions.constEnd(); ++it_transaction) {
 
     TableRow qA, qS;
     QDate pd;
     QList<QString> tagIdListCache;
 
     qA[ctID] = qS[ctID] = (* it_transaction).id();
     qA[ctEntryDate] = qS[ctEntryDate] = (* it_transaction).entryDate().toString(Qt::ISODate);
     qA[ctPostDate] = qS[ctPostDate] = (* it_transaction).postDate().toString(Qt::ISODate);
     qA[ctCommodity] = qS[ctCommodity] = (* it_transaction).commodity();
 
     pd = (* it_transaction).postDate();
     qA[ctMonth] = qS[ctMonth] = i18n("Month of %1", QDate(pd.year(), pd.month(), 1).toString(Qt::ISODate));
     qA[ctWeek] = qS[ctWeek] = i18n("Week of %1", pd.addDays(1 - pd.dayOfWeek()).toString(Qt::ISODate));
 
     if (!m_containsNonBaseCurrency && (*it_transaction).commodity() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (report.isConvertCurrency())
       qA[ctCurrency] = qS[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = qS[ctCurrency] = (*it_transaction).commodity();
 
     // to handle splits, we decide on which account to base the split
     // (a reference point or point of view so to speak). here we take the
     // first account that is a stock account or loan account (or the first account
     // that is not an income or expense account if there is no stock or loan account)
     // to be the account (qA) that will have the sub-item "split" entries. we add
     // one transaction entry (qS) for each subsequent entry in the split.
 
     const QList<MyMoneySplit>& splits = (*it_transaction).splits();
     QList<MyMoneySplit>::const_iterator myBegin, it_split;
 
     for (it_split = splits.constBegin(), myBegin = splits.constEnd(); it_split != splits.constEnd(); ++it_split) {
       ReportAccount splitAcc((* it_split).accountId());
       // always put split with a "stock" account if it exists
       if (splitAcc.isInvest())
         break;
 
       // prefer to put splits with a "loan" account if it exists
       if (splitAcc.isLoan())
         myBegin = it_split;
 
       if ((myBegin == splits.end()) && ! splitAcc.isIncomeExpense()) {
         myBegin = it_split;
       }
     }
 
     // select our "reference" split
     if (it_split == splits.end()) {
       it_split = myBegin;
     } else {
       myBegin = it_split;
     }
 
     // skip this transaction if we didn't find a valid base account - see the above description
     // for the base account's description - if we don't find it avoid a crash by skipping the transaction
     if (myBegin == splits.end())
       continue;
 
     // if the split is still unknown, use the first one. I have seen this
     // happen with a transaction that has only a single split referencing an income or expense
     // account and has an amount and value of 0. Such a transaction will fall through
     // the above logic and leave 'it_split' pointing to splits.end() which causes the remainder
     // of this to end in an infinite loop.
     if (it_split == splits.end()) {
       it_split = splits.begin();
     }
 
     // for "loan" reports, the loan transaction gets special treatment.
     // the splits of a loan transaction are placed on one line in the
     // reference (loan) account (qA). however, we process the matching
     // split entries (qS) normally.
 
     bool loan_special_case = false;
     if (m_config.queryColumns() & eMyMoney::Report::QueryColumn::Loan) {
       ReportAccount splitAcc((*it_split).accountId());
       loan_special_case = splitAcc.isLoan();
     }
 
     bool include_me = true;
     bool transaction_text = false; //indicates whether a text should be considered as a match for the transaction or for a split only
     QString a_fullname;
     QString a_memo;
     int pass = 1;
 
     QString myBeginCurrency;
     QString baseCurrency = file->baseCurrency().id();
 
     QMap<QString, MyMoneyMoney> xrMap; // container for conversion rates from given currency to myBeginCurrency
     do {
       MyMoneyMoney xr;
       ReportAccount splitAcc((* it_split).accountId());
       QString splitCurrency;
       if (splitAcc.isInvest())
         splitCurrency = file->account(file->account((*it_split).accountId()).parentAccountId()).currencyId();
       else
         splitCurrency = file->account((*it_split).accountId()).currencyId();
       if (it_split == myBegin)
         myBeginCurrency = splitCurrency;
 
       //get fraction for account
       int fraction = splitAcc.currency().smallestAccountFraction();
 
       //use base currency fraction if not initialized
       if (fraction == -1)
         fraction = file->baseCurrency().smallestAccountFraction();
 
       QString institution = splitAcc.institutionId();
       QString payee = (*it_split).payeeId();
 
       const QList<QString> tagIdList = (*it_split).tagIdList();
 
       //convert to base currency
       if (m_config.isConvertCurrency()) {
         xr = xrMap.value(splitCurrency, xr);  // check if there is conversion rate to myBeginCurrency already stored...
         if (xr == MyMoneyMoney())             // ...if not...
             xr = (*it_split).price();         // ...take conversion rate to myBeginCurrency from split
         else if (splitAcc.isInvest())         // if it's stock split...
           xr *= (*it_split).price();          // ...multiply it by stock price stored in split
 
         if (!m_containsNonBaseCurrency && myBeginCurrency != baseCurrency)
           m_containsNonBaseCurrency = true;
         if (myBeginCurrency != baseCurrency) {                             // myBeginCurrency can differ from baseCurrency...
           MyMoneyPrice price = file->price(myBeginCurrency, baseCurrency,
                                            (*it_transaction).postDate());  // ...so check conversion rate...
           if (price.isValid()) {
             xr *= price.rate(baseCurrency);                                // ...and multiply it by current price...
             qA[ctCurrency] = qS[ctCurrency] = baseCurrency;
           } else
             qA[ctCurrency] = qS[ctCurrency] = myBeginCurrency;             // ...and set information about non-baseCurrency
         }
       } else if (splitAcc.isInvest())
         xr = (*it_split).price();
       else
         xr = MyMoneyMoney::ONE;
 
       if (it_split == myBegin) {
         include_me = m_config.includes(splitAcc);
         if (include_me)
           // track accts that will need opening and closing balances
           //FIXME in some cases it will show the opening and closing
           //balances but no transactions if the splits are all filtered out -- asoliverez
           accts.insert(splitAcc.id(), splitAcc);
 
         qA[ctAccount] = splitAcc.name();
         qA[ctAccountID] = splitAcc.id();
         qA[ctTopAccount] = splitAcc.topParentName();
 
         if (splitAcc.isInvest()) {
           // use the institution of the parent for stock accounts
           institution = splitAcc.parent().institutionId();
           MyMoneyMoney shares = (*it_split).shares();
 
           int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
           qA[ctAction] = (*it_split).action();
           qA[ctShares] = shares.isZero() ? QString() : shares.toString();
           qA[ctPrice] = shares.isZero() ? QString() : xr.convertPrecision(pricePrecision).toString();
 
           if (((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) && shares.isNegative())
             qA[ctAction] = "Sell";
 
           qA[ctInvestAccount] = splitAcc.parent().name();
 
           MyMoneySplit stockSplit = (*it_split);
           MyMoneySplit assetAccountSplit;
           QList<MyMoneySplit> feeSplits;
           QList<MyMoneySplit> interestSplits;
           MyMoneySecurity currency;
           MyMoneySecurity security;
           eMyMoney::Split::InvestmentTransactionType transactionType;
           KMyMoneyUtils::dissectTransaction((*it_transaction), stockSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
           if (!(assetAccountSplit == MyMoneySplit())) {
             for (it_split = splits.begin(); it_split != splits.end(); ++it_split) {
               if ((*it_split) == assetAccountSplit) {
                 splitAcc = ReportAccount(assetAccountSplit.accountId()); // switch over from stock split to asset split because amount in stock split doesn't take fees/interests into account
                 myBegin = it_split;                       // set myBegin to asset split, so stock split can be listed in details under splits
                 myBeginCurrency = (file->account((*myBegin).accountId())).currencyId();
                 if (!m_containsNonBaseCurrency && myBeginCurrency != baseCurrency)
                   m_containsNonBaseCurrency = true;
                 if (m_config.isConvertCurrency()) {
                   if (myBeginCurrency != baseCurrency) {
                     MyMoneyPrice price = file->price(myBeginCurrency, baseCurrency, (*it_transaction).postDate());
                     if (price.isValid()) {
                       xr = price.rate(baseCurrency);
                       qA[ctCurrency] = qS[ctCurrency] = baseCurrency;
                     } else
                       qA[ctCurrency] = qS[ctCurrency] = myBeginCurrency;
                   } else
                     xr = MyMoneyMoney::ONE;
 
                   qA[ctPrice] = shares.isZero() ? QString() : (stockSplit.price() * xr / (*it_split).price()).toString();
                   // put conversion rate for all splits with this currency, so...
                   // every split of transaction have the same conversion rate
                   xrMap.insert(splitCurrency, MyMoneyMoney::ONE / (*it_split).price());
                 } else
                   xr = (*it_split).price();
                 break;
               }
             }
           }
         } else
           qA[ctPrice] = xr.toString();
 
         a_fullname = splitAcc.fullName();
         a_memo = (*it_split).memo();
 
         transaction_text = m_config.match((*it_split));
 
         qA[ctInstitution] = institution.isEmpty()
                             ? i18n("No Institution")
                             : file->institution(institution).name();
 
         qA[ctPayee] = payee.isEmpty()
                       ? i18n("[Empty Payee]")
                       : file->payee(payee).name().simplified();
 
         if (tag_special_case) {
           tagIdListCache = tagIdList;
         } else {
           QString delimiter;
           foreach(const auto tagId, tagIdList) {
             qA[ctTag] += delimiter + file->tag(tagId).name().simplified();
             delimiter = QLatin1Char(',');
           }
         }
         qA[ctReconcileDate] = (*it_split).reconcileDate().toString(Qt::ISODate);
         qA[ctReconcileFlag] = KMyMoneyUtils::reconcileStateToString((*it_split).reconcileFlag(), true);
         qA[ctNumber] = (*it_split).number();
 
         qA[ctMemo] = a_memo;
 
         qA[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
 
         qS[ctReconcileDate] = qA[ctReconcileDate];
         qS[ctReconcileFlag] = qA[ctReconcileFlag];
         qS[ctNumber] = qA[ctNumber];
 
         qS[ctTopCategory] = splitAcc.topParentName();
         qS[ctCategoryType] = i18n("Transfer");
 
         // only include the configured accounts
         if (include_me) {
 
           if (loan_special_case) {
 
             // put the principal amount in the "value" column and convert to lowest fraction
             qA[ctValue] = (-(*it_split).shares() * xr).convert(fraction).toString();
 
             qA[ctRank] = QLatin1Char('1');
             qA[ctSplit].clear();
 
           } else {
             if ((splits.count() > 2) && use_summary) {
 
               // add the "summarized" split transaction
               // this is the sub-total of the split detail
               // convert to lowest fraction
               qA[ctRank] = QLatin1Char('1');
               qA[ctCategory] = i18n("[Split Transaction]");
               qA[ctTopCategory] = i18nc("Split transaction", "Split");
               qA[ctCategoryType] = i18nc("Split transaction", "Split");
 
               m_rows += qA;
             }
           }
         }
 
       } else {
 
         if (include_me) {
 
           if (loan_special_case) {
             MyMoneyMoney value = (-(* it_split).shares() * xr).convert(fraction);
 
             if ((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Amortization)) {
               // put the payment in the "payment" column and convert to lowest fraction
               qA[ctPayee] = value.toString();
             } else if ((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::Interest)) {
               // put the interest in the "interest" column and convert to lowest fraction
               qA[ctInterest] = value.toString();
             } else if (splits.count() > 2) {
               // [dv: This comment carried from the original code. I am
               // not exactly clear on what it means or why we do this.]
               // Put the initial pay-in nowhere (that is, ignore it). This
               // is dangerous, though. The only way I can tell the initial
               // pay-in apart from fees is if there are only 2 splits in
               // the transaction.  I wish there was a better way.
             } else {
               // accumulate everything else in the "fees" column
               MyMoneyMoney n0 = MyMoneyMoney(qA[ctFees]);
               qA[ctFees] = (n0 + value).toString();
             }
             // we don't add qA here for a loan transaction. we'll add one
             // qA after all of the split components have been processed.
             // (see below)
 
           }
 
           //--- special case to hide split transaction details
           else if (hide_details && (splits.count() > 2)) {
             // essentially, don't add any qA entries
           }
           //--- default case includes all transaction details
           else {
 
             //this is when the splits are going to be shown as children of the main split
             if ((splits.count() > 2) && use_summary) {
               qA[ctValue].clear();
 
               //convert to lowest fraction
               qA[ctSplit] = (-(*it_split).shares() * xr).convert(fraction).toString();
               qA[ctRank] = QLatin1Char('2');
             } else {
               //this applies when the transaction has only 2 splits, or each split is going to be
               //shown separately, eg. transactions by category
               switch (m_config.rowType()) {
                 case eMyMoney::Report::RowType::Category:
                 case eMyMoney::Report::RowType::TopCategory:
                   if (splitAcc.isIncomeExpense())
                     qA[ctValue] = (-(*it_split).shares() * xr).convert(fraction).toString(); // needed for category reports, in case of multicurrency transaction it breaks it
                   break;
                 default:
                   break;
               }
               qA[ctSplit].clear();
               qA[ctRank] = QLatin1Char('1');
             }
 
             qA [ctMemo] = (*it_split).memo();
 
             if (!m_containsNonBaseCurrency && splitAcc.currencyId() != file->baseCurrency().id())
               m_containsNonBaseCurrency = true;
             if (report.isConvertCurrency())
               qS[ctCurrency] = file->baseCurrency().id();
             else
               qS[ctCurrency] = splitAcc.currency().id();
 
             if (! splitAcc.isIncomeExpense()) {
               qA[ctCategory] = ((*it_split).shares().isNegative()) ?
                                i18n("Transfer from %1", splitAcc.fullName())
                                : i18n("Transfer to %1", splitAcc.fullName());
               qA[ctTopCategory] = splitAcc.topParentName();
               qA[ctCategoryType] = i18n("Transfer");
             } else {
               qA [ctCategory] = splitAcc.fullName();
               qA [ctTopCategory] = splitAcc.topParentName();
               qA [ctCategoryType] = MyMoneyAccount::accountTypeToString(splitAcc.accountGroup());
             }
 
             if (use_transfers || (splitAcc.isIncomeExpense() && m_config.includes(splitAcc))) {
               //if it matches the text of the main split of the transaction or
               //it matches this particular split, include it
               //otherwise, skip it
               //if the filter is "does not contain" exclude the split if it does not match
               //even it matches the whole split
               if ((m_config.isInvertingText() &&
                    m_config.match((*it_split)))
                   || (!m_config.isInvertingText()
                       && (transaction_text
                           || m_config.match((*it_split))))) {
                 if (tag_special_case) {
                   if (!tagIdListCache.size())
                     qA[ctTag] = i18n("[No Tag]");
                   else
                     for (int i = 0; i < tagIdListCache.size(); i++) {
                       qA[ctTag] = file->tag(tagIdListCache[i]).name().simplified();
                       m_rows += qA;
                     }
                 } else {
                   m_rows += qA;
                 }
               }
             }
           }
         }
 
         if (m_config.includes(splitAcc) && use_transfers &&
             !(splitAcc.isInvest() && include_me)) { // otherwise stock split is displayed twice in report
           if (! splitAcc.isIncomeExpense()) {
             //multiply by currency and convert to lowest fraction
             qS[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
 
             qS[ctRank] = QLatin1Char('1');
 
             qS[ctAccount] = splitAcc.name();
             qS[ctAccountID] = splitAcc.id();
             qS[ctTopAccount] = splitAcc.topParentName();
 
             qS[ctCategory] = ((*it_split).shares().isNegative())
                              ? i18n("Transfer to %1", a_fullname)
                              : i18n("Transfer from %1", a_fullname);
 
             qS[ctInstitution] = institution.isEmpty()
                                 ? i18n("No Institution")
                                 : file->institution(institution).name();
 
             qS[ctMemo] = (*it_split).memo().isEmpty()
                          ? a_memo
                          : (*it_split).memo();
 
             //FIXME-ALEX When is used this? I can't find in which condition we arrive here... maybe this code is useless?
             QString delimiter;
             for (int i = 0; i < tagIdList.size(); i++) {
               qA[ctTag] += delimiter + file->tag(tagIdList[i]).name().simplified();
               delimiter = '+';
             }
 
             qS[ctPayee] = payee.isEmpty()
                           ? qA[ctPayee]
                           : file->payee(payee).name().simplified();
 
             //check the specific split against the filter for text and amount
             //TODO this should be done at the engine, but I have no clear idea how -- asoliverez
             //if the filter is "does not contain" exclude the split if it does not match
             //even it matches the whole split
             if ((m_config.isInvertingText() &&
                  m_config.match((*it_split)))
                 || (!m_config.isInvertingText()
                     && (transaction_text
                         || m_config.match((*it_split))))) {
               m_rows += qS;
 
               // track accts that will need opening and closing balances
               accts.insert(splitAcc.id(), splitAcc);
             }
           }
         }
       }
 
       ++it_split;
 
       // look for wrap-around
       if (it_split == splits.end())
         it_split = splits.begin();
 
       // but terminate if this transaction has only a single split
       if (splits.count() < 2)
         break;
 
       //check if there have been more passes than there are splits
       //this is to prevent infinite loops in cases of data inconsistency -- asoliverez
       ++pass;
       if (pass > splits.count())
         break;
 
     } while (it_split != myBegin);
     if (loan_special_case) {
       m_rows += qA;
     }
   }
 
   // now run through our accts list and add opening and closing balances
 
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::Account:
     case eMyMoney::Report::RowType::TopAccount:
       break;
 
       // case eMyMoney::Report::RowType::Category:
       // case MyMoneyReport::eTopCategory:
       // case MyMoneyReport::ePayee:
       // case MyMoneyReport::eMonth:
       // case MyMoneyReport::eWeek:
     default:
       return;
   }
 
   QDate startDate, endDate;
 
   report.validDateRange(startDate, endDate);
   QString strStartDate = startDate.toString(Qt::ISODate);
   QString strEndDate = endDate.toString(Qt::ISODate);
   startDate = startDate.addDays(-1);
 
   for (auto it_account = accts.constBegin(); it_account != accts.constEnd(); ++it_account) {
     TableRow qA;
 
     ReportAccount account(*it_account);
 
     //get fraction for account
     int fraction = account.currency().smallestAccountFraction();
 
     //use base currency fraction if not initialized
     if (fraction == -1)
       fraction = file->baseCurrency().smallestAccountFraction();
 
     QString institution = account.institutionId();
 
     // use the institution of the parent for stock accounts
     if (account.isInvest())
       institution = account.parent().institutionId();
 
     MyMoneyMoney startBalance, endBalance, startPrice, endPrice;
     MyMoneyMoney startShares, endShares;
 
     //get price and convert currency if necessary
     if (m_config.isConvertCurrency()) {
       startPrice = (account.deepCurrencyPrice(startDate) * account.baseCurrencyPrice(startDate)).reduce();
       endPrice = (account.deepCurrencyPrice(endDate) * account.baseCurrencyPrice(endDate)).reduce();
     } else {
       startPrice = account.deepCurrencyPrice(startDate).reduce();
       endPrice = account.deepCurrencyPrice(endDate).reduce();
     }
     startShares = file->balance(account.id(), startDate);
     endShares = file->balance(account.id(), endDate);
 
     //get starting and ending balances
     startBalance = startShares * startPrice;
     endBalance = endShares * endPrice;
 
     //starting balance
     // don't show currency if we're converting or if it's not foreign
     if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (m_config.isConvertCurrency())
       qA[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = account.currency().id();
 
     qA[ctAccountID] = account.id();
     qA[ctAccount] = account.name();
     qA[ctTopAccount] = account.topParentName();
     qA[ctInstitution] = institution.isEmpty() ? i18n("No Institution") : file->institution(institution).name();
     qA[ctRank] = QLatin1Char('0');
 
     qA[ctPrice] = startPrice.convertPrecision(account.currency().pricePrecision()).toString();
     if (account.isInvest()) {
       qA[ctShares] = startShares.toString();
     }
 
     qA[ctPostDate] = strStartDate;
     qA[ctBalance] = startBalance.convert(fraction).toString();
     qA[ctValue].clear();
     qA[ctID] = QLatin1Char('A');
     m_rows += qA;
 
     //ending balance
     qA[ctPrice] = endPrice.convertPrecision(account.currency().pricePrecision()).toString();
 
     if (account.isInvest()) {
       qA[ctShares] = endShares.toString();
     }
 
     qA[ctPostDate] = strEndDate;
     qA[ctBalance] = endBalance.toString();
     qA[ctRank] = QLatin1Char('3');
     qA[ctID] = QLatin1Char('Z');
     m_rows += qA;
   }
 }
 
 QString QueryTable::helperROI(const MyMoneyMoney &buys, const MyMoneyMoney &sells, const MyMoneyMoney &startingBal, const MyMoneyMoney &endingBal, const MyMoneyMoney &cashIncome) const
 {
   MyMoneyMoney returnInvestment;
-  if (!buys.isZero() || !startingBal.isZero()) {
+  if (!(startingBal - buys).isZero()) {
     returnInvestment = (sells + buys + cashIncome + endingBal - startingBal) / (startingBal - buys);
     return returnInvestment.convert(10000).toString();
   } else
     return QString();
 }
 
 QString QueryTable::helperIRR(const CashFlowList &all) const
 {
   try {
     return MyMoneyMoney(all.XIRR(), 10000).toString();
   } catch (MyMoneyException &e) {
     qDebug() << e.what();
     all.dumpDebug();
     return QString();
   }
 }
 
 void QueryTable::sumInvestmentValues(const ReportAccount& account, QList<CashFlowList>& cfList, QList<MyMoneyMoney>& shList) const
 {
   for (int i = InvestmentValue::Buys; i < InvestmentValue::End; ++i)
     cfList.append(CashFlowList());
   for (int i = InvestmentValue::Buys; i <= InvestmentValue::BuysOfOwned; ++i)
     shList.append(MyMoneyMoney());
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   MyMoneyReport report = m_config;
   QDate startingDate;
   QDate endingDate;
   QDate newStartingDate;
   QDate newEndingDate;
   const bool isSTLT = report.isShowingSTLTCapitalGains();
   const int settlementPeriod = report.settlementPeriod();
   QDate termSeparator = report.termSeparator().addDays(-settlementPeriod);
   report.validDateRange(startingDate, endingDate);
   newStartingDate = startingDate;
   newEndingDate = endingDate;
 
   if (report.queryColumns() & eMyMoney::Report::QueryColumn::CapitalGain) {
     // Saturday and Sunday aren't valid settlement dates
     if (endingDate.dayOfWeek() == Qt::Saturday)
       endingDate = endingDate.addDays(-1);
     else if (endingDate.dayOfWeek() == Qt::Sunday)
       endingDate = endingDate.addDays(-2);
 
     if (termSeparator.dayOfWeek() == Qt::Saturday)
       termSeparator = termSeparator.addDays(-1);
     else if (termSeparator.dayOfWeek() == Qt::Sunday)
       termSeparator = termSeparator.addDays(-2);
     if (startingDate.daysTo(endingDate) <= settlementPeriod)        // no days to check for
       return;
     termSeparator = termSeparator.addDays(-settlementPeriod);
     newEndingDate = endingDate.addDays(-settlementPeriod);
   }
 
   shList[BuysOfOwned] = file->balance(account.id(), newEndingDate); // get how many shares there are at the end of period
   MyMoneyMoney stashedBuysOfOwned = shList.at(BuysOfOwned);
 
   bool reportedDateRange = true;  // flag marking sell transactions between startingDate and endingDate
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
   report.clearAccountFilter();
   report.addAccount(account.id());
   report.setDateFilter(newStartingDate, newEndingDate);
 
   do {
     QList<MyMoneyTransaction> transactions = file->transactionList(report);
     for (QList<MyMoneyTransaction>::const_reverse_iterator  it_t = transactions.crbegin(); it_t != transactions.crend(); ++it_t) {
       MyMoneySplit shareSplit = (*it_t).splitByAccount(account.id());
       MyMoneySplit assetAccountSplit;
       QList<MyMoneySplit> feeSplits;
       QList<MyMoneySplit> interestSplits;
       MyMoneySecurity security;
       MyMoneySecurity currency;
       eMyMoney::Split::InvestmentTransactionType transactionType;
       KMyMoneyUtils::dissectTransaction((*it_t), shareSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
       QDate postDate = (*it_t).postDate();
       MyMoneyMoney price;
       //get price for the day of the transaction if we have to calculate base currency
       //we are using the value of the split which is in deep currency
       if (m_config.isConvertCurrency())
         price = account.baseCurrencyPrice(postDate); //we only need base currency because the value is in deep currency
       else
         price = MyMoneyMoney::ONE;
       MyMoneyMoney value = assetAccountSplit.value() * price;
       MyMoneyMoney shares = shareSplit.shares();
 
       if (transactionType == eMyMoney::Split::InvestmentTransactionType::BuyShares) {
         if (reportedDateRange) {
           cfList[Buys].append(CashFlowListItem(postDate, value));
           shList[Buys] += shares;
         }
 
         if (shList.at(BuysOfOwned).isZero()) {                      // add sold shares
           if (shList.at(BuysOfSells) + shares > shList.at(Sells).abs()) { // add partially sold shares
             MyMoneyMoney tempVal = (((shList.at(Sells).abs() - shList.at(BuysOfSells))) / shares) * value;
             cfList[BuysOfSells].append(CashFlowListItem(postDate, tempVal));
             shList[BuysOfSells] = shList.at(Sells).abs();
             if (isSTLT && postDate < termSeparator) {
               cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, tempVal));
               shList[LongTermBuysOfSells] = shList.at(BuysOfSells);
             }
           } else {                                                  // add wholly sold shares
             cfList[BuysOfSells].append(CashFlowListItem(postDate, value));
             shList[BuysOfSells] += shares;
             if (isSTLT && postDate < termSeparator) {
               cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, value));
               shList[LongTermBuysOfSells] += shares;
             }
           }
         } else if (shList.at(BuysOfOwned) >= shares) {              // subtract not-sold shares
           shList[BuysOfOwned] -= shares;
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, value));
         } else {                                                    // subtract partially not-sold shares
           MyMoneyMoney tempVal = ((shares - shList.at(BuysOfOwned)) / shares) * value;
           MyMoneyMoney tempVal2 = (shares - shList.at(BuysOfOwned));
           cfList[BuysOfSells].append(CashFlowListItem(postDate, tempVal));
           shList[BuysOfSells] += tempVal2;
           if (isSTLT && postDate < termSeparator) {
             cfList[LongTermBuysOfSells].append(CashFlowListItem(postDate, tempVal));
             shList[LongTermBuysOfSells] += tempVal2;
           }
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, (shList.at(BuysOfOwned) / shares) * value));
           shList[BuysOfOwned] = MyMoneyMoney();
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::SellShares && reportedDateRange) {
         cfList[Sells].append(CashFlowListItem(postDate, value));
         shList[Sells] += shares;
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::SplitShares) {          // shares variable is denominator of split ratio here
         for (int i = Buys; i <= InvestmentValue::BuysOfOwned; ++i)
           shList[i] /= shares;
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::AddShares ||            // added shares, when sold give 100% capital gain
                  transactionType == eMyMoney::Split::InvestmentTransactionType::ReinvestDividend) {
         if (shList.at(BuysOfOwned).isZero()) {                            // add added/reinvested shares
           if (shList.at(BuysOfSells) + shares > shList.at(Sells).abs()) { // add partially added/reinvested shares
             shList[BuysOfSells] = shList.at(Sells).abs();
             if (postDate < termSeparator)
               shList[LongTermBuysOfSells] = shList[BuysOfSells];
           } else {                                                        // add wholly added/reinvested shares
             shList[BuysOfSells] += shares;
             if (postDate < termSeparator)
               shList[LongTermBuysOfSells] += shares;
           }
         } else if (shList.at(BuysOfOwned) >= shares) {                    // subtract not-added/not-reinvested shares
           shList[BuysOfOwned] -= shares;
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, value));
         } else {                                                          // subtract partially not-added/not-reinvested shares
           MyMoneyMoney tempVal = (shares - shList.at(BuysOfOwned));
           shList[BuysOfSells] += tempVal;
           if (postDate < termSeparator)
             shList[LongTermBuysOfSells] += tempVal;
 
           cfList[BuysOfOwned].append(CashFlowListItem(postDate, (shList.at(BuysOfOwned) / shares) * value));
           shList[BuysOfOwned] = MyMoneyMoney();
         }
         if (transactionType == eMyMoney::Split::InvestmentTransactionType::ReinvestDividend) {
           value = MyMoneyMoney();
           foreach (const auto split, interestSplits)
             value += split.value();
           value *= price;
           cfList[ReinvestIncome].append(CashFlowListItem(postDate, -value));
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::RemoveShares && reportedDateRange) // removed shares give no value in return so no capital gain on them
         shList[Sells] += shares;
       else if (transactionType == eMyMoney::Split::InvestmentTransactionType::Dividend || transactionType == eMyMoney::Split::InvestmentTransactionType::Yield)
         cfList[CashIncome].append(CashFlowListItem(postDate, value));
 
     }
     reportedDateRange = false;
     newEndingDate = newStartingDate;
     newStartingDate = newStartingDate.addYears(-1);
     report.setDateFilter(newStartingDate, newEndingDate); // search for matching buy transactions year earlier
 
   } while (
            (
              (report.investmentSum() == eMyMoney::Report::InvestmentSum::Owned && !shList[BuysOfOwned].isZero()) ||
              (report.investmentSum() == eMyMoney::Report::InvestmentSum::Sold && !shList.at(Sells).isZero() && shList.at(Sells).abs() > shList.at(BuysOfSells).abs()) ||
              (report.investmentSum() == eMyMoney::Report::InvestmentSum::OwnedAndSold && (!shList[BuysOfOwned].isZero() || (!shList.at(Sells).isZero() && shList.at(Sells).abs() > shList.at(BuysOfSells).abs())))
            ) && account.openingDate() <= newEndingDate
           );
 
   // we've got buy value and no sell value of long-term shares, so get them
   if (isSTLT && !shList[LongTermBuysOfSells].isZero()) {
     newStartingDate = startingDate;
     newEndingDate = endingDate.addDays(-settlementPeriod);
     report.setDateFilter(newStartingDate, newEndingDate); // search for matching buy transactions year earlier
     QList<MyMoneyTransaction> transactions = file->transactionList(report);
     shList[BuysOfOwned] = shList[LongTermBuysOfSells];
 
     foreach (const auto transaction, transactions) {
       MyMoneySplit shareSplit = transaction.splitByAccount(account.id());
       MyMoneySplit assetAccountSplit;
       QList<MyMoneySplit> feeSplits;
       QList<MyMoneySplit> interestSplits;
       MyMoneySecurity security;
       MyMoneySecurity currency;
       eMyMoney::Split::InvestmentTransactionType transactionType;
       KMyMoneyUtils::dissectTransaction(transaction, shareSplit, assetAccountSplit, feeSplits, interestSplits, security, currency, transactionType);
       QDate postDate = transaction.postDate();
       MyMoneyMoney price;
       if (m_config.isConvertCurrency())
         price = account.baseCurrencyPrice(postDate); //we only need base currency because the value is in deep currency
       else
         price = MyMoneyMoney::ONE;
       MyMoneyMoney value = assetAccountSplit.value() * price;
       MyMoneyMoney shares = shareSplit.shares();
 
       if (transactionType == eMyMoney::Split::InvestmentTransactionType::SellShares) {
         if ((shList.at(LongTermSellsOfBuys) + shares).abs() >= shList.at(LongTermBuysOfSells)) { // add partially sold long-term shares
           cfList[LongTermSellsOfBuys].append(CashFlowListItem(postDate, (shList.at(LongTermSellsOfBuys).abs() - shList.at(LongTermBuysOfSells)) / shares * value));
           shList[LongTermSellsOfBuys] = shList.at(LongTermBuysOfSells);
           break;
         } else {                      // add wholly sold long-term shares
           cfList[LongTermSellsOfBuys].append(CashFlowListItem(postDate, value));
           shList[LongTermSellsOfBuys] += shares;
         }
       } else if (transactionType == eMyMoney::Split::InvestmentTransactionType::RemoveShares) {
         if ((shList.at(LongTermSellsOfBuys) + shares).abs() >= shList.at(LongTermBuysOfSells)) {
           shList[LongTermSellsOfBuys] = shList.at(LongTermBuysOfSells);
           break;
         } else
           shList[LongTermSellsOfBuys] += shares;
       }
     }
   }
 
   shList[BuysOfOwned] = stashedBuysOfOwned;
   report.setDateFilter(startingDate, endingDate); // reset data filter for next security
   return;
 }
 
 void QueryTable::constructPerformanceRow(const ReportAccount& account, TableRow& result, CashFlowList &all) const
 {
   MyMoneyReport report = m_config;
   QDate startingDate;
   QDate endingDate;
   report.validDateRange(startingDate, endingDate);
   startingDate = startingDate.addDays(-1);
 
   MyMoneyFile* file = MyMoneyFile::instance();
   //get fraction depending on type of account
   int fraction = account.currency().smallestAccountFraction();
   MyMoneyMoney price;
   if (m_config.isConvertCurrency())
     price = account.deepCurrencyPrice(startingDate) * account.baseCurrencyPrice(startingDate);
   else
     price = account.deepCurrencyPrice(startingDate);
 
   MyMoneyMoney startingBal = file->balance(account.id(), startingDate) * price;
 
   //convert to lowest fraction
   startingBal = startingBal.convert(fraction);
 
   //calculate ending balance
   if (m_config.isConvertCurrency())
     price = account.deepCurrencyPrice(endingDate) * account.baseCurrencyPrice(endingDate);
   else
     price = account.deepCurrencyPrice(endingDate);
 
   MyMoneyMoney endingBal = file->balance((account).id(), endingDate) * price;
 
   //convert to lowest fraction
   endingBal = endingBal.convert(fraction);
 
   QList<CashFlowList> cfList;
   QList<MyMoneyMoney> shList;
   sumInvestmentValues(account, cfList, shList);
 
   MyMoneyMoney buysTotal;
   MyMoneyMoney sellsTotal;
   MyMoneyMoney cashIncomeTotal;
   MyMoneyMoney reinvestIncomeTotal;
 
   switch (m_config.investmentSum()) {
   case eMyMoney::Report::InvestmentSum::OwnedAndSold:
     buysTotal = cfList.at(BuysOfSells).total() + cfList.at(BuysOfOwned).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     reinvestIncomeTotal = cfList.at(ReinvestIncome).total();
     startingBal = MyMoneyMoney();
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         cashIncomeTotal.isZero() && reinvestIncomeTotal.isZero())
       return;
 
     all.append(cfList.at(BuysOfSells));
     all.append(cfList.at(BuysOfOwned));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctEndingBalance] = endingBal.toString();
     break;
   case eMyMoney::Report::InvestmentSum::Owned:
     buysTotal = cfList.at(BuysOfOwned).total();
     startingBal = MyMoneyMoney();
     if (buysTotal.isZero() && endingBal.isZero())
       return;
     all.append(cfList.at(BuysOfOwned));
     all.append(CashFlowListItem(endingDate, endingBal));
 
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctMarketValue] = endingBal.toString();
     break;
   case eMyMoney::Report::InvestmentSum::Sold:
     buysTotal = cfList.at(BuysOfSells).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     startingBal = endingBal = MyMoneyMoney();
     // check if there are any meaningfull values before adding them to results
     if (buysTotal.isZero() && sellsTotal.isZero() && cashIncomeTotal.isZero())
       return;
     all.append(cfList.at(BuysOfSells));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     break;
   case eMyMoney::Report::InvestmentSum::Period:
   default:
     buysTotal = cfList.at(Buys).total();
     sellsTotal = cfList.at(Sells).total();
     cashIncomeTotal = cfList.at(CashIncome).total();
     reinvestIncomeTotal = cfList.at(ReinvestIncome).total();
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         cashIncomeTotal.isZero() && reinvestIncomeTotal.isZero() &&
         startingBal.isZero() && endingBal.isZero())
       return;
 
     all.append(cfList.at(Buys));
     all.append(cfList.at(Sells));
     all.append(cfList.at(CashIncome));
     all.append(CashFlowListItem(startingDate, -startingBal));
     all.append(CashFlowListItem(endingDate, endingBal));
 
     result[ctSells] = sellsTotal.toString();
     result[ctCashIncome] = cashIncomeTotal.toString();
     result[ctReinvestIncome] = reinvestIncomeTotal.toString();
     result[ctStartingBalance] = startingBal.toString();
     result[ctEndingBalance] = endingBal.toString();
     break;
   }
 
   result[ctBuys] = buysTotal.toString();
   result[ctReturn] = helperIRR(all);
   result[ctReturnInvestment] = helperROI(buysTotal - reinvestIncomeTotal, sellsTotal, startingBal, endingBal, cashIncomeTotal);
   result[ctEquityType] = MyMoneySecurity::securityTypeToString(file->security(account.currencyId()).securityType());
 }
 
 void QueryTable::constructCapitalGainRow(const ReportAccount& account, TableRow& result) const
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<CashFlowList> cfList;
   QList<MyMoneyMoney> shList;
   sumInvestmentValues(account, cfList, shList);
 
   MyMoneyMoney buysTotal = cfList.at(BuysOfSells).total();
   MyMoneyMoney sellsTotal = cfList.at(Sells).total();
   MyMoneyMoney longTermBuysOfSellsTotal = cfList.at(LongTermBuysOfSells).total();
   MyMoneyMoney longTermSellsOfBuys = cfList.at(LongTermSellsOfBuys).total();
 
   switch (m_config.investmentSum()) {
   case eMyMoney::Report::InvestmentSum::Owned:
   {
     if (shList.at(BuysOfOwned).isZero())
       return;
 
     MyMoneyReport report = m_config;
     QDate startingDate;
     QDate endingDate;
     report.validDateRange(startingDate, endingDate);
 
     //get fraction depending on type of account
     int fraction = account.currency().smallestAccountFraction();
     MyMoneyMoney price;
 
     //calculate ending balance
     if (m_config.isConvertCurrency())
       price = account.deepCurrencyPrice(endingDate) * account.baseCurrencyPrice(endingDate);
     else
       price = account.deepCurrencyPrice(endingDate);
 
     MyMoneyMoney endingBal = shList.at(BuysOfOwned) * price;
 
     //convert to lowest fraction
     endingBal = endingBal.convert(fraction);
 
     buysTotal = cfList.at(BuysOfOwned).total() - cfList.at(ReinvestIncome).total();
 
     int pricePrecision = file->security(account.currencyId()).pricePrecision();
     result[ctBuys] = buysTotal.toString();
     result[ctShares] = shList.at(BuysOfOwned).toString();
     result[ctBuyPrice] = (buysTotal.abs() / shList.at(BuysOfOwned)).convertPrecision(pricePrecision).toString();
     result[ctLastPrice] = price.toString();
     result[ctMarketValue] = endingBal.toString();
     result[ctCapitalGain] = (buysTotal + endingBal).toString();
-    result[ctPercentageGain] = ((buysTotal + endingBal)/buysTotal.abs()).toString();
+    result[ctPercentageGain] = buysTotal.isZero() ? QString() :
+        ((buysTotal + endingBal)/buysTotal.abs()).toString();
     break;
   }
   case eMyMoney::Report::InvestmentSum::Sold:
   default:
     buysTotal = cfList.at(BuysOfSells).total() - cfList.at(ReinvestIncome).total();
     sellsTotal = cfList.at(Sells).total();
     longTermBuysOfSellsTotal = cfList.at(LongTermBuysOfSells).total();
     longTermSellsOfBuys = cfList.at(LongTermSellsOfBuys).total();
     // check if there are any meaningfull values before adding them to results
     if (buysTotal.isZero() && sellsTotal.isZero() &&
         longTermBuysOfSellsTotal.isZero() && longTermSellsOfBuys.isZero())
       return;
 
     result[ctBuys] = buysTotal.toString();
     result[ctSells] = sellsTotal.toString();
     result[ctCapitalGain] = (buysTotal + sellsTotal).toString();
     if (m_config.isShowingSTLTCapitalGains()) {
       result[ctBuysLT] = longTermBuysOfSellsTotal.toString();
       result[ctSellsLT] = longTermSellsOfBuys.toString();
       result[ctCapitalGainLT] = (longTermBuysOfSellsTotal + longTermSellsOfBuys).toString();
       result[ctBuysST] = (buysTotal - longTermBuysOfSellsTotal).toString();
       result[ctSellsST] = (sellsTotal - longTermSellsOfBuys).toString();
       result[ctCapitalGainST] = ((buysTotal - longTermBuysOfSellsTotal) + (sellsTotal - longTermSellsOfBuys)).toString();
     }
     break;
   }
 
   result[ctEquityType] = MyMoneySecurity::securityTypeToString(file->security(account.currencyId()).securityType());
 }
 
 void QueryTable::constructAccountTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   QMap<QString, QMap<QString, CashFlowList>> currencyCashFlow; // for total calculation
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
   for (auto it_account = accounts.constBegin(); it_account != accounts.constEnd(); ++it_account) {
     // Note, "Investment" accounts are never included in account rows because
     // they don't contain anything by themselves.  In reports, they are only
     // useful as a "topaccount" aggregator of stock accounts
     if ((*it_account).isAssetLiability() && m_config.includes((*it_account)) && (*it_account).accountType() != eMyMoney::Account::Type::Investment) {
       // don't add the account if it is closed. In fact, the business logic
       // should prevent that an account can be closed with a balance not equal
       // to zero, but we never know.
       MyMoneyMoney shares = file->balance((*it_account).id(), m_config.toDate());
       if (shares.isZero() && (*it_account).isClosed())
         continue;
 
       ReportAccount account(*it_account);
       TableRow qaccountrow;
       CashFlowList accountCashflow; // for total calculation
       switch(m_config.queryColumns()) {
         case eMyMoney::Report::QueryColumn::Performance:
         {
           constructPerformanceRow(account, qaccountrow, accountCashflow);
           if (!qaccountrow.isEmpty()) {
             // assuming that that report is grouped by topaccount
             qaccountrow[ctTopAccount] = account.topParentName();
             if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
               m_containsNonBaseCurrency = true;
             if (m_config.isConvertCurrency())
               qaccountrow[ctCurrency] = file->baseCurrency().id();
             else
               qaccountrow[ctCurrency] = account.currency().id();
 
             if (!currencyCashFlow.value(qaccountrow.value(ctCurrency)).contains(qaccountrow.value(ctTopAccount)))
               currencyCashFlow[qaccountrow.value(ctCurrency)].insert(qaccountrow.value(ctTopAccount), accountCashflow);   // create cashflow for unknown account...
             else
               currencyCashFlow[qaccountrow.value(ctCurrency)][qaccountrow.value(ctTopAccount)] += accountCashflow;        // ...or add cashflow for known account
           }
           break;
         }
         case eMyMoney::Report::QueryColumn::CapitalGain:
           constructCapitalGainRow(account, qaccountrow);
           break;
         default:
         {
           //get fraction for account
           int fraction = account.currency().smallestAccountFraction() != -1 ?
                 account.currency().smallestAccountFraction() : file->baseCurrency().smallestAccountFraction();
 
           MyMoneyMoney netprice = account.deepCurrencyPrice(m_config.toDate());
           if (m_config.isConvertCurrency() && account.isForeignCurrency())
             netprice *= account.baseCurrencyPrice(m_config.toDate()); // display currency is base currency, so set the price
 
           netprice = netprice.reduce();
           shares = shares.reduce();
           int pricePrecision = file->security(account.currencyId()).pricePrecision();
           qaccountrow[ctPrice] = netprice.convertPrecision(pricePrecision).toString();
           qaccountrow[ctValue] = (netprice * shares).convert(fraction).toString();
           qaccountrow[ctShares] = shares.toString();
 
           QString iid = account.institutionId();
 
           // If an account does not have an institution, get it from the top-parent.
           if (iid.isEmpty() && !account.isTopLevel())
             iid = account.topParent().institutionId();
 
           if (iid.isEmpty())
             qaccountrow[ctInstitution] = i18nc("No institution", "None");
           else
             qaccountrow[ctInstitution] = file->institution(iid).name();
 
           qaccountrow[ctType] = MyMoneyAccount::accountTypeToString(account.accountType());
         }
       }
 
       if (qaccountrow.isEmpty()) // don't add the account if there are no calculated values
         continue;
 
       qaccountrow[ctRank] = QLatin1Char('1');
       qaccountrow[ctAccount] = account.name();
       qaccountrow[ctAccountID] = account.id();
       qaccountrow[ctTopAccount] = account.topParentName();
       if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
         m_containsNonBaseCurrency = true;
       if (m_config.isConvertCurrency())
         qaccountrow[ctCurrency] = file->baseCurrency().id();
       else
         qaccountrow[ctCurrency] = account.currency().id();
       m_rows.append(qaccountrow);
     }
   }
 
   if (m_config.queryColumns() == eMyMoney::Report::QueryColumn::Performance && m_config.isShowingColumnTotals()) {
     TableRow qtotalsrow;
     qtotalsrow[ctRank] = QLatin1Char('4'); // add identification of row as total
     QMap<QString, CashFlowList> currencyGrandCashFlow;
 
     QMap<QString, QMap<QString, CashFlowList>>::iterator currencyAccGrp = currencyCashFlow.begin();
     while (currencyAccGrp != currencyCashFlow.end()) {
       // convert map of top accounts with cashflows to TableRow
       for (QMap<QString, CashFlowList>::iterator topAccount = (*currencyAccGrp).begin(); topAccount != (*currencyAccGrp).end(); ++topAccount) {
         qtotalsrow[ctTopAccount] = topAccount.key();
         qtotalsrow[ctReturn] = helperIRR(topAccount.value());
         qtotalsrow[ctCurrency] = currencyAccGrp.key();
         currencyGrandCashFlow[currencyAccGrp.key()] += topAccount.value();  // cumulative sum of cashflows of each topaccount
         m_rows.append(qtotalsrow);            // rows aren't sorted yet, so no problem with adding them randomly at the end
       }
       ++currencyAccGrp;
     }
     QMap<QString, CashFlowList>::iterator currencyGrp = currencyGrandCashFlow.begin();
     qtotalsrow[ctTopAccount].clear();          // empty topaccount because it's grand cashflow
     while (currencyGrp != currencyGrandCashFlow.end()) {
       qtotalsrow[ctReturn] = helperIRR(currencyGrp.value());
       qtotalsrow[ctCurrency] = currencyGrp.key();
       m_rows.append(qtotalsrow);
       ++currencyGrp;
     }
   }
 }
 
 void QueryTable::constructSplitsTable()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   MyMoneyReport report(m_config);
   report.setReportAllSplits(false);
   report.setConsiderCategory(true);
 
   // support for opening and closing balances
   QMap<QString, MyMoneyAccount> accts;
 
   //get all transactions for this report
   QList<MyMoneyTransaction> transactions = file->transactionList(report);
   for (QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin(); it_transaction != transactions.constEnd(); ++it_transaction) {
 
     TableRow qA, qS;
     QDate pd;
 
     qA[ctID] = qS[ctID] = (* it_transaction).id();
     qA[ctEntryDate] = qS[ctEntryDate] = (* it_transaction).entryDate().toString(Qt::ISODate);
     qA[ctPostDate] = qS[ctPostDate] = (* it_transaction).postDate().toString(Qt::ISODate);
     qA[ctCommodity] = qS[ctCommodity] = (* it_transaction).commodity();
 
     pd = (* it_transaction).postDate();
     qA[ctMonth] = qS[ctMonth] = i18n("Month of %1", QDate(pd.year(), pd.month(), 1).toString(Qt::ISODate));
     qA[ctWeek] = qS[ctWeek] = i18n("Week of %1", pd.addDays(1 - pd.dayOfWeek()).toString(Qt::ISODate));
 
     if (!m_containsNonBaseCurrency && (*it_transaction).commodity() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (report.isConvertCurrency())
       qA[ctCurrency] = qS[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = qS[ctCurrency] = (*it_transaction).commodity();
 
     // to handle splits, we decide on which account to base the split
     // (a reference point or point of view so to speak). here we take the
     // first account that is a stock account or loan account (or the first account
     // that is not an income or expense account if there is no stock or loan account)
     // to be the account (qA) that will have the sub-item "split" entries. we add
     // one transaction entry (qS) for each subsequent entry in the split.
     const QList<MyMoneySplit>& splits = (*it_transaction).splits();
     QList<MyMoneySplit>::const_iterator myBegin, it_split;
     //S_end = splits.end();
 
     for (it_split = splits.constBegin(), myBegin = splits.constEnd(); it_split != splits.constEnd(); ++it_split) {
       ReportAccount splitAcc((* it_split).accountId());
       // always put split with a "stock" account if it exists
       if (splitAcc.isInvest())
         break;
 
       // prefer to put splits with a "loan" account if it exists
       if (splitAcc.isLoan())
         myBegin = it_split;
 
       if ((myBegin == splits.end()) && ! splitAcc.isIncomeExpense()) {
         myBegin = it_split;
       }
     }
 
     // select our "reference" split
     if (it_split == splits.end()) {
       it_split = myBegin;
     } else {
       myBegin = it_split;
     }
 
     // if the split is still unknown, use the first one. I have seen this
     // happen with a transaction that has only a single split referencing an income or expense
     // account and has an amount and value of 0. Such a transaction will fall through
     // the above logic and leave 'it_split' pointing to splits.end() which causes the remainder
     // of this to end in an infinite loop.
     if (it_split == splits.end()) {
       it_split = splits.begin();
     }
 
     // for "loan" reports, the loan transaction gets special treatment.
     // the splits of a loan transaction are placed on one line in the
     // reference (loan) account (qA). however, we process the matching
     // split entries (qS) normally.
     bool loan_special_case = false;
     if (m_config.queryColumns() & eMyMoney::Report::QueryColumn::Loan) {
       ReportAccount splitAcc((*it_split).accountId());
       loan_special_case = splitAcc.isLoan();
     }
 
     // There is a slight chance that at this point myBegin is still pointing to splits.end() if the
     // transaction only has income and expense splits (which should not happen). In that case, point
     // it to the first split
     if (myBegin == splits.end()) {
       myBegin = splits.begin();
     }
 
     //the account of the beginning splits
     ReportAccount myBeginAcc((*myBegin).accountId());
 
     bool include_me = true;
     QString a_fullname;
     QString a_memo;
     int pass = 1;
 
     do {
       MyMoneyMoney xr;
       ReportAccount splitAcc((* it_split).accountId());
 
       //get fraction for account
       int fraction = splitAcc.currency().smallestAccountFraction();
 
       //use base currency fraction if not initialized
       if (fraction == -1)
         fraction = file->baseCurrency().smallestAccountFraction();
 
       QString institution = splitAcc.institutionId();
       QString payee = (*it_split).payeeId();
 
       const QList<QString> tagIdList = (*it_split).tagIdList();
 
       if (m_config.isConvertCurrency()) {
         xr = (splitAcc.deepCurrencyPrice((*it_transaction).postDate()) * splitAcc.baseCurrencyPrice((*it_transaction).postDate())).reduce();
       } else {
         xr = splitAcc.deepCurrencyPrice((*it_transaction).postDate()).reduce();
       }
 
       // reverse the sign of incomes and expenses to keep consistency in the way it is displayed in other reports
       if (splitAcc.isIncomeExpense()) {
         xr = -xr;
       }
 
       if (splitAcc.isInvest()) {
 
         // use the institution of the parent for stock accounts
         institution = splitAcc.parent().institutionId();
         MyMoneyMoney shares = (*it_split).shares();
         int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
         qA[ctAction] = (*it_split).action();
         qA[ctShares] = shares.isZero() ? QString() : (*it_split).shares().toString();
         qA[ctPrice] = shares.isZero() ? QString() : xr.convertPrecision(pricePrecision).toString();
 
         if (((*it_split).action() == MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares)) && (*it_split).shares().isNegative())
           qA[ctAction] = "Sell";
 
         qA[ctInvestAccount] = splitAcc.parent().name();
       }
 
       include_me = m_config.includes(splitAcc);
       a_fullname = splitAcc.fullName();
       a_memo = (*it_split).memo();
 
       int pricePrecision = file->security(splitAcc.currencyId()).pricePrecision();
       qA[ctPrice] = xr.convertPrecision(pricePrecision).toString();
       qA[ctAccount] = splitAcc.name();
       qA[ctAccountID] = splitAcc.id();
       qA[ctTopAccount] = splitAcc.topParentName();
 
       qA[ctInstitution] = institution.isEmpty()
                           ? i18n("No Institution")
                           : file->institution(institution).name();
 
       //FIXME-ALEX Is this useless? Isn't constructSplitsTable called only for cashflow type report?
       QString delimiter;
       foreach(const auto tagId, tagIdList) {
         qA[ctTag] += delimiter + file->tag(tagId).name().simplified();
         delimiter = QLatin1Char(',');
       }
 
       qA[ctPayee] = payee.isEmpty()
                     ? i18n("[Empty Payee]")
                     : file->payee(payee).name().simplified();
 
       qA[ctReconcileDate] = (*it_split).reconcileDate().toString(Qt::ISODate);
       qA[ctReconcileFlag] = KMyMoneyUtils::reconcileStateToString((*it_split).reconcileFlag(), true);
       qA[ctNumber] = (*it_split).number();
 
       qA[ctMemo] = a_memo;
 
       qS[ctReconcileDate] = qA[ctReconcileDate];
       qS[ctReconcileFlag] = qA[ctReconcileFlag];
       qS[ctNumber] = qA[ctNumber];
 
       qS[ctTopCategory] = splitAcc.topParentName();
 
       // only include the configured accounts
       if (include_me) {
         // add the "summarized" split transaction
         // this is the sub-total of the split detail
         // convert to lowest fraction
         qA[ctValue] = ((*it_split).shares() * xr).convert(fraction).toString();
         qA[ctRank] = QLatin1Char('1');
 
         //fill in account information
         if (! splitAcc.isIncomeExpense() && it_split != myBegin) {
           qA[ctAccount] = ((*it_split).shares().isNegative()) ?
                           i18n("Transfer to %1", myBeginAcc.fullName())
                           : i18n("Transfer from %1", myBeginAcc.fullName());
         } else if (it_split == myBegin) {
           //handle the main split
           if ((splits.count() > 2)) {
             //if it is the main split and has multiple splits, note that
             qA[ctAccount] = i18n("[Split Transaction]");
           } else {
             //fill the account name of the second split
             QList<MyMoneySplit>::const_iterator tempSplit = splits.constBegin();
 
             //there are supposed to be only 2 splits if we ever get here
             if (tempSplit == myBegin && splits.count() > 1)
               ++tempSplit;
 
             //show the name of the category, or "transfer to/from" if it as an account
             ReportAccount tempSplitAcc((*tempSplit).accountId());
             if (! tempSplitAcc.isIncomeExpense()) {
               qA[ctAccount] = ((*it_split).shares().isNegative()) ?
                               i18n("Transfer to %1", tempSplitAcc.fullName())
                               : i18n("Transfer from %1", tempSplitAcc.fullName());
             } else {
               qA[ctAccount] = tempSplitAcc.fullName();
             }
           }
         } else {
           //in any other case, fill in the account name of the main split
           qA[ctAccount] = myBeginAcc.fullName();
         }
 
         //category data is always the one of the split
         qA [ctCategory] = splitAcc.fullName();
         qA [ctTopCategory] = splitAcc.topParentName();
         qA [ctCategoryType] = MyMoneyAccount::accountTypeToString(splitAcc.accountGroup());
 
         m_rows += qA;
 
         // track accts that will need opening and closing balances
         accts.insert(splitAcc.id(), splitAcc);
       }
       ++it_split;
 
       // look for wrap-around
       if (it_split == splits.end())
         it_split = splits.begin();
 
       //check if there have been more passes than there are splits
       //this is to prevent infinite loops in cases of data inconsistency -- asoliverez
       ++pass;
       if (pass > splits.count())
         break;
 
     } while (it_split != myBegin);
 
     if (loan_special_case) {
       m_rows += qA;
     }
   }
 
   // now run through our accts list and add opening and closing balances
 
   switch (m_config.rowType()) {
     case eMyMoney::Report::RowType::Account:
     case eMyMoney::Report::RowType::TopAccount:
       break;
 
       // case eMyMoney::Report::RowType::Category:
       // case MyMoneyReport::eTopCategory:
       // case MyMoneyReport::ePayee:
       // case MyMoneyReport::eMonth:
       // case MyMoneyReport::eWeek:
     default:
       return;
   }
 
   QDate startDate, endDate;
 
   report.validDateRange(startDate, endDate);
   QString strStartDate = startDate.toString(Qt::ISODate);
   QString strEndDate = endDate.toString(Qt::ISODate);
   startDate = startDate.addDays(-1);
 
   for (auto it_account = accts.constBegin(); it_account != accts.constEnd(); ++it_account) {
     TableRow qA;
 
     ReportAccount account((* it_account));
 
     //get fraction for account
     int fraction = account.currency().smallestAccountFraction();
 
     //use base currency fraction if not initialized
     if (fraction == -1)
       fraction = file->baseCurrency().smallestAccountFraction();
 
     QString institution = account.institutionId();
 
     // use the institution of the parent for stock accounts
     if (account.isInvest())
       institution = account.parent().institutionId();
 
     MyMoneyMoney startBalance, endBalance, startPrice, endPrice;
     MyMoneyMoney startShares, endShares;
 
     //get price and convert currency if necessary
     if (m_config.isConvertCurrency()) {
       startPrice = (account.deepCurrencyPrice(startDate) * account.baseCurrencyPrice(startDate)).reduce();
       endPrice = (account.deepCurrencyPrice(endDate) * account.baseCurrencyPrice(endDate)).reduce();
     } else {
       startPrice = account.deepCurrencyPrice(startDate).reduce();
       endPrice = account.deepCurrencyPrice(endDate).reduce();
     }
     startShares = file->balance(account.id(), startDate);
     endShares = file->balance(account.id(), endDate);
 
     //get starting and ending balances
     startBalance = startShares * startPrice;
     endBalance = endShares * endPrice;
 
     //starting balance
     // don't show currency if we're converting or if it's not foreign
     if (!m_containsNonBaseCurrency && account.currency().id() != file->baseCurrency().id())
       m_containsNonBaseCurrency = true;
     if (m_config.isConvertCurrency())
       qA[ctCurrency] = file->baseCurrency().id();
     else
       qA[ctCurrency] = account.currency().id();
 
     qA[ctAccountID] = account.id();
     qA[ctAccount] = account.name();
     qA[ctTopAccount] = account.topParentName();
     qA[ctInstitution] = institution.isEmpty() ? i18n("No Institution") : file->institution(institution).name();
     qA[ctRank] = QLatin1Char('0');
 
     int pricePrecision = file->security(account.currencyId()).pricePrecision();
     qA[ctPrice] = startPrice.convertPrecision(pricePrecision).toString();
     if (account.isInvest()) {
       qA[ctShares] = startShares.toString();
     }
 
     qA[ctPostDate] = strStartDate;
     qA[ctBalance] = startBalance.convert(fraction).toString();
     qA[ctValue].clear();
     qA[ctID] = QLatin1Char('A');
     m_rows += qA;
 
     qA[ctRank] = QLatin1Char('3');
     //ending balance
     qA[ctPrice] = endPrice.convertPrecision(pricePrecision).toString();
 
     if (account.isInvest()) {
       qA[ctShares] = endShares.toString();
     }
 
     qA[ctPostDate] = strEndDate;
     qA[ctBalance] = endBalance.toString();
     qA[ctID] = QLatin1Char('Z');
     m_rows += qA;
   }
 }
 
 
 
 }
diff --git a/kmymoney/plugins/views/reports/core/tests/querytable-test.cpp b/kmymoney/plugins/views/reports/core/tests/querytable-test.cpp
index 8db4deff3..181fd2430 100644
--- a/kmymoney/plugins/views/reports/core/tests/querytable-test.cpp
+++ b/kmymoney/plugins/views/reports/core/tests/querytable-test.cpp
@@ -1,977 +1,1005 @@
 /*
  * Copyright 2005-2018  Thomas Baumgart <tbaumgart@kde.org>
  * Copyright 2005-2006  Ace Jones <acejones@users.sourceforge.net>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * 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 "querytable-test.h"
 
 #include <QFile>
 #include <QTest>
 
 #include <KLocalizedString>
 
 #include "tests/testutilities.h"
 #include "cashflowlist.h"
 #include "querytable.h"
 #include "mymoneyinstitution.h"
 #include "mymoneyaccount.h"
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneystoragedump.h"
 #include "mymoneyreport.h"
 #include "mymoneysplit.h"
 #include "mymoneypayee.h"
 #include "mymoneystatement.h"
 #include "mymoneyexception.h"
 #include "kmymoneysettings.h"
 
 using namespace reports;
 using namespace test;
 
 QTEST_GUILESS_MAIN(QueryTableTest)
 
 void writeTabletoHTML(const QueryTable& table, const QString& _filename = QString())
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString::fromLatin1("report-%1.html").arg(filenumber, 2, 10,QLatin1Char('0'));
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderHTML();
   g.close();
 }
 
 void writeTabletoCSV(const QueryTable& table, const QString& _filename = QString())
 {
   static unsigned filenumber = 1;
   QString filename = _filename;
   if (filename.isEmpty()) {
     filename = QString::fromLatin1("report-%1.csv").arg(filenumber, 2, 10,QLatin1Char('0'));
     ++filenumber;
   }
 
   QFile g(filename);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << table.renderCSV();
   g.close();
 }
 
 void QueryTableTest::setup()
 {
 }
 
 void QueryTableTest::init()
 {
   storage = new MyMoneyStorageMgr;
   file = MyMoneyFile::instance();
   file->attachStorage(storage);
   MyMoneyFileTransaction ft;
   file->addCurrency(MyMoneySecurity("CAD", "Canadian Dollar",        "C$"));
   file->addCurrency(MyMoneySecurity("USD", "US Dollar",              "$"));
   file->addCurrency(MyMoneySecurity("JPY", "Japanese Yen",           QChar(0x00A5), 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest;
   payeeTest.setName("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2;
   payeeTest2.setName("Thomas Baumgart");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount(QString("Checking Account"), eMyMoney::Account::Type::Checkings, moCheckingOpen, QDate(2004, 5, 15), acAsset);
   acCredit = makeAccount(QString("Credit Card"), eMyMoney::Account::Type::CreditCard, moCreditOpen, QDate(2004, 7, 15), acLiability);
   acSolo = makeAccount(QString("Solo"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acParent = makeAccount(QString("Parent"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acChild = makeAccount(QString("Child"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acForeign = makeAccount(QString("Foreign"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acTax = makeAccount(QString("Tax"), eMyMoney::Account::Type::Expense, MyMoneyMoney(), QDate(2005, 1, 11), acExpense, "", true);
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 }
 
 void QueryTableTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void QueryTableTest::testQueryBasics()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     unsigned cols;
 
     MyMoneyReport filter;
     filter.setRowType(eMyMoney::Report::RowType::Category);
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Account;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     filter.setName("Transactions by Category");
     XMLandback(filter);
     QueryTable qtbl_1(filter);
 
     writeTabletoHTML(qtbl_1, "Transactions by Category.html");
 
     QList<ListTable::TableRow> rows = qtbl_1.rows();
 
     QVERIFY(rows.count() == 19);
     QVERIFY(rows[0][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[0][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-02-01");
     QVERIFY(rows[14][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[14][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[14][ListTable::ctPostDate] == "2005-01-01");
 
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == -(moParent1 + moParent2) * 3);
     QVERIFY(MyMoneyMoney(rows[10][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[16][ListTable::ctValue]) == -(moSolo) * 3);
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[18][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(eMyMoney::Report::RowType::TopCategory);
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Account;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     filter.setName("Transactions by Top Category");
     XMLandback(filter);
     QueryTable qtbl_2(filter);
 
     writeTabletoHTML(qtbl_2, "Transactions by Top Category.html");
 
     rows = qtbl_2.rows();
 
     QVERIFY(rows.count() == 16);
     QVERIFY(rows[0][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[0][ListTable::ctTopCategory] == "Parent");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-02-01");
     QVERIFY(rows[8][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[8][ListTable::ctTopCategory] == "Parent");
     QVERIFY(rows[8][ListTable::ctPostDate] == "2005-09-01");
     QVERIFY(rows[12][ListTable::ctCategoryType] == "Expense");
     QVERIFY(rows[12][ListTable::ctTopCategory] == "Solo");
     QVERIFY(rows[12][ListTable::ctPostDate] == "2005-01-01");
 
     QVERIFY(MyMoneyMoney(rows[9][ListTable::ctValue]) == -(moParent1 + moParent2 + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[13][ListTable::ctValue]) == -(moSolo) * 3);
     QVERIFY(MyMoneyMoney(rows[14][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(eMyMoney::Report::RowType::Account);
     filter.setName("Transactions by Account");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account.html");
 
     rows = qtbl_3.rows();
 
 #if 1
     QVERIFY(rows.count() == 19);
     QVERIFY(rows[1][ListTable::ctAccount] == "Checking Account");
     QVERIFY(rows[1][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[1][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[15][ListTable::ctAccount] == "Credit Card");
     QVERIFY(rows[15][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[15][ListTable::ctPostDate] == "2005-09-01");
 #else
     QVERIFY(rows.count() == 12);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[11][ListTable::ctAccount] == "Credit Card");
     QVERIFY(rows[11][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[11][ListTable::ctPostDate] == "2005-09-01");
 #endif
 
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == -(moSolo) * 3 + moCheckingOpen);
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == -(moParent1 + moParent2 + moChild) * 3 + moCreditOpen);
     QVERIFY(MyMoneyMoney(rows[18][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(eMyMoney::Report::RowType::Payee);
     filter.setName("Transactions by Payee");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Memo | eMyMoney::Report::QueryColumn::Category;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_4(filter);
 
     writeTabletoHTML(qtbl_4, "Transactions by Payee.html");
 
     rows = qtbl_4.rows();
 
     QVERIFY(rows.count() == 14);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[7][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[7][ListTable::ctCategory] == "Parent: Child");
     QVERIFY(rows[7][ListTable::ctPostDate] == "2004-11-07");
     QVERIFY(rows[11][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[11][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[11][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[12][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[13][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(eMyMoney::Report::RowType::Month);
     filter.setName("Transactions by Month");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_5(filter);
 
     writeTabletoHTML(qtbl_5, "Transactions by Month.html");
 
     rows = qtbl_5.rows();
 
     QVERIFY(rows.count() == 23);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[12][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[12][ListTable::ctCategory] == "Parent: Child");
     QVERIFY(rows[12][ListTable::ctPostDate] == "2004-11-07");
     QVERIFY(rows[20][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[20][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[20][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == -moSolo);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[9][ListTable::ctValue]) == -moParent1 + moCheckingOpen);
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
 
     filter.setRowType(eMyMoney::Report::RowType::Week);
     filter.setName("Transactions by Week");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_6(filter);
 
     writeTabletoHTML(qtbl_6, "Transactions by Week.html");
 
     rows = qtbl_6.rows();
 
     QVERIFY(rows.count() == 23);
     QVERIFY(rows[0][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[0][ListTable::ctCategory] == "Solo");
     QVERIFY(rows[0][ListTable::ctPostDate] == "2004-01-01");
     QVERIFY(rows[20][ListTable::ctPayee] == "Test Payee");
     QVERIFY(rows[20][ListTable::ctCategory] == "Parent");
     QVERIFY(rows[20][ListTable::ctPostDate] == "2005-09-01");
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == -moSolo);
     QVERIFY(MyMoneyMoney(rows[15][ListTable::ctValue]) == -(moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[21][ListTable::ctValue]) == -moParent2);
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == -(moParent1 + moParent2 + moSolo + moChild) * 3 + moCheckingOpen + moCreditOpen);
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 
   // Test querytable::TableRow::operator> and operator==
 
   QueryTable::TableRow low;
   low[ListTable::ctPrice] = 'A';
   low[ListTable::ctLastPrice] = 'B';
   low[ListTable::ctBuyPrice] = 'C';
 
   QueryTable::TableRow high;
   high[ListTable::ctPrice] = 'A';
   high[ListTable::ctLastPrice] = 'C';
   high[ListTable::ctBuyPrice] = 'B';
 
   QueryTable::TableRow::setSortCriteria({ListTable::ctPrice, ListTable::ctLastPrice, ListTable::ctBuyPrice});
   QVERIFY(low < high);
   QVERIFY(low <= high);
   QVERIFY(high > low);
   QVERIFY(high <= high);
   QVERIFY(high == high);
 }
 
 void QueryTableTest::testCashFlowAnalysis()
 {
   //
   // Test XIRR calculations
   //
 
   CashFlowList list;
 
   list += CashFlowListItem(QDate(2004, 5, 3), MyMoneyMoney(1000.0));
   list += CashFlowListItem(QDate(2004, 5, 20), MyMoneyMoney(59.0));
   list += CashFlowListItem(QDate(2004, 6, 3), MyMoneyMoney(14.0));
   list += CashFlowListItem(QDate(2004, 6, 24), MyMoneyMoney(92.0));
   list += CashFlowListItem(QDate(2004, 7, 6), MyMoneyMoney(63.0));
   list += CashFlowListItem(QDate(2004, 7, 25), MyMoneyMoney(15.0));
   list += CashFlowListItem(QDate(2004, 8, 5), MyMoneyMoney(92.0));
   list += CashFlowListItem(QDate(2004, 9, 2), MyMoneyMoney(18.0));
   list += CashFlowListItem(QDate(2004, 9, 21), MyMoneyMoney(5.0));
   list += CashFlowListItem(QDate(2004, 10, 16), MyMoneyMoney(-2037.0));
 
   MyMoneyMoney XIRR(list.XIRR(), 1000);
   QVERIFY(XIRR == MyMoneyMoney(1676, 1000));
 
   list.pop_back();
   list += CashFlowListItem(QDate(2004, 10, 16), MyMoneyMoney(-1358.0));
 
   XIRR = MyMoneyMoney(list.XIRR(), 1000);
   QVERIFY(XIRR.isZero());
 
   // two entries
   list.clear();
   list += CashFlowListItem(QDate(2005, 9, 22), MyMoneyMoney(-3472.57));
   list += CashFlowListItem(QDate(2009, 3, 18), MyMoneyMoney(6051.36));
 
   XIRR = MyMoneyMoney(list.XIRR(), 1000);
   QCOMPARE(XIRR.toDouble(), MyMoneyMoney(173, 1000).toDouble());
 
   // check ignoring zero values
   list += CashFlowListItem(QDate(1998, 11, 1), MyMoneyMoney(0.0));
   list += CashFlowListItem(QDate(2017, 8, 11), MyMoneyMoney(0.0));
 
   XIRR = MyMoneyMoney(list.XIRR(), 1000);
   QCOMPARE(XIRR.toDouble(), MyMoneyMoney(173, 1000).toDouble());
 
   list.pop_back();
   // former implementation crashed
   list += CashFlowListItem(QDate(2014, 8, 11), MyMoneyMoney(0.0));
 
   XIRR = MyMoneyMoney(list.XIRR(), 1000);
   QCOMPARE(XIRR.toDouble(), MyMoneyMoney(173, 1000).toDouble());
 
   // different ordering
   list.clear();
   list += CashFlowListItem(QDate(2004, 3, 18), MyMoneyMoney(6051.36));
   list += CashFlowListItem(QDate(2005, 9, 22), MyMoneyMoney(-3472.57));
 
   XIRR = MyMoneyMoney(list.XIRR(), 1000);
   QCOMPARE(XIRR.toDouble(), MyMoneyMoney(-307, 1000).toDouble());
 
 
   // not enough entries
   list.pop_back();
 
   bool result = false;
   try {
     XIRR = MyMoneyMoney(list.XIRR(), 1000);
   } catch (MyMoneyException &e) {
     result  = true;
   }
   QVERIFY(result);
 }
 
 void QueryTableTest::testAccountQuery()
 {
   try {
     QString htmlcontext = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\">\n<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"html/kmymoney.css\"></head><body>\n%1\n</body></html>\n");
 
     //
     // No transactions, opening balances only
     //
 
     MyMoneyReport filter;
     filter.setRowType(eMyMoney::Report::RowType::Institution);
     filter.setName("Accounts by Institution (No transactions)");
     XMLandback(filter);
     QueryTable qtbl_1(filter);
 
     writeTabletoHTML(qtbl_1, "Accounts by Institution (No transactions).html");
 
     QList<ListTable::TableRow> rows = qtbl_1.rows();
 
     QVERIFY(rows.count() == 6);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == moCheckingOpen);
     QVERIFY(rows[0][ListTable::ctEquityType].isEmpty());
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == moCreditOpen);
     QVERIFY(rows[2][ListTable::ctEquityType].isEmpty());
 
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == moCheckingOpen + moCreditOpen);
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == moCheckingOpen + moCreditOpen);
 
     //
     // Adding in transactions
     //
 
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     filter.setRowType(eMyMoney::Report::RowType::Institution);
     filter.setName("Accounts by Institution (With Transactions)");
     XMLandback(filter);
     QueryTable qtbl_2(filter);
 
     rows = qtbl_2.rows();
 
     QVERIFY(rows.count() == 6);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == (moCheckingOpen - moSolo*3));
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == (moCreditOpen - (moParent1 + moParent2 + moChild) * 3));
 
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == moCheckingOpen + moCreditOpen - (moParent1 + moParent2 + moSolo + moChild) * 3);
 
     //
     // Account TYPES
     //
 
     filter.setRowType(eMyMoney::Report::RowType::AccountType);
     filter.setName("Accounts by Type");
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(rows[0][ListTable::ctAccount] == "Checking Account");
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == (moCheckingOpen - moSolo * 3));
     QVERIFY(rows[2][ListTable::ctAccount] == "Credit Card");
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == (moCreditOpen - (moParent1 + moParent2 + moChild) * 3));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == moCheckingOpen - moSolo * 3);
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == moCreditOpen - (moParent1 + moParent2 + moChild) * 3);
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == moCheckingOpen + moCreditOpen - (moParent1 + moParent2 + moSolo + moChild) * 3);
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 }
 
 void QueryTableTest::testInvestment()
 {
   try {
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
     eqStock2 = makeEquity("Stock2", "STK2");
     eqStock3 = makeEquity("Stock3", "STK3");
     eqStock4 = makeEquity("Stock4", "STK4");
 
     // Accounts
     acInvestment = makeAccount("Investment", eMyMoney::Account::Type::Investment, moZero, QDate(2003, 11, 1), acAsset);
     acStock1 = makeAccount("Stock 1", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock1);
     acStock2 = makeAccount("Stock 2", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock2);
     acStock3 = makeAccount("Stock 3", eMyMoney::Account::Type::Stock, moZero, QDate(2003, 11, 1), acInvestment, eqStock3);
     acStock4 = makeAccount("Stock 4", eMyMoney::Account::Type::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock4);
     acDividends = makeAccount("Dividends", eMyMoney::Account::Type::Income, moZero, QDate(2004, 1, 1), acIncome);
     acInterest = makeAccount("Interest", eMyMoney::Account::Type::Income, moZero, QDate(2004, 1, 1), acIncome);
     acFees = makeAccount("Fees", eMyMoney::Account::Type::Expense, moZero, QDate(2003, 11, 1), acExpense);
 
     // Transactions
     //                         Date             Action                                               Shares                Price   Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2003, 12, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock3, acChecking, QString());
     InvTransactionHelper s1b2(QDate(2004, 1, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(500.00), MyMoneyMoney(100.00), acStock4, acChecking, acFees, MyMoneyMoney(100.00));
     InvTransactionHelper s1b3(QDate(2004, 1, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(500.00), MyMoneyMoney(90.00), acStock4, acChecking, acFees, MyMoneyMoney(100.00));
     InvTransactionHelper s1b4(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1b5(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(1000.00), MyMoneyMoney(110.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(120.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-200.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s3(QDate(2004, 5, 30), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),        MyMoneyMoney(-1000.00), MyMoneyMoney(120.00), acStock4, acChecking, acFees, MyMoneyMoney(200.00));
     InvTransactionHelper s1r1(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(100.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1r2(QDate(2004, 7, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::ReinvestDividend), MyMoneyMoney(50.00), MyMoneyMoney(80.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1c1(QDate(2004, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(100.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1c2(QDate(2004, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Dividend),         MyMoneyMoney(10.00), MyMoneyMoney(120.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1y1(QDate(2004, 9, 15), MyMoneySplit::actionName(eMyMoney::Split::Action::Yield),           MyMoneyMoney(10.00), MyMoneyMoney(110.00), acStock1, acChecking, acInterest);
 
     makeEquityPrice(eqStock1, QDate(2004, 10, 1), MyMoneyMoney(100.00));
     makeEquityPrice(eqStock3, QDate(2004, 10, 1), MyMoneyMoney(110.00));
     makeEquityPrice(eqStock4, QDate(2004, 10, 1), MyMoneyMoney(110.00));
 
     //
     // Investment Transactions Report
     //
 
     MyMoneyReport invtran_r(
       eMyMoney::Report::RowType::TopAccount,
       eMyMoney::Report::QueryColumn::Action | eMyMoney::Report::QueryColumn::Shares | eMyMoney::Report::QueryColumn::Price,
       eMyMoney::TransactionFilter::Date::UserDefined,
       eMyMoney::Report::DetailLevel::All,
       i18n("Investment Transactions"),
       i18n("Test Report")
     );
     invtran_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31));
     invtran_r.setInvestmentsOnly(true);
     XMLandback(invtran_r);
     QueryTable invtran(invtran_r);
 
 #if 1
     writeTabletoHTML(invtran, "investment_transactions_test.html");
 
     QList<ListTable::TableRow> rows = invtran.rows();
 
     QVERIFY(rows.count() == 32);
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == MyMoneyMoney(-100000.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == MyMoneyMoney(-110000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == MyMoneyMoney(24000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == MyMoneyMoney(20000.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == MyMoneyMoney(5000.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == MyMoneyMoney(4000.00));
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctValue]) == MyMoneyMoney(-50100.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctValue]) == MyMoneyMoney(-45100.00));
     // need to fix these... fundamentally different from the original test
     //QVERIFY(MyMoneyMoney(invtran.m_rows[8][ListTable::ctValue])==MyMoneyMoney( -1000.00));
     //QVERIFY(MyMoneyMoney(invtran.m_rows[11][ListTable::ctValue])==MyMoneyMoney( -1200.00));
     //QVERIFY(MyMoneyMoney(invtran.m_rows[14][ListTable::ctValue])==MyMoneyMoney( -1100.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctPrice]) == MyMoneyMoney(120.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctPrice]) == MyMoneyMoney());
     QVERIFY(MyMoneyMoney(rows[10][ListTable::ctPrice]) == MyMoneyMoney());
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctPrice]) == MyMoneyMoney(90.00));
 
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctShares]) == MyMoneyMoney(1000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctShares]) == MyMoneyMoney(-200.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctShares]) == MyMoneyMoney(50.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[11][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[19][ListTable::ctShares]) == MyMoneyMoney(500.00));
     QVERIFY(MyMoneyMoney(rows[22][ListTable::ctShares]) == MyMoneyMoney(500.00));
 
     QVERIFY(rows[1][ListTable::ctAction] == "Buy");
     QVERIFY(rows[3][ListTable::ctAction] == "Sell");
     QVERIFY(rows[5][ListTable::ctAction] == "Reinvest");
     QVERIFY(rows[7][ListTable::ctAction] == "Dividend");
     QVERIFY(rows[13][ListTable::ctAction] == "Yield");
     QVERIFY(rows[19][ListTable::ctAction] == "Buy");
     QVERIFY(rows[22][ListTable::ctAction] == "Buy");
 #else
     QVERIFY(rows.count() == 9);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctValue]) == MyMoneyMoney(100000.00));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == MyMoneyMoney(110000.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctValue]) == MyMoneyMoney(-24000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctValue]) == MyMoneyMoney(-20000.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctValue]) == MyMoneyMoney(5000.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctValue]) == MyMoneyMoney(4000.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctValue]) == MyMoneyMoney(-1000.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctValue]) == MyMoneyMoney(-1200.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctValue]) == MyMoneyMoney(-1100.00));
 
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctPrice]) == MyMoneyMoney(120.00));
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctPrice]) == MyMoneyMoney(100.00));
     QVERIFY(MyMoneyMoney(rows[6][ListTable::ctPrice]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctPrice]) == MyMoneyMoney(0.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctShares]) == MyMoneyMoney(1000.00));
     QVERIFY(MyMoneyMoney(rows[3][ListTable::ctShares]) == MyMoneyMoney(-200.00));
     QVERIFY(MyMoneyMoney(rows[5][ListTable::ctShares]) == MyMoneyMoney(50.00));
     QVERIFY(MyMoneyMoney(rows[7][ListTable::ctShares]) == MyMoneyMoney(0.00));
     QVERIFY(MyMoneyMoney(rows[8][ListTable::ctShares]) == MyMoneyMoney(0.00));
 
     QVERIFY(rows[0][ListTable::ctAction] == "Buy");
     QVERIFY(rows[2][ListTable::ctAction] == "Sell");
     QVERIFY(rows[4][ListTable::ctAction] == "Reinvest");
     QVERIFY(rows[6][ListTable::ctAction] == "Dividend");
     QVERIFY(rows[8][ListTable::ctAction] == "Yield");
 #endif
 
 #if 1
     // i think this is the correct amount. different treatment of dividend and yield
     QVERIFY(MyMoneyMoney(rows[17][ListTable::ctValue]) == MyMoneyMoney(-153700.00));
     QVERIFY(MyMoneyMoney(rows[29][ListTable::ctValue]) == MyMoneyMoney(24600.00));
     QVERIFY(MyMoneyMoney(rows[31][ListTable::ctValue]) == MyMoneyMoney(-129100.00));
 #else
     QVERIFY(searchHTML(html, i18n("Total Stock 1")) == MyMoneyMoney(171700.00));
     QVERIFY(searchHTML(html, i18n("Grand Total")) == MyMoneyMoney(171700.00));
 #endif
 
     //
     // Investment Performance Report
     //
 
     MyMoneyReport invhold_r(
       eMyMoney::Report::RowType::AccountByTopAccount,
       eMyMoney::Report::QueryColumn::Performance,
       eMyMoney::TransactionFilter::Date::UserDefined,
       eMyMoney::Report::DetailLevel::All,
       i18n("Investment Performance by Account"),
       i18n("Test Report")
     );
     invhold_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 10, 1));
     invhold_r.setInvestmentsOnly(true);
     XMLandback(invhold_r);
     QueryTable invhold(invhold_r);
 
     writeTabletoHTML(invhold, "Investment Performance by Account.html");
 
     rows = invhold.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReturn]) == MyMoneyMoney("669/10000"));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReturnInvestment]) == MyMoneyMoney("-39/5000"));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctBuys]) == MyMoneyMoney(-210000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctSells]) == MyMoneyMoney(44000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctReinvestIncome]) == MyMoneyMoney(9000.00));
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctCashIncome]) == MyMoneyMoney(3300.00));
 
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctReturn]) == MyMoneyMoney("1349/10000"));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctReturnInvestment]) == MyMoneyMoney("1/10"));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctStartingBalance]) == MyMoneyMoney(100000.00)); // this should stay non-zero to check if investment performance is calculated at non-zero starting balance
 
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctReturn]) == MyMoneyMoney("2501/2500"));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctReturnInvestment]) == MyMoneyMoney("323/1250"));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctBuys]) == MyMoneyMoney(-95200.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctSells]) == MyMoneyMoney(119800.00));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctEndingBalance]) == MyMoneyMoney(0.00)); // this should stay zero to check if investment performance is calculated at zero ending balance
 
     QVERIFY(MyMoneyMoney(rows[4][ListTable::ctEndingBalance]) == MyMoneyMoney(280000.00));
 
 #if 0
     // Dump file & reports
     QFile g("investmentkmy.xml");
     g.open(QIODevice::WriteOnly);
     MyMoneyStorageXML xml;
     IMyMoneyOperationsFormat& interface = xml;
     interface.writeFile(&g, dynamic_cast<IMyMoneySerialization*>(MyMoneyFile::instance()->storage()));
     g.close();
 
     invtran.dump("invtran.html", "<html><head></head><body>%1</body></html>");
     invhold.dump("invhold.html", "<html><head></head><body>%1</body></html>");
 #endif
 
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 }
 
 // prevents bug #312135
 void QueryTableTest::testSplitShares()
 {
   try {
     MyMoneyMoney firstSharesPurchase(16);
     MyMoneyMoney splitFactor(2);
     MyMoneyMoney secondSharesPurchase(1);
     MyMoneyMoney sharesAtTheEnd = firstSharesPurchase / splitFactor + secondSharesPurchase;
     MyMoneyMoney priceBeforeSplit(74.99, 100);
     MyMoneyMoney priceAfterSplit = splitFactor * priceBeforeSplit;
 
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
 
     // Accounts
     acInvestment = makeAccount("Investment", eMyMoney::Account::Type::Investment, moZero, QDate(2017, 8, 1), acAsset);
     acStock1 =     makeAccount("Stock 1",    eMyMoney::Account::Type::Stock,      moZero, QDate(2017, 8, 1), acInvestment, eqStock1);
 
     // Transactions
     //                        Date               Action                           Shares                Price             Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2017, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),   firstSharesPurchase,  priceBeforeSplit, acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2017, 8, 2), MyMoneySplit::actionName(eMyMoney::Split::Action::SplitShares), splitFactor,          MyMoneyMoney(),   acStock1, QString(),  QString());
     InvTransactionHelper s1b2(QDate(2017, 8, 3), MyMoneySplit::actionName(eMyMoney::Split::Action::BuyShares),   secondSharesPurchase, priceAfterSplit,  acStock1, acChecking, QString());
 
     //
     // Investment Performance Report
     //
 
     MyMoneyReport invhold_r(
       eMyMoney::Report::RowType::AccountByTopAccount,
       eMyMoney::Report::QueryColumn::Performance,
       eMyMoney::TransactionFilter::Date::UserDefined,
       eMyMoney::Report::DetailLevel::All,
       i18n("Investment Performance by Account"),
       i18n("Test Report")
     );
     invhold_r.setDateFilter(QDate(2017, 8, 1), QDate(2017, 8, 3));
     invhold_r.setInvestmentsOnly(true);
     XMLandback(invhold_r);
     QueryTable invhold(invhold_r);
 
     writeTabletoHTML(invhold, "Investment Performance by Account (with stock split).html");
 
     const auto rows = invhold.rows();
 
     QVERIFY(rows.count() == 3);
     QVERIFY(MyMoneyMoney(rows[0][ListTable::ctBuys]) == sharesAtTheEnd * priceAfterSplit * MyMoneyMoney(-1));
 
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 }
 
 // prevents bug #118159
 void QueryTableTest::testConversionRate()
 {
   try {
     MyMoneyMoney firsConversionRate(1.1800, 10000);
     MyMoneyMoney secondConversionRate(1.1567, 10000);
     MyMoneyMoney amountWithdrawn(100);
 
     const auto acCadChecking = makeAccount(QString("Canadian Checking"), eMyMoney::Account::Type::Checkings, moZero, QDate(2017, 8, 1), acAsset, "CAD");
 
     makePrice("CAD", QDate(2017, 8, 1), firsConversionRate);
     makePrice("CAD", QDate(2017, 8, 2), secondConversionRate);
 
     TransactionHelper t1(QDate(2017, 8, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), amountWithdrawn, acCadChecking, acSolo, "CAD");
 
     MyMoneyReport filter;
     filter.setRowType(eMyMoney::Report::RowType::Account);
     filter.setDateFilter(QDate(2017, 8, 1), QDate(2017, 8, 2));
     filter.setName("Transactions by Account");
     auto cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category | eMyMoney::Report::QueryColumn::Balance;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl(filter);
 
     writeTabletoHTML(qtbl, "Transactions by Account (conversion rate).html");
 
     const auto rows = qtbl.rows();
 
     QVERIFY(rows.count() == 5);
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctValue]) == amountWithdrawn * firsConversionRate * MyMoneyMoney(-1));
     QVERIFY(MyMoneyMoney(rows[1][ListTable::ctPrice]) == firsConversionRate);
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctBalance]) == amountWithdrawn * secondConversionRate * MyMoneyMoney(-1));
     QVERIFY(MyMoneyMoney(rows[2][ListTable::ctPrice]) == secondConversionRate);
 
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 
 }
 
 //this is to prevent me from making mistakes again when modifying balances - asoliverez
 //this case tests only the opening and ending balance of the accounts
 void QueryTableTest::testBalanceColumn()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y1(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4q2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent2, acCredit, acParent);
     TransactionHelper t4y2(QDate(2004, 11, 7), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moChild, acCredit, acChild);
 
     unsigned cols;
 
     MyMoneyReport filter;
 
     filter.setRowType(eMyMoney::Report::RowType::Account);
     filter.setName("Transactions by Account");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category | eMyMoney::Report::QueryColumn::Balance;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));   //
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account.html");
 
     QString html = qtbl_3.renderHTML();
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 19);
 
     //this is to make sure that the dates of closing and opening balances and the balance numbers are ok
     QString openingDate = QLocale().toString(QDate(2004, 1, 1), QLocale::ShortFormat);
     QString closingDate = QLocale().toString(QDate(2005, 9, 1), QLocale::ShortFormat);
     QVERIFY(html.indexOf(openingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance")) > 0);
     QVERIFY(html.indexOf(closingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-702.36</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDate + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-705.69</td></tr>") > 0);
 
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 
 }
 
 void QueryTableTest::testBalanceColumnWithMultipleCurrencies()
 {
   try {
 
     MyMoneyMoney moJpyOpening(0.0, 1);
     MyMoneyMoney moJpyPrice(0.010, 100);
     MyMoneyMoney moJpyPrice2(0.011, 100);
     MyMoneyMoney moJpyPrice3(0.024, 100);
     MyMoneyMoney moTransaction(100, 1);
     MyMoneyMoney moJpyTransaction(100, 1);
 
     QString acJpyChecking = makeAccount(QString("Japanese Checking"), eMyMoney::Account::Type::Checkings, moJpyOpening, QDate(2003, 11, 15), acAsset, "JPY");
 
     makePrice("JPY", QDate(2004, 1, 1), MyMoneyMoney(moJpyPrice));
     makePrice("JPY", QDate(2004, 5, 1), MyMoneyMoney(moJpyPrice2));
     makePrice("JPY", QDate(2004, 6, 30), MyMoneyMoney(moJpyPrice3));
 
     QDate openingDate(2004, 2, 20);
     QDate intermediateDate(2004, 5, 20);
     QDate closingDate(2004, 7, 20);
 
     TransactionHelper t1(openingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t4(openingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     TransactionHelper t2(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t5(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     TransactionHelper t3(closingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Transfer),   MyMoneyMoney(moJpyTransaction), acJpyChecking, acChecking, "JPY");
     TransactionHelper t6(closingDate,      MyMoneySplit::actionName(eMyMoney::Split::Action::Deposit),    MyMoneyMoney(moTransaction),    acCredit,      acChecking);
     // test that an income/expense transaction that involves a currency exchange is properly reported
     TransactionHelper t7(intermediateDate, MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), MyMoneyMoney(moJpyTransaction), acJpyChecking, acSolo, "JPY");
 
     unsigned cols;
 
     MyMoneyReport filter;
 
     filter.setRowType(eMyMoney::Report::RowType::Account);
     filter.setName("Transactions by Account");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Category | eMyMoney::Report::QueryColumn::Balance;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));
     // don't convert values to the default currency
     filter.setConvertCurrency(false);
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Transactions by Account (multiple currencies).html");
 
     QString html = qtbl_3.renderHTML();
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QVERIFY(rows.count() == 24);
 
     //this is to make sure that the dates of closing and opening balances and the balance numbers are ok
     QString openingDateString = QLocale().toString(openingDate, QLocale::ShortFormat);
     QString intermediateDateString = QLocale().toString(intermediateDate, QLocale::ShortFormat);
     QString closingDateString = QLocale().toString(closingDate, QLocale::ShortFormat);
     // check the opening and closing balances
     QVERIFY(html.indexOf(openingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;0.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;304.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>USD&nbsp;-300.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>JPY&nbsp;-400.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 1.00 - price is 0.010 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000001>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;1.00</td><td>USD&nbsp;1.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 101.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000002>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;101.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 102.00 - price is 0.011 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000003>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;1.00</td><td>USD&nbsp;102.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 202.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000004>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;202.00</td></tr>") > 0);
 
     // after a transfer of 100 JPY the balance should be 204.00 - price is 0.024 (precision of 2)
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000005>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Japanese Checking</td><td class=\"value\">USD&nbsp;2.00</td><td>USD&nbsp;204.00</td></tr>") > 0);
 
     // after a transfer of 100 the balance should be 304.00
     QVERIFY(html.indexOf("<a href=ledger?id=A000001&tid=T000000000000000006>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer from Credit Card</td><td class=\"value\">USD&nbsp;100.00</td><td>USD&nbsp;304.00</td></tr>") > 0);
 
     // a 100.00 JPY withdrawal should be displayed as such even if the expense account uses another currency
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000007>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Solo</td><td class=\"value\">JPY&nbsp;-100.00</td><td>JPY&nbsp;-300.00</td></tr>") > 0);
 
     // now run the same report again but this time convert all values to the base currency and make sure the values are correct
     filter.setConvertCurrency(true);
     XMLandback(filter);
     QueryTable qtbl_4(filter);
 
     writeTabletoHTML(qtbl_4, "Transactions by Account (multiple currencies converted to base).html");
 
     html = qtbl_4.renderHTML();
 
     rows = qtbl_4.rows();
 
     QVERIFY(rows.count() == 23);
 
     // check the opening and closing balances
     QVERIFY(html.indexOf(openingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Opening Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;0.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;304.00</td></tr>") > 0);
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-300.00</td></tr>") > 0);
     // although the balance should be -5.00 it's -8.00 because the foreign currency balance is converted using the closing date price (0.024)
     QVERIFY(html.indexOf(closingDateString + "</td><td class=\"left0\"></td><td class=\"left0\">" + i18n("Closing Balance") + "</td><td class=\"left0\"></td><td class=\"value\"></td><td>&nbsp;-8.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -1.00 when converted to the base currency using the opening date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000001>" + openingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-1.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -1.00 when converted to the base currency using the intermediate date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000003>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-2.00</td></tr>") > 0);
 
     // a 100.00 JPY transfer should be displayed as -2.00 when converted to the base currency using the closing date price (notice the balance is -5.00)
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000005>" + closingDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Transfer to Checking Account</td><td class=\"value\">&nbsp;-2.00</td><td>&nbsp;-5.00</td></tr>") > 0);
 
     // a 100.00 JPY withdrawal should be displayed as -1.00 when converted to the base currency using the intermediate date price
     QVERIFY(html.indexOf("<a href=ledger?id=A000008&tid=T000000000000000007>" + intermediateDateString + "</a></td><td class=\"left0\"></td><td class=\"left0\">Test Payee</td><td class=\"left0\">Solo</td><td class=\"value\">&nbsp;-1.00</td><td>&nbsp;-3.00</td></tr>") > 0);
 
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 }
 
 void QueryTableTest::testTaxReport()
 {
   try {
     TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moSolo, acChecking, acSolo);
     TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::actionName(eMyMoney::Split::Action::Withdrawal), moParent1, acChecking, acTax);
 
     unsigned cols;
     MyMoneyReport filter;
 
     filter.setRowType(eMyMoney::Report::RowType::Category);
     filter.setName("Tax Transactions");
     cols = eMyMoney::Report::QueryColumn::Number | eMyMoney::Report::QueryColumn::Payee | eMyMoney::Report::QueryColumn::Account;
     filter.setQueryColumns(static_cast<eMyMoney::Report::QueryColumn>(cols));
     filter.setTax(true);
 
     XMLandback(filter);
     QueryTable qtbl_3(filter);
 
     writeTabletoHTML(qtbl_3, "Tax Transactions.html");
 
     QList<ListTable::TableRow> rows = qtbl_3.rows();
 
     QString html = qtbl_3.renderHTML();
     QVERIFY(rows.count() == 5);
   } catch (const MyMoneyException &e) {
     QFAIL(e.what());
   }
 }
+
+class QueryTableProtectedTester : QueryTable {
+public:
+  QueryTableProtectedTester(): QueryTable(MyMoneyReport(eMyMoney::Report::RowType::Account,
+      static_cast<unsigned>(eMyMoney::Report::ColumnType::Months),
+      eMyMoney::TransactionFilter::Date::YearToDate,
+      eMyMoney::Report::DetailLevel::Top,
+      "Yearly Budgeted vs. Actual", "Default Report")) {}
+
+  void testHelperROI() {
+    // (10 + 50 - 110 + 60 + 70) / (110 - 10)
+    QString result1 = helperROI(MyMoneyMoney(10), MyMoneyMoney(50), MyMoneyMoney(110), MyMoneyMoney(60), MyMoneyMoney(70));
+    QVERIFY(MyMoneyMoney(result1) == MyMoneyMoney(80, 100));
+
+    // (110 + 50 - 110 + 60 + 70) / (110 - 110)
+    QString result2 = helperROI(MyMoneyMoney(110), MyMoneyMoney(50), MyMoneyMoney(110), MyMoneyMoney(60), MyMoneyMoney(70));
+    QVERIFY(result2 == "");
+  }
+};
+
+void QueryTableTest::testProtectedMethods()
+{
+  try {
+    QueryTableProtectedTester().testHelperROI();
+  } catch (const MyMoneyException &e) {
+    QFAIL(e.what());
+  }
+}
diff --git a/kmymoney/plugins/views/reports/core/tests/querytable-test.h b/kmymoney/plugins/views/reports/core/tests/querytable-test.h
index 3b34934dc..ac74a1a08 100644
--- a/kmymoney/plugins/views/reports/core/tests/querytable-test.h
+++ b/kmymoney/plugins/views/reports/core/tests/querytable-test.h
@@ -1,48 +1,49 @@
 /*
  * Copyright 2005-2018  Thomas Baumgart <tbaumgart@kde.org>
  * Copyright 2005-2006  Ace Jones <acejones@users.sourceforge.net>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * 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 QUERYTABLETEST_H
 #define QUERYTABLETEST_H
 
 #include <QObject>
 #include "mymoneyfile.h"
 #include "mymoneystoragemgr.h"
 
 class QueryTableTest : public QObject
 {
   Q_OBJECT
 private:
   MyMoneyStorageMgr* storage;
   MyMoneyFile* file;
 
 private Q_SLOTS:
   void setup();
   void init();
   void cleanup();
   void testQueryBasics();
   void testCashFlowAnalysis();
   void testAccountQuery();
   void testInvestment();
   void testSplitShares();
   void testConversionRate();
   void testBalanceColumn();
   void testBalanceColumnWithMultipleCurrencies();
   void testTaxReport();
+  void testProtectedMethods();
 };
 
 #endif