diff --git a/kmymoney/dialogs/kbalancechartdlg.cpp b/kmymoney/dialogs/kbalancechartdlg.cpp
index 1fe79e402..0b19ad087 100644
--- a/kmymoney/dialogs/kbalancechartdlg.cpp
+++ b/kmymoney/dialogs/kbalancechartdlg.cpp
@@ -1,151 +1,151 @@
 /***************************************************************************
                           kbalancechartdlg  -  description
                              -------------------
     begin                : Mon Nov 26 2007
     copyright            : (C) 2007 by Thomas Baumgart
     email                : Thomas Baumgart <ipwizard@users.sourceforge.net>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kbalancechartdlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QLayout>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <kpushbutton.h>
 #include <klocale.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <mymoneyreport.h>
 #include <pivottable.h>
 #include <kmymoneyglobalsettings.h>
 
 KBalanceChartDlg::KBalanceChartDlg(const MyMoneyAccount& account, QWidget* parent) :
     KDialog(parent)
 {
   setCaption(i18n("Balance of %1", account.name()));
   setSizeGripEnabled(true);
   setModal(true);
   setButtons(KDialog::Close);
   setButtonsOrientation(Qt::Horizontal);
 
   // restore the last used dialog size
   KConfigGroup grp = KGlobal::config()->group("KBalanceChartDlg");
   if (grp.isValid()) {
     restoreDialogSize(grp);
   }
   // let the minimum size be 700x500
   resize(QSize(700, 500).expandedTo(size()));
 
   //draw the chart and add it to the main layout
   KReportChartView* chartWidget = drawChart(account);
   setMainWidget(chartWidget);
 }
 
 
 KBalanceChartDlg::~KBalanceChartDlg()
 {
   // store the last used dialog size
   KConfigGroup grp = KGlobal::config()->group("KBalanceChartDlg");
   if (grp.isValid()) {
     saveDialogSize(grp);
   }
 }
 
 KReportChartView* KBalanceChartDlg::drawChart(const MyMoneyAccount& account)
 {
   MyMoneyReport reportCfg = MyMoneyReport(
                               MyMoneyReport::eAssetLiability,
-                              MyMoneyReport::eMonths,
+                              MyMoneyReport::Column::Months,
                               MyMoneyTransactionFilter::last3ToNext3Months,
                               MyMoneyReport::eDetailTotal,
                               i18n("%1 Balance History", account.name()),
                               i18n("Generated Report")
                             );
   reportCfg.setChartByDefault(true);
   reportCfg.setChartGridLines(false);
   reportCfg.setChartDataLabels(false);
   reportCfg.setChartType(MyMoneyReport::eChartLine);
   reportCfg.setIncludingForecast(true);
   reportCfg.setIncludingBudgetActuals(true);
   if (account.accountType() == MyMoneyAccount::Investment) {
     QStringList::const_iterator it_a;
     for (it_a = account.accountList().begin(); it_a != account.accountList().end(); ++it_a)
       reportCfg.addAccount(*it_a);
   } else
     reportCfg.addAccount(account.id());
   reportCfg.setColumnsAreDays(true);
   reportCfg.setConvertCurrency(false);
   reportCfg.setMixedTime(true);
   reports::PivotTable table(reportCfg);
 
   reports::KReportChartView* chartWidget = new reports::KReportChartView(this);
 
   table.drawChart(*chartWidget);
 
   // add another row for limit
   bool needRow = false;
   bool haveMinBalance = false;
   bool haveMaxCredit = false;
   MyMoneyMoney minBalance, maxCredit;
   MyMoneyMoney factor(1, 1);
   if (account.accountGroup() == MyMoneyAccount::Asset)
     factor = -factor;
 
   if (account.value("maxCreditEarly").length() > 0) {
     needRow = true;
     haveMaxCredit = true;
     maxCredit = MyMoneyMoney(account.value("maxCreditEarly")) * factor;
   }
   if (account.value("maxCreditAbsolute").length() > 0) {
     needRow = true;
     haveMaxCredit = true;
     maxCredit = MyMoneyMoney(account.value("maxCreditAbsolute")) * factor;
   }
 
   if (account.value("minBalanceEarly").length() > 0) {
     needRow = true;
     haveMinBalance = true;
     minBalance = MyMoneyMoney(account.value("minBalanceEarly"));
   }
   if (account.value("minBalanceAbsolute").length() > 0) {
     needRow = true;
     haveMinBalance = true;
     minBalance = MyMoneyMoney(account.value("minBalanceAbsolute"));
   }
 
   if (needRow) {
     if (haveMinBalance) {
       chartWidget->drawLimitLine(minBalance.toDouble());
     }
     if (haveMaxCredit) {
       chartWidget->drawLimitLine(maxCredit.toDouble());
     }
   }
 
   // always draw the y axis zero value line
   chartWidget->drawLimitLine(0);
 
   //remove the legend
   chartWidget->removeLegend();
 
   return chartWidget;
 }
diff --git a/kmymoney/dialogs/kreportconfigurationfilterdlg.cpp b/kmymoney/dialogs/kreportconfigurationfilterdlg.cpp
index 7160a55c6..1299f499f 100644
--- a/kmymoney/dialogs/kreportconfigurationfilterdlg.cpp
+++ b/kmymoney/dialogs/kreportconfigurationfilterdlg.cpp
@@ -1,667 +1,667 @@
 /***************************************************************************
                           kreportconfigurationdlg.cpp  -  description
                              -------------------
     begin                : Mon Jun 21 2004
     copyright            : (C) 2000-2004 by Michael Edwardes
     email                : mte@users.sourceforge.net
                            Javier Campos Morales <javi_c@users.sourceforge.net>
                            Felix Rodriguez <frodriguez@users.sourceforge.net>
                            John C <thetacoturtle@users.sourceforge.net>
                            Thomas Baumgart <ipwizard@users.sourceforge.net>
                            Kevin Tambascio <ktambascio@users.sourceforge.net>
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kreportconfigurationfilterdlg.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QVariant>
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QLabel>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QLayout>
 #include <QSpinBox>
 #include <QToolTip>
 #include <QTabWidget>
 #include <QApplication>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <kapplication.h>
 #include <kpushbutton.h>
 #include <klineedit.h>
 #include <kcombobox.h>
 #include <kguiitem.h>
 #include <kiconloader.h>
 #include <kdebug.h>
 #include <klocale.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <kmymoneydateinput.h>
 #include <kmymoneyedit.h>
 #include <kmymoneylineedit.h>
 #include <kmymoneyaccountselector.h>
 #include <mymoneyfile.h>
 #include <mymoneyreport.h>
 #include <ktoolinvocation.h>
 #include "ui_kfindtransactiondlgdecl.h"
 
 KReportConfigurationFilterDlg::KReportConfigurationFilterDlg(
   MyMoneyReport report, QWidget *parent)
     : KFindTransactionDlg(parent, report.rowType() == MyMoneyReport::eAccount),
     m_tab2(0),
     m_tab3(0),
     m_tabChart(0),
     m_initialState(report),
     m_currentState(report)
 {
   //
   // Rework labeling
   //
 
   setWindowTitle(i18n("Report Configuration"));
   delete m_ui->TextLabel1;
 
   //
   // Rework the buttons
   //
 
   // the Apply button is always enabled
   disconnect(SIGNAL(selectionNotEmpty(bool)));
   enableButtonApply(true);
   setButtonGuiItem(KDialog::Apply, KStandardGuiItem::ok());
   setButtonToolTip(KDialog::Apply, i18nc("@info:tooltip for report configuration apply button", "Apply the configuration changes to the report"));
 
   //
   // Add new tabs
   //
 
   m_tab1 = new kMyMoneyReportConfigTab1Decl(m_ui->m_criteriaTab);
   m_tab1->setObjectName("kMyMoneyReportConfigTab1");
   m_ui->m_criteriaTab->insertTab(0, m_tab1, i18n("Report"));
 
   if (m_initialState.reportType() == MyMoneyReport::ePivotTable) {
     m_tab2 = new kMyMoneyReportConfigTab2Decl(m_ui->m_criteriaTab);
     m_tab2->setObjectName("kMyMoneyReportConfigTab2");
     m_ui->m_criteriaTab->insertTab(1, m_tab2, i18n("Rows/Columns"));
     connect(m_tab2->findChild<KComboBox*>("m_comboRows"), SIGNAL(activated(int)), this, SLOT(slotRowTypeChanged(int)));
     connect(m_tab2->findChild<KComboBox*>("m_comboColumns"), SIGNAL(activated(int)), this, SLOT(slotColumnTypeChanged(int)));
     connect(m_tab2->findChild<KComboBox*>("m_comboRows"), SIGNAL(activated(int)), this, SLOT(slotUpdateColumnsCombo()));
     connect(m_tab2->findChild<KComboBox*>("m_comboColumns"), SIGNAL(activated(int)), this, SLOT(slotUpdateColumnsCombo()));
     //control the state of the includeTransfer check
     connect(m_ui->m_categoriesView, SIGNAL(stateChanged()), this, SLOT(slotUpdateCheckTransfers()));
 
     m_tabChart = new kMyMoneyReportConfigTabChartDecl(m_ui->m_criteriaTab);
     m_tabChart->setObjectName("kMyMoneyReportConfigTabChart");
     m_ui->m_criteriaTab->insertTab(2, m_tabChart, i18n("Chart"));
   } else if (m_initialState.reportType() == MyMoneyReport::eQueryTable) {
     // eInvestmentHoldings is a special-case report, and you cannot configure the
     // rows & columns of that report.
     if (m_initialState.rowType() < MyMoneyReport::eAccountByTopAccount) {
       m_tab3 = new kMyMoneyReportConfigTab3Decl(m_ui->m_criteriaTab);
       m_tab3->setObjectName("kMyMoneyReportConfigTab3");
       m_ui->m_criteriaTab->insertTab(1, m_tab3, i18n("Rows/Columns"));
     }
   }
 
   m_ui->m_criteriaTab->setCurrentIndex(m_ui->m_criteriaTab->indexOf(m_tab1));
   m_ui->m_criteriaTab->setMinimumSize(500, 200);
 
   QList<MyMoneyBudget> list = MyMoneyFile::instance()->budgetList();
   QList<MyMoneyBudget>::const_iterator it_b;
   for (it_b = list.constBegin(); it_b != list.constEnd(); ++it_b) {
     m_budgets.push_back(*it_b);
   }
 
   //
   // Now set up the widgets with proper values
   //
   slotReset();
 }
 
 KReportConfigurationFilterDlg::~KReportConfigurationFilterDlg()
 {
 }
 
 void KReportConfigurationFilterDlg::slotSearch()
 {
   // setup the filter from the dialog widgets
   setupFilter();
 
   // Copy the m_filter over to the filter part of m_currentConfig.
   m_currentState.assignFilter(m_filter);
 
   // Then extract the report properties
   m_currentState.setName(m_tab1->findChild<KLineEdit*>("m_editName")->text());
   m_currentState.setComment(m_tab1->findChild<KLineEdit*>("m_editComment")->text());
   m_currentState.setConvertCurrency(m_tab1->findChild<QCheckBox*>("m_checkCurrency")->isChecked());
   m_currentState.setFavorite(m_tab1->findChild<QCheckBox*>("m_checkFavorite")->isChecked());
   m_currentState.setSkipZero(m_tab1->findChild<QCheckBox*>("m_skipZero")->isChecked());
 
   if (m_tab2) {
     MyMoneyReport::EDetailLevel dl[4] = { MyMoneyReport::eDetailAll, MyMoneyReport::eDetailTop, MyMoneyReport::eDetailGroup, MyMoneyReport::eDetailTotal };
 
     m_currentState.setDetailLevel(dl[m_tab2->findChild<KComboBox*>("m_comboDetail")->currentIndex()]);
 
     // modify the rowtype only if the widget is enabled
     if (m_tab2->findChild<KComboBox*>("m_comboRows")->isEnabled()) {
       MyMoneyReport::ERowType rt[2] = { MyMoneyReport::eExpenseIncome, MyMoneyReport::eAssetLiability };
       m_currentState.setRowType(rt[m_tab2->findChild<KComboBox*>("m_comboRows")->currentIndex()]);
     }
 
     m_currentState.setShowingRowTotals(false);
     if (m_tab2->findChild<KComboBox*>("m_comboRows")->currentIndex() == 0)
       m_currentState.setShowingRowTotals(m_tab2->findChild<QCheckBox*>("m_checkTotalColumn")->isChecked());
 
-    MyMoneyReport::EColumnType ct[6] = { MyMoneyReport::eDays, MyMoneyReport::eWeeks, MyMoneyReport::eMonths, MyMoneyReport::eBiMonths, MyMoneyReport::eQuarters, MyMoneyReport::eYears };
+    MyMoneyReport::Column::Type ct[6] = { MyMoneyReport::Column::Days, MyMoneyReport::Column::Weeks, MyMoneyReport::Column::Months, MyMoneyReport::Column::BiMonths, MyMoneyReport::Column::Quarters, MyMoneyReport::Column::Years };
     bool dy[6] = { true, true, false, false, false, false };
     m_currentState.setColumnType(ct[m_tab2->findChild<KComboBox*>("m_comboColumns")->currentIndex()]);
 
     //TODO (Ace) This should be implicit in the call above.  MMReport needs fixin'
     m_currentState.setColumnsAreDays(dy[m_tab2->findChild<KComboBox*>("m_comboColumns")->currentIndex()]);
 
     m_currentState.setIncludingSchedules(m_tab2->findChild<QCheckBox*>("m_checkScheduled")->isChecked());
 
     m_currentState.setIncludingTransfers(m_tab2->findChild<QCheckBox*>("m_checkTransfers")->isChecked());
 
     m_currentState.setIncludingUnusedAccounts(m_tab2->findChild<QCheckBox*>("m_checkUnused")->isChecked());
 
     if (m_tab2->findChild<KMyMoneyGeneralCombo*>("m_comboBudget")->isEnabled()) {
       m_currentState.setBudget(m_budgets[m_tab2->findChild<KMyMoneyGeneralCombo*>("m_comboBudget")->currentItem()].id(), m_initialState.rowType() == MyMoneyReport::eBudgetActual);
     } else {
       m_currentState.setBudget(QString(), false);
     }
 
     //set moving average days
     if (m_tab2->findChild<QSpinBox*>("m_movingAverageDays")->isEnabled()) {
       m_currentState.setMovingAverageDays(m_tab2->findChild<QSpinBox*>("m_movingAverageDays")->value());
     }
   } else if (m_tab3) {
     MyMoneyReport::ERowType rtq[8] = { MyMoneyReport::eCategory, MyMoneyReport::eTopCategory, MyMoneyReport::eTag, MyMoneyReport::ePayee, MyMoneyReport::eAccount, MyMoneyReport::eTopAccount, MyMoneyReport::eMonth, MyMoneyReport::eWeek };
     m_currentState.setRowType(rtq[m_tab3->findChild<KComboBox*>("m_comboOrganizeBy")->currentIndex()]);
 
     unsigned qc = MyMoneyReport::eQCnone;
 
     if (m_currentState.queryColumns() & MyMoneyReport::eQCloan)
       // once a loan report, always a loan report
       qc = MyMoneyReport::eQCloan;
 
     if (m_tab3->findChild<QCheckBox*>("m_checkNumber")->isChecked())
       qc |= MyMoneyReport::eQCnumber;
     if (m_tab3->findChild<QCheckBox*>("m_checkPayee")->isChecked())
       qc |= MyMoneyReport::eQCpayee;
     if (m_tab3->findChild<QCheckBox*>("m_checkTag")->isChecked())
       qc |= MyMoneyReport::eQCtag;
     if (m_tab3->findChild<QCheckBox*>("m_checkCategory")->isChecked())
       qc |= MyMoneyReport::eQCcategory;
     if (m_tab3->findChild<QCheckBox*>("m_checkMemo")->isChecked())
       qc |= MyMoneyReport::eQCmemo;
     if (m_tab3->findChild<QCheckBox*>("m_checkAccount")->isChecked())
       qc |= MyMoneyReport::eQCaccount;
     if (m_tab3->findChild<QCheckBox*>("m_checkReconciled")->isChecked())
       qc |= MyMoneyReport::eQCreconciled;
     if (m_tab3->findChild<QCheckBox*>("m_checkAction")->isChecked())
       qc |= MyMoneyReport::eQCaction;
     if (m_tab3->findChild<QCheckBox*>("m_checkShares")->isChecked())
       qc |= MyMoneyReport::eQCshares;
     if (m_tab3->findChild<QCheckBox*>("m_checkPrice")->isChecked())
       qc |= MyMoneyReport::eQCprice;
     if (m_tab3->findChild<QCheckBox*>("m_checkBalance")->isChecked())
       qc |= MyMoneyReport::eQCbalance;
 
     m_currentState.setQueryColumns(static_cast<MyMoneyReport::EQueryColumns>(qc));
 
     m_currentState.setTax(m_tab3->findChild<QCheckBox*>("m_checkTax")->isChecked());
     m_currentState.setInvestmentsOnly(m_tab3->findChild<QCheckBox*>("m_checkInvestments")->isChecked());
     m_currentState.setLoansOnly(m_tab3->findChild<QCheckBox*>("m_checkLoans")->isChecked());
 
     m_currentState.setDetailLevel(m_tab3->findChild<QCheckBox*>("m_checkHideSplitDetails")->isChecked() ?
                                   MyMoneyReport::eDetailNone : MyMoneyReport::eDetailAll);
   }
 
   if (m_tabChart) {
     MyMoneyReport::EChartType ct[5] = { MyMoneyReport::eChartLine, MyMoneyReport::eChartBar, MyMoneyReport::eChartStackedBar, MyMoneyReport::eChartPie, MyMoneyReport::eChartRing };
     m_currentState.setChartType(ct[m_tabChart->findChild<KMyMoneyGeneralCombo*>("m_comboType")->currentIndex()]);
 
     m_currentState.setChartGridLines(m_tabChart->findChild<QCheckBox*>("m_checkGridLines")->isChecked());
     m_currentState.setChartDataLabels(m_tabChart->findChild<QCheckBox*>("m_checkValues")->isChecked());
     m_currentState.setChartByDefault(m_tabChart->findChild<QCheckBox*>("m_checkShowChart")->isChecked());
     m_currentState.setChartLineWidth(m_tabChart->findChild<QSpinBox*>("m_lineWidth")->value());
   }
 
   // setup the date lock
   MyMoneyTransactionFilter::dateOptionE range = m_ui->m_dateRange->currentItem();
   m_currentState.setDateFilter(range);
 
   done(true);
 }
 
 void KReportConfigurationFilterDlg::slotRowTypeChanged(int row)
 {
   m_tab2->findChild<QCheckBox*>("m_checkTotalColumn")->setEnabled(row == 0);
 }
 
 void KReportConfigurationFilterDlg::slotColumnTypeChanged(int row)
 {
   if ((m_tab2->findChild<KMyMoneyGeneralCombo*>("m_comboBudget")->isEnabled() && row < 2)) {
     m_tab2->findChild<KComboBox*>("m_comboColumns")->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
   }
 }
 
 void KReportConfigurationFilterDlg::slotUpdateColumnsCombo()
 {
   const int monthlyIndex = 2;
   const int incomeExpenseIndex = 0;
   const bool isIncomeExpenseForecast = m_currentState.isIncludingForecast() && m_tab2->findChild<KComboBox*>("m_comboRows")->currentIndex() == incomeExpenseIndex;
   if (isIncomeExpenseForecast && m_tab2->findChild<KComboBox*>("m_comboColumns")->currentIndex() != monthlyIndex) {
     m_tab2->findChild<KComboBox*>("m_comboColumns")->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
   }
 }
 
 void KReportConfigurationFilterDlg::slotReset()
 {
   //
   // Set up the widget from the initial filter
   //
   m_currentState = m_initialState;
 
   //
   // Report Properties
   //
 
   m_tab1->findChild<KLineEdit*>("m_editName")->setText(m_initialState.name());
   m_tab1->findChild<KLineEdit*>("m_editComment")->setText(m_initialState.comment());
   m_tab1->findChild<QCheckBox*>("m_checkCurrency")->setChecked(m_initialState.isConvertCurrency());
   m_tab1->findChild<QCheckBox*>("m_checkFavorite")->setChecked(m_initialState.isFavorite());
 
   if (m_initialState.isIncludingPrice() || m_initialState.isSkippingZero()) {
     m_tab1->findChild<QCheckBox*>("m_skipZero")->setChecked(m_initialState.isSkippingZero());
   } else {
     m_tab1->findChild<QCheckBox*>("m_skipZero")->setEnabled(false);
   }
 
   if (m_tab2) {
     KComboBox *combo = m_tab2->findChild<KComboBox*>("m_comboDetail");
     switch (m_initialState.detailLevel()) {
       case MyMoneyReport::eDetailNone:
       case MyMoneyReport::eDetailEnd:
       case MyMoneyReport::eDetailAll:
         combo->setCurrentItem(i18nc("All accounts", "All"), false);
         break;
       case MyMoneyReport::eDetailTop:
         combo->setCurrentItem(i18n("Top-Level"), false);
         break;
       case MyMoneyReport::eDetailGroup:
         combo->setCurrentItem(i18n("Groups"), false);
         break;
       case MyMoneyReport::eDetailTotal:
         combo->setCurrentItem(i18n("Totals"), false);
         break;
     }
 
     combo = m_tab2->findChild<KComboBox*>("m_comboRows");
     switch (m_initialState.rowType()) {
       case MyMoneyReport::eExpenseIncome:
       case MyMoneyReport::eBudget:
       case MyMoneyReport::eBudgetActual:
         combo->setCurrentItem(i18n("Income & Expenses"), false); // income / expense
         break;
       default:
         combo->setCurrentItem(i18n("Assets & Liabilities"), false); // asset / liability
         break;
     }
     m_tab2->findChild<QCheckBox*>("m_checkTotalColumn")->setChecked(m_initialState.isShowingRowTotals());
 
     slotRowTypeChanged(combo->currentIndex());
 
     combo = m_tab2->findChild<KComboBox*>("m_comboColumns");
     if (m_initialState.isColumnsAreDays()) {
       switch (m_initialState.columnType()) {
-        case MyMoneyReport::eNoColumns:
-        case MyMoneyReport::eDays:
+        case MyMoneyReport::Column::NoColumns:
+        case MyMoneyReport::Column::Days:
           combo->setCurrentItem(i18nc("@item the columns will display daily data", "Daily"), false);
           break;
-        case MyMoneyReport::eWeeks:
+        case MyMoneyReport::Column::Weeks:
           combo->setCurrentItem(i18nc("@item the columns will display weekly data", "Weekly"), false);
           break;
         default:
           break;
       }
     } else {
       switch (m_initialState.columnType()) {
-        case MyMoneyReport::eNoColumns:
-        case MyMoneyReport::eMonths:
+        case MyMoneyReport::Column::NoColumns:
+        case MyMoneyReport::Column::Months:
           combo->setCurrentItem(i18nc("@item the columns will display monthly data", "Monthly"), false);
           break;
-        case MyMoneyReport::eBiMonths:
+        case MyMoneyReport::Column::BiMonths:
           combo->setCurrentItem(i18nc("@item the columns will display bi-monthly data", "Bi-Monthly"), false);
           break;
-        case MyMoneyReport::eQuarters:
+        case MyMoneyReport::Column::Quarters:
           combo->setCurrentItem(i18nc("@item the columns will display quarterly data", "Quarterly"), false);
           break;
-        case MyMoneyReport::eYears:
+        case MyMoneyReport::Column::Years:
           combo->setCurrentItem(i18nc("@item the columns will display yearly data", "Yearly"), false);
           break;
         default:
           break;
       }
     }
 
     //load budgets combo
     if (m_initialState.rowType() == MyMoneyReport::eBudget
         || m_initialState.rowType() == MyMoneyReport::eBudgetActual) {
       m_tab2->findChild<KComboBox*>("m_comboRows")->setEnabled(false);
       m_tab2->findChild<QFrame*>("m_budgetFrame")->setEnabled(!m_budgets.empty());
       int i = 0;
       for (QVector<MyMoneyBudget>::const_iterator it_b = m_budgets.constBegin(); it_b != m_budgets.constEnd(); ++it_b) {
         m_tab2->findChild<KMyMoneyGeneralCombo*>("m_comboBudget")->insertItem((*it_b).name(), i);
         //set the current selected item
         if ((m_initialState.budget() == "Any" && (*it_b).budgetStart().year() == QDate::currentDate().year())
             || m_initialState.budget() == (*it_b).id())
           m_tab2->findChild<KMyMoneyGeneralCombo*>("m_comboBudget")->setCurrentItem(i);
         i++;
       }
     }
 
     //set moving average days spinbox
     QSpinBox *spinbox = m_tab2->findChild<QSpinBox*>("m_movingAverageDays");
     spinbox->setEnabled(m_initialState.isIncludingMovingAverage());
     if (m_initialState.isIncludingMovingAverage()) {
       spinbox->setValue(m_initialState.movingAverageDays());
     }
 
     m_tab2->findChild<QCheckBox*>("m_checkScheduled")->setChecked(m_initialState.isIncludingSchedules());
     m_tab2->findChild<QCheckBox*>("m_checkTransfers")->setChecked(m_initialState.isIncludingTransfers());
     m_tab2->findChild<QCheckBox*>("m_checkUnused")->setChecked(m_initialState.isIncludingUnusedAccounts());
   } else if (m_tab3) {
     KComboBox *combo = m_tab3->findChild<KComboBox*>("m_comboOrganizeBy");
     switch (m_initialState.rowType()) {
-      case MyMoneyReport::eNoColumns:
+      case MyMoneyReport::Column::NoColumns:
       case MyMoneyReport::eCategory:
         combo->setCurrentItem(i18n("Categories"), false);
         break;
       case MyMoneyReport::eTopCategory:
         combo->setCurrentItem(i18n("Top Categories"), false);
         break;
       case MyMoneyReport::eTag:
         combo->setCurrentItem(i18n("Tags"), false);
         break;
       case MyMoneyReport::ePayee:
         combo->setCurrentItem(i18n("Payees"), false);
         break;
       case MyMoneyReport::eAccount:
         combo->setCurrentItem(i18n("Accounts"), false);
         break;
       case MyMoneyReport::eTopAccount:
         combo->setCurrentItem(i18n("Top Accounts"), false);
         break;
       case MyMoneyReport::eMonth:
         combo->setCurrentItem(i18n("Month"), false);
         break;
       case MyMoneyReport::eWeek:
         combo->setCurrentItem(i18n("Week"), false);
         break;
       default:
         throw MYMONEYEXCEPTION("KReportConfigurationFilterDlg::slotReset(): QueryTable report has invalid rowtype");
     }
 
     unsigned qc = m_initialState.queryColumns();
     m_tab3->findChild<QCheckBox*>("m_checkNumber")->setChecked(qc & MyMoneyReport::eQCnumber);
     m_tab3->findChild<QCheckBox*>("m_checkPayee")->setChecked(qc & MyMoneyReport::eQCpayee);
     m_tab3->findChild<QCheckBox*>("m_checkTag")->setChecked(qc & MyMoneyReport::eQCtag);
     m_tab3->findChild<QCheckBox*>("m_checkCategory")->setChecked(qc & MyMoneyReport::eQCcategory);
     m_tab3->findChild<QCheckBox*>("m_checkMemo")->setChecked(qc & MyMoneyReport::eQCmemo);
     m_tab3->findChild<QCheckBox*>("m_checkAccount")->setChecked(qc & MyMoneyReport::eQCaccount);
     m_tab3->findChild<QCheckBox*>("m_checkReconciled")->setChecked(qc & MyMoneyReport::eQCreconciled);
     m_tab3->findChild<QCheckBox*>("m_checkAction")->setChecked(qc & MyMoneyReport::eQCaction);
     m_tab3->findChild<QCheckBox*>("m_checkShares")->setChecked(qc & MyMoneyReport::eQCshares);
     m_tab3->findChild<QCheckBox*>("m_checkPrice")->setChecked(qc & MyMoneyReport::eQCprice);
     m_tab3->findChild<QCheckBox*>("m_checkBalance")->setChecked(qc & MyMoneyReport::eQCbalance);
 
     m_tab3->findChild<QCheckBox*>("m_checkTax")->setChecked(m_initialState.isTax());
     m_tab3->findChild<QCheckBox*>("m_checkInvestments")->setChecked(m_initialState.isInvestmentsOnly());
     m_tab3->findChild<QCheckBox*>("m_checkLoans")->setChecked(m_initialState.isLoansOnly());
 
     m_tab3->findChild<QCheckBox*>("m_checkHideSplitDetails")->setChecked
     (m_initialState.detailLevel() == MyMoneyReport::eDetailNone);
   }
 
   if (m_tabChart) {
     KMyMoneyGeneralCombo* combo = m_tabChart->findChild<KMyMoneyGeneralCombo*>("m_comboType");
     switch (m_initialState.chartType()) {
       case MyMoneyReport::eChartNone:
         combo->setCurrentItem(MyMoneyReport::eChartLine);
         break;
       case MyMoneyReport::eChartLine:
       case MyMoneyReport::eChartBar:
       case MyMoneyReport::eChartStackedBar:
       case MyMoneyReport::eChartPie:
       case MyMoneyReport::eChartRing:
         combo->setCurrentItem(m_initialState.chartType());
         break;
       case MyMoneyReport::eChartEnd:
         throw MYMONEYEXCEPTION("KReportConfigurationFilterDlg::slotReset(): Report has invalid charttype");
     }
     m_tabChart->findChild<QCheckBox*>("m_checkGridLines")->setChecked(m_initialState.isChartGridLines());
     m_tabChart->findChild<QCheckBox*>("m_checkValues")->setChecked(m_initialState.isChartDataLabels());
     m_tabChart->findChild<QCheckBox*>("m_checkShowChart")->setChecked(m_initialState.isChartByDefault());
     m_tabChart->findChild<QSpinBox*>("m_lineWidth")->setValue(m_initialState.chartLineWidth());
   }
 
   //
   // Text Filter
   //
 
   QRegExp textfilter;
   if (m_initialState.textFilter(textfilter)) {
     m_ui->m_textEdit->setText(textfilter.pattern());
     m_ui->m_caseSensitive->setChecked(Qt::CaseSensitive == textfilter.caseSensitivity());
     m_ui->m_regExp->setChecked(QRegExp::RegExp == textfilter.patternSyntax());
     m_ui->m_textNegate->setCurrentIndex(m_initialState.isInvertingText());
   }
 
   //
   // Type & State Filters
   //
 
   int type;
   if (m_initialState.firstType(type))
     m_ui->m_typeBox->setCurrentIndex(type);
 
   int state;
   if (m_initialState.firstState(state))
     m_ui->m_stateBox->setCurrentIndex(state);
 
   //
   // Number Filter
   //
 
   QString nrFrom, nrTo;
   if (m_initialState.numberFilter(nrFrom, nrTo)) {
     if (nrFrom == nrTo) {
       m_ui->m_nrEdit->setEnabled(true);
       m_ui->m_nrFromEdit->setEnabled(false);
       m_ui->m_nrToEdit->setEnabled(false);
       m_ui->m_nrEdit->setText(nrFrom);
       m_ui->m_nrFromEdit->setText(QString());
       m_ui->m_nrToEdit->setText(QString());
       m_ui->m_nrButton->setChecked(true);
       m_ui->m_nrRangeButton->setChecked(false);
     } else {
       m_ui->m_nrEdit->setEnabled(false);
       m_ui->m_nrFromEdit->setEnabled(true);
       m_ui->m_nrToEdit->setEnabled(false);
       m_ui->m_nrEdit->setText(QString());
       m_ui->m_nrFromEdit->setText(nrFrom);
       m_ui->m_nrToEdit->setText(nrTo);
       m_ui->m_nrButton->setChecked(false);
       m_ui->m_nrRangeButton->setChecked(true);
     }
   } else {
     m_ui->m_nrEdit->setEnabled(true);
     m_ui->m_nrFromEdit->setEnabled(false);
     m_ui->m_nrToEdit->setEnabled(false);
     m_ui->m_nrEdit->setText(QString());
     m_ui->m_nrFromEdit->setText(QString());
     m_ui->m_nrToEdit->setText(QString());
     m_ui->m_nrButton->setChecked(true);
     m_ui->m_nrRangeButton->setChecked(false);
   }
 
   //
   // Amount Filter
   //
 
   MyMoneyMoney from, to;
   if (m_initialState.amountFilter(from, to)) { // bool getAmountFilter(MyMoneyMoney&,MyMoneyMoney&);
     if (from == to) {
       m_ui->m_amountEdit->setEnabled(true);
       m_ui->m_amountFromEdit->setEnabled(false);
       m_ui->m_amountToEdit->setEnabled(false);
       m_ui->m_amountEdit->loadText(QString::number(from.toDouble()));
       m_ui->m_amountFromEdit->loadText(QString());
       m_ui->m_amountToEdit->loadText(QString());
       m_ui->m_amountButton->setChecked(true);
       m_ui->m_amountRangeButton->setChecked(false);
     } else {
       m_ui->m_amountEdit->setEnabled(false);
       m_ui->m_amountFromEdit->setEnabled(true);
       m_ui->m_amountToEdit->setEnabled(true);
       m_ui->m_amountEdit->loadText(QString());
       m_ui->m_amountFromEdit->loadText(QString::number(from.toDouble()));
       m_ui->m_amountToEdit->loadText(QString::number(to.toDouble()));
       m_ui->m_amountButton->setChecked(false);
       m_ui->m_amountRangeButton->setChecked(true);
     }
   } else {
     m_ui->m_amountEdit->setEnabled(true);
     m_ui->m_amountFromEdit->setEnabled(false);
     m_ui->m_amountToEdit->setEnabled(false);
     m_ui->m_amountEdit->loadText(QString());
     m_ui->m_amountFromEdit->loadText(QString());
     m_ui->m_amountToEdit->loadText(QString());
     m_ui->m_amountButton->setChecked(true);
     m_ui->m_amountRangeButton->setChecked(false);
   }
 
   //
   // Payees Filter
   //
 
   QStringList payees;
   if (m_initialState.payees(payees)) {
     if (payees.empty()) {
       m_ui->m_emptyPayeesButton->setChecked(true);
     } else {
       selectAllItems(m_ui->m_payeesView, false);
       selectItems(m_ui->m_payeesView, payees, true);
     }
   } else {
     selectAllItems(m_ui->m_payeesView, true);
   }
 
   //
   // Tags Filter
   //
 
   QStringList tags;
   if (m_initialState.tags(tags)) {
     if (tags.empty()) {
       m_ui->m_emptyTagsButton->setChecked(true);
     } else {
       selectAllItems(m_ui->m_tagsView, false);
       selectItems(m_ui->m_tagsView, tags, true);
     }
   } else {
     selectAllItems(m_ui->m_tagsView, true);
   }
 
   //
   // Accounts Filter
   //
 
   QStringList accounts;
   if (m_initialState.accounts(accounts)) {
     m_ui->m_accountsView->selectAllItems(false);
     m_ui->m_accountsView->selectItems(accounts, true);
   } else
     m_ui->m_accountsView->selectAllItems(true);
 
   //
   // Categories Filter
   //
 
   if (m_initialState.categories(accounts)) {
     m_ui->m_categoriesView->selectAllItems(false);
     m_ui->m_categoriesView->selectItems(accounts, true);
   } else
     m_ui->m_categoriesView->selectAllItems(true);
 
   //
   // Date Filter
   //
 
   // the following call implies a call to slotUpdateSelections,
   // that's why we call it last
 
   m_initialState.updateDateFilter();
   QDate dateFrom, dateTo;
   if (m_initialState.dateFilter(dateFrom, dateTo)) {
     if (m_initialState.isUserDefined()) {
       m_ui->m_dateRange->setCurrentItem(MyMoneyTransactionFilter::userDefined);
       m_ui->m_fromDate->setDate(dateFrom);
       m_ui->m_toDate->setDate(dateTo);
     } else {
       m_ui->m_fromDate->setDate(dateFrom);
       m_ui->m_toDate->setDate(dateTo);
       KFindTransactionDlg::slotDateChanged();
     }
   } else {
     m_ui->m_dateRange->setCurrentItem(MyMoneyTransactionFilter::allDates);
     slotDateRangeChanged(MyMoneyTransactionFilter::allDates);
   }
 
   slotRightSize();
 }
 
 void KReportConfigurationFilterDlg::slotDateChanged()
 {
   if (m_ui->m_dateRange->currentItem() != MyMoneyTransactionFilter::userDefined) {
     KFindTransactionDlg::slotDateChanged();
   }
   slotUpdateSelections();
 }
 
 void KReportConfigurationFilterDlg::slotShowHelp()
 {
   KToolInvocation::invokeHelp("details.reports.config");
 }
 
 //TODO Fix the reports and engine to include transfers even if categories are filtered - bug #1523508
 void KReportConfigurationFilterDlg::slotUpdateCheckTransfers()
 {
   QCheckBox* cb = m_tab2->findChild<QCheckBox*>("m_checkTransfers");
   if (!m_ui->m_categoriesView->allItemsSelected()) {
     cb->setChecked(false);
     cb->setDisabled(true);
   } else {
     cb->setEnabled(true);
   }
 }
diff --git a/kmymoney/mymoney/mymoneyreport.cpp b/kmymoney/mymoney/mymoneyreport.cpp
index 979ceccdb..223cd0d06 100644
--- a/kmymoney/mymoney/mymoneyreport.cpp
+++ b/kmymoney/mymoney/mymoneyreport.cpp
@@ -1,868 +1,869 @@
 /***************************************************************************
                           mymoneyreport.cpp
                              -------------------
     begin                : Sun July 4 2004
     copyright            : (C) 2004-2005 by Ace Jones
     email                : acejones@users.sourceforge.net
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "mymoneyreport.h"
 #include <kmymoneyglobalsettings.h>
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QString>
 #include <QList>
 #include <QtDebug>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include "mymoneyfile.h"
 #include "reportdebug.h"
 
+const QStringList MyMoneyReport::Column::kTypeText = QString("none,months,bimonths,quarters,4,5,6,weeks,8,9,10,11,years").split(',');
+
 const QStringList MyMoneyReport::kRowTypeText = QString("none,assetliability,expenseincome,category,topcategory,account,tag,payee,month,week,topaccount,topaccount-account,equitytype,accounttype,institution,budget,budgetactual,schedule,accountinfo,accountloaninfo,accountreconcile,cashflow").split(',');
-const QStringList MyMoneyReport::kColumnTypeText = QString("none,months,bimonths,quarters,4,5,6,weeks,8,9,10,11,years").split(',');
 
 // if you add names here, don't forget to update the bitmap for EQueryColumns
 // and shift the bit for eQCend one position to the left
 const QStringList MyMoneyReport::kQueryColumnsText = QString("none,number,payee,category,tag,memo,account,reconcileflag,action,shares,price,performance,loan,balance").split(',');
 
 const MyMoneyReport::EReportType MyMoneyReport::kTypeArray[] = { eNoReport, ePivotTable, ePivotTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, eQueryTable, ePivotTable, ePivotTable, eInfoTable, eInfoTable, eInfoTable, eQueryTable, eQueryTable, eNoReport };
 const QStringList MyMoneyReport::kDetailLevelText = QString("none,all,top,group,total,invalid").split(',');
 const QStringList MyMoneyReport::kChartTypeText = QString("none,line,bar,pie,ring,stackedbar,invalid").split(',');
 
 // This should live in mymoney/mymoneytransactionfilter.h
 const QStringList kTypeText = QString("all,payments,deposits,transfers,none").split(',');
 const QStringList kStateText = QString("all,notreconciled,cleared,reconciled,frozen,none").split(',');
 const QStringList kDateLockText = QString("alldates,untiltoday,currentmonth,currentyear,monthtodate,yeartodate,yeartomonth,lastmonth,lastyear,last7days,last30days,last3months,last6months,last12months,next7days,next30days,next3months,next6months,next12months,userdefined,last3tonext3months,last11Months,currentQuarter,lastQuarter,nextQuarter,currentFiscalYear,lastFiscalYear,today,next18months").split(',');
 const QStringList kAccountTypeText = QString("unknown,checkings,savings,cash,creditcard,loan,certificatedep,investment,moneymarket,asset,liability,currency,income,expense,assetloan,stock,equity,invalid").split(',');
 
 MyMoneyReport::MyMoneyReport() :
     m_name("Unconfigured Pivot Table Report"),
     m_detailLevel(eDetailNone),
     m_convertCurrency(true),
     m_favorite(false),
     m_tax(false),
     m_investments(false),
     m_loans(false),
     m_reportType(kTypeArray[eExpenseIncome]),
     m_rowType(eExpenseIncome),
-    m_columnType(eMonths),
+    m_columnType(Column::Months),
     m_columnsAreDays(false),
     m_queryColumns(eQCnone),
     m_dateLock(userDefined),
     m_accountGroupFilter(false),
     m_chartType(eChartLine),
     m_chartDataLabels(true),
     m_chartGridLines(true),
     m_chartByDefault(false),
     m_includeSchedules(false),
     m_includeTransfers(false),
     m_includeBudgetActuals(false),
     m_includeUnusedAccounts(false),
     m_showRowTotals(false),
     m_includeForecast(false),
     m_includeMovingAverage(false),
     m_movingAverageDays(0),
     m_includePrice(false),
     m_includeAveragePrice(false),
     m_mixedTime(false),
     m_currentDateColumn(0),
     m_skipZero(false)
 {
   m_chartLineWidth = m_lineWidth;
 }
 
 MyMoneyReport::MyMoneyReport(const QString& id, const MyMoneyReport& right) :
     MyMoneyObject(id),
     m_movingAverageDays(0),
     m_currentDateColumn(0)
 {
   *this = right;
   setId(id);
 }
 
 MyMoneyReport::MyMoneyReport(ERowType _rt, unsigned _ct, dateOptionE _dl, EDetailLevel _ss, const QString& _name, const QString& _comment) :
     m_name(_name),
     m_comment(_comment),
     m_detailLevel(_ss),
     m_convertCurrency(true),
     m_favorite(false),
     m_tax(false),
     m_investments(false),
     m_loans(false),
     m_reportType(kTypeArray[_rt]),
     m_rowType(_rt),
-    m_columnType(eMonths),
+    m_columnType(Column::Months),
     m_columnsAreDays(false),
     m_queryColumns(eQCnone),
     m_dateLock(_dl),
     m_accountGroupFilter(false),
     m_chartType(eChartLine),
     m_chartDataLabels(true),
     m_chartGridLines(true),
     m_chartByDefault(false),
     m_includeSchedules(false),
     m_includeTransfers(false),
     m_includeBudgetActuals(false),
     m_includeUnusedAccounts(false),
     m_showRowTotals(false),
     m_includeForecast(false),
     m_includeMovingAverage(false),
     m_movingAverageDays(0),
     m_includePrice(false),
     m_includeAveragePrice(false),
     m_mixedTime(false),
     m_currentDateColumn(0),
     m_skipZero(false)
 {
   //set initial values
   m_chartLineWidth = m_lineWidth;
 
   //set report type
   if (m_reportType == ePivotTable)
-    m_columnType = static_cast<EColumnType>(_ct);
+    m_columnType = static_cast<Column::Type>(_ct);
   if (m_reportType == eQueryTable)
     m_queryColumns = static_cast<EQueryColumns>(_ct);
   setDateFilter(_dl);
 
   //throw exception if the type is inconsistent
   if ((_rt > static_cast<ERowType>(sizeof(kTypeArray) / sizeof(kTypeArray[0])))
       || (m_reportType == eNoReport))
     throw MYMONEYEXCEPTION("Invalid report type");
 
   //add the corresponding account groups
   if (_rt == MyMoneyReport::eAssetLiability) {
     addAccountGroup(MyMoneyAccount::Asset);
     addAccountGroup(MyMoneyAccount::Liability);
     m_showRowTotals = true;
   }
   if (_rt == MyMoneyReport::eAccount) {
     addAccountGroup(MyMoneyAccount::Asset);
     addAccountGroup(MyMoneyAccount::AssetLoan);
     addAccountGroup(MyMoneyAccount::Cash);
     addAccountGroup(MyMoneyAccount::Checkings);
     addAccountGroup(MyMoneyAccount::CreditCard);
     if (KMyMoneyGlobalSettings::expertMode())
       addAccountGroup(MyMoneyAccount::Equity);
     addAccountGroup(MyMoneyAccount::Expense);
     addAccountGroup(MyMoneyAccount::Income);
     addAccountGroup(MyMoneyAccount::Liability);
     addAccountGroup(MyMoneyAccount::Loan);
     addAccountGroup(MyMoneyAccount::Savings);
     addAccountGroup(MyMoneyAccount::Stock);
     m_showRowTotals = true;
   }
   if (_rt == MyMoneyReport::eExpenseIncome) {
     addAccountGroup(MyMoneyAccount::Expense);
     addAccountGroup(MyMoneyAccount::Income);
     m_showRowTotals = true;
   }
   //FIXME take this out once we have sorted out all issues regarding budget of assets and liabilities -- asoliverez@gmail.com
   if (_rt == MyMoneyReport::eBudget || _rt == MyMoneyReport::eBudgetActual) {
     addAccountGroup(MyMoneyAccount::Expense);
     addAccountGroup(MyMoneyAccount::Income);
   }
   if (_rt == MyMoneyReport::eAccountInfo) {
     addAccountGroup(MyMoneyAccount::Asset);
     addAccountGroup(MyMoneyAccount::Liability);
   }
   //cash flow reports show splits for all account groups
   if (_rt == MyMoneyReport::eCashFlow) {
     addAccountGroup(MyMoneyAccount::Expense);
     addAccountGroup(MyMoneyAccount::Income);
     addAccountGroup(MyMoneyAccount::Asset);
     addAccountGroup(MyMoneyAccount::Liability);
   }
 #ifdef DEBUG_REPORTS
   QDebug dbg = qDebug();
   dbg << _name << toString(_rt) << toString(m_reportType);
   foreach(const MyMoneyAccount::accountTypeE accountType, m_accountGroups)
     dbg << MyMoneyAccount::accountTypeToString(accountType);
   if (m_accounts.size() > 0)
     dbg << m_accounts;
 #endif
 }
 
 MyMoneyReport::MyMoneyReport(const QDomElement& node) :
     MyMoneyObject(node),
     m_currentDateColumn(0)
 {
   // properly initialize the object before reading it
   *this = MyMoneyReport();
   if (!read(node))
     clearId();
 }
 
 void MyMoneyReport::clear()
 {
   m_accountGroupFilter = false;
   m_accountGroups.clear();
 
   MyMoneyTransactionFilter::clear();
 }
 
 void MyMoneyReport::validDateRange(QDate& _db, QDate& _de)
 {
   _db = fromDate();
   _de = toDate();
 
   // if either begin or end date are invalid we have one of the following
   // possible date filters:
   //
   // a) begin date not set - first transaction until given end date
   // b) end date not set   - from given date until last transaction
   // c) both not set       - first transaction until last transaction
   //
   // If there is no transaction in the engine at all, we use the current
   // year as the filter criteria.
 
   if (!_db.isValid() || !_de.isValid()) {
     QList<MyMoneyTransaction> list = MyMoneyFile::instance()->transactionList(*this);
     QDate tmpBegin, tmpEnd;
 
     if (!list.isEmpty()) {
       qSort(list);
       // try to use the post dates
       tmpBegin = list.front().postDate();
       tmpEnd = list.back().postDate();
       // if the post dates are not valid try the entry dates
       if (!tmpBegin.isValid())
         tmpBegin = list.front().entryDate();
       if (!tmpEnd.isValid())
         tmpEnd = list.back().entryDate();
     }
     // make sure that we leave this function with valid dates no mather what
     if (!tmpBegin.isValid() || !tmpEnd.isValid() || tmpBegin > tmpEnd) {
       tmpBegin = QDate(QDate::currentDate().year(), 1, 1);   // the first date in the file
       tmpEnd = QDate(QDate::currentDate().year(), 12, 31);   // the last date in the file
     }
     if (!_db.isValid())
       _db = tmpBegin;
     if (!_de.isValid())
       _de = tmpEnd;
   }
   if (_db > _de)
     _db = _de;
 }
 
 void MyMoneyReport::setRowType(ERowType _rt)
 {
   m_rowType = _rt;
   m_reportType = kTypeArray[_rt];
 
   m_accountGroupFilter = false;
   m_accountGroups.clear();
 
   if (_rt == MyMoneyReport::eAssetLiability) {
     addAccountGroup(MyMoneyAccount::Asset);
     addAccountGroup(MyMoneyAccount::Liability);
   }
   if (_rt == MyMoneyReport::eExpenseIncome) {
     addAccountGroup(MyMoneyAccount::Expense);
     addAccountGroup(MyMoneyAccount::Income);
   }
 }
 
 bool MyMoneyReport::accountGroups(QList<MyMoneyAccount::accountTypeE>& list) const
 
 {
   bool result = m_accountGroupFilter;
 
   if (result) {
     QList<MyMoneyAccount::accountTypeE>::const_iterator it_group = m_accountGroups.begin();
     while (it_group != m_accountGroups.end()) {
       list += (*it_group);
       ++it_group;
     }
   }
   return result;
 }
 
 void MyMoneyReport::addAccountGroup(MyMoneyAccount::accountTypeE type)
 {
   if (!m_accountGroups.isEmpty() && type != MyMoneyAccount::UnknownAccountType) {
     if (m_accountGroups.contains(type))
       return;
   }
   m_accountGroupFilter = true;
   if (type != MyMoneyAccount::UnknownAccountType)
     m_accountGroups.push_back(type);
 }
 
 bool MyMoneyReport::includesAccountGroup(MyMoneyAccount::accountTypeE type) const
 {
   bool result = (! m_accountGroupFilter)
                 || (isIncludingTransfers() && m_rowType == MyMoneyReport::eExpenseIncome)
                 || m_accountGroups.contains(type);
 
   return result;
 }
 
 bool MyMoneyReport::includes(const MyMoneyAccount& acc) const
 {
   bool result = false;
 
   if (includesAccountGroup(acc.accountGroup())) {
     switch (acc.accountGroup()) {
       case MyMoneyAccount::Income:
       case MyMoneyAccount::Expense:
         if (isTax())
           result = (acc.value("Tax") == "Yes") && includesCategory(acc.id());
         else
           result = includesCategory(acc.id());
         break;
       case MyMoneyAccount::Asset:
       case MyMoneyAccount::Liability:
         if (isLoansOnly())
           result = acc.isLoan() && includesAccount(acc.id());
         else if (isInvestmentsOnly())
           result = acc.isInvest() && includesAccount(acc.id());
         else if (isIncludingTransfers() && m_rowType == MyMoneyReport::eExpenseIncome)
           // If transfers are included, ONLY include this account if it is NOT
           // included in the report itself!!
           result = ! includesAccount(acc.id());
         else
           result = includesAccount(acc.id());
         break;
       default:
         result = includesAccount(acc.id());
     }
   }
   return result;
 }
 
 void MyMoneyReport::write(QDomElement& e, QDomDocument *doc, bool anonymous) const
 {
   // No matter what changes, be sure to have a 'type' attribute.  Only change
   // the major type if it becomes impossible to maintain compatibility with
   // older versions of the program as new features are added to the reports.
   // Feel free to change the minor type every time a change is made here.
 
   writeBaseXML(*doc, e);
 
   if (anonymous) {
     e.setAttribute("name", m_id);
     e.setAttribute("comment", QString(m_comment).fill('x'));
   } else {
     e.setAttribute("name", m_name);
     e.setAttribute("comment", m_comment);
   }
   e.setAttribute("group", m_group);
   e.setAttribute("convertcurrency", m_convertCurrency);
   e.setAttribute("favorite", m_favorite);
   e.setAttribute("tax", m_tax);
   e.setAttribute("investments", m_investments);
   e.setAttribute("loans", m_loans);
   e.setAttribute("rowtype", kRowTypeText[m_rowType]);
   e.setAttribute("datelock", kDateLockText[m_dateLock]);
   e.setAttribute("includeschedules", m_includeSchedules);
   e.setAttribute("columnsaredays", m_columnsAreDays);
   e.setAttribute("includestransfers", m_includeTransfers);
   if (!m_budgetId.isEmpty())
     e.setAttribute("budget", m_budgetId);
   e.setAttribute("includesactuals", m_includeBudgetActuals);
   e.setAttribute("includeunused", m_includeUnusedAccounts);
   e.setAttribute("includesforecast", m_includeForecast);
   e.setAttribute("includesprice", m_includePrice);
   e.setAttribute("includesaverageprice", m_includeAveragePrice);
   e.setAttribute("mixedtime", m_mixedTime);
   e.setAttribute("includesmovingaverage", m_includeMovingAverage);
   if (m_includeMovingAverage)
     e.setAttribute("movingaveragedays", m_movingAverageDays);
 
   if (m_chartType < 0 || m_chartType >= kChartTypeText.size()) {
     qDebug("m_chartType out of bounds with %d on report of type %d. Default to none.", m_chartType, m_reportType);
     e.setAttribute("charttype", kChartTypeText[0]);
   } else {
     e.setAttribute("charttype", kChartTypeText[m_chartType]);
   }
   e.setAttribute("chartdatalabels", m_chartDataLabels);
   e.setAttribute("chartgridlines", m_chartGridLines);
   e.setAttribute("chartbydefault", m_chartByDefault);
   e.setAttribute("chartlinewidth", m_chartLineWidth);
   e.setAttribute("skipZero", m_skipZero);
 
   if (m_reportType == ePivotTable) {
     e.setAttribute("type", "pivottable 1.15");
     e.setAttribute("detail", kDetailLevelText[m_detailLevel]);
-    e.setAttribute("columntype", kColumnTypeText[m_columnType]);
+    e.setAttribute("columntype", Column::kTypeText[m_columnType]);
     e.setAttribute("showrowtotals", m_showRowTotals);
   } else if (m_reportType == eQueryTable) {
     e.setAttribute("type", "querytable 1.14");
 
     QStringList columns;
     unsigned qc = m_queryColumns;
     unsigned it_qc = eQCbegin;
     unsigned index = 1;
     while (it_qc != eQCend) {
       if (qc & it_qc)
         columns += kQueryColumnsText[index];
       it_qc *= 2;
       index++;
     }
     e.setAttribute("querycolumns", columns.join(","));
   } else if (m_reportType == eInfoTable) {
     e.setAttribute("type", "infotable 1.0");
     e.setAttribute("detail", kDetailLevelText[m_detailLevel]);
     e.setAttribute("showrowtotals", m_showRowTotals);
   }
 
   //
   // Text Filter
   //
 
   QRegExp textfilter;
   if (textFilter(textfilter)) {
     QDomElement f = doc->createElement("TEXT");
     f.setAttribute("pattern", textfilter.pattern());
     f.setAttribute("casesensitive", (textfilter.caseSensitivity() == Qt::CaseSensitive) ? 1 : 0);
     f.setAttribute("regex", (textfilter.patternSyntax() == QRegExp::Wildcard) ? 1 : 0);
     f.setAttribute("inverttext", m_invertText);
     e.appendChild(f);
   }
 
   //
   // Type & State Filters
   //
   QList<int> typelist;
   if (types(typelist) && ! typelist.empty()) {
     // iterate over payees, and add each one
     QList<int>::const_iterator it_type = typelist.constBegin();
     while (it_type != typelist.constEnd()) {
       QDomElement p = doc->createElement("TYPE");
       p.setAttribute("type", kTypeText[*it_type]);
       e.appendChild(p);
 
       ++it_type;
     }
   }
 
   QList<int> statelist;
   if (states(statelist) && ! statelist.empty()) {
     // iterate over payees, and add each one
     QList<int>::const_iterator it_state = statelist.constBegin();
     while (it_state != statelist.constEnd()) {
       QDomElement p = doc->createElement("STATE");
       p.setAttribute("state", kStateText[*it_state]);
       e.appendChild(p);
 
       ++it_state;
     }
   }
   //
   // Number Filter
   //
 
   QString nrFrom, nrTo;
   if (numberFilter(nrFrom, nrTo)) {
     QDomElement f = doc->createElement("NUMBER");
     f.setAttribute("from", nrFrom);
     f.setAttribute("to", nrTo);
     e.appendChild(f);
   }
 
   //
   // Amount Filter
   //
 
   MyMoneyMoney from, to;
   if (amountFilter(from, to)) {    // bool getAmountFilter(MyMoneyMoney&,MyMoneyMoney&);
     QDomElement f = doc->createElement("AMOUNT");
     f.setAttribute("from", from.toString());
     f.setAttribute("to", to.toString());
     e.appendChild(f);
   }
 
   //
   // Payees Filter
   //
 
   QStringList payeelist;
   if (payees(payeelist)) {
     if (payeelist.empty()) {
       QDomElement p = doc->createElement("PAYEE");
       e.appendChild(p);
     } else {
       // iterate over payees, and add each one
       QStringList::const_iterator it_payee = payeelist.constBegin();
       while (it_payee != payeelist.constEnd()) {
         QDomElement p = doc->createElement("PAYEE");
         p.setAttribute("id", *it_payee);
         e.appendChild(p);
 
         ++it_payee;
       }
     }
   }
 
   //
   // Tags Filter
   //
 
   QStringList taglist;
   if (tags(taglist)) {
     if (taglist.empty()) {
       QDomElement p = doc->createElement("TAG");
       e.appendChild(p);
     } else {
       // iterate over tags, and add each one
       QStringList::const_iterator it_tag = taglist.constBegin();
       while (it_tag != taglist.constEnd()) {
         QDomElement p = doc->createElement("TAG");
         p.setAttribute("id", *it_tag);
         e.appendChild(p);
 
         ++it_tag;
       }
     }
   }
 
   //
   // Account Groups Filter
   //
 
   QList<MyMoneyAccount::accountTypeE> accountgrouplist;
   if (accountGroups(accountgrouplist)) {
     // iterate over accounts, and add each one
     QList<MyMoneyAccount::accountTypeE>::const_iterator it_group = accountgrouplist.constBegin();
     while (it_group != accountgrouplist.constEnd()) {
       QDomElement p = doc->createElement("ACCOUNTGROUP");
       p.setAttribute("group", kAccountTypeText[*it_group]);
       e.appendChild(p);
 
       ++it_group;
     }
   }
 
   //
   // Accounts Filter
   //
 
   QStringList accountlist;
   if (accounts(accountlist)) {
     // iterate over accounts, and add each one
     QStringList::const_iterator it_account = accountlist.constBegin();
     while (it_account != accountlist.constEnd()) {
       QDomElement p = doc->createElement("ACCOUNT");
       p.setAttribute("id", *it_account);
       e.appendChild(p);
 
       ++it_account;
     }
   }
 
   //
   // Categories Filter
   //
 
   accountlist.clear();
   if (categories(accountlist)) {
     // iterate over accounts, and add each one
     QStringList::const_iterator it_account = accountlist.constBegin();
     while (it_account != accountlist.constEnd()) {
       QDomElement p = doc->createElement("CATEGORY");
       p.setAttribute("id", *it_account);
       e.appendChild(p);
 
       ++it_account;
     }
   }
 
   //
   // Date Filter
   //
 
   if (m_dateLock == userDefined) {
     QDate dateFrom, dateTo;
     if (dateFilter(dateFrom, dateTo)) {
       QDomElement f = doc->createElement("DATES");
       if (dateFrom.isValid())
         f.setAttribute("from", dateFrom.toString(Qt::ISODate));
       if (dateTo.isValid())
         f.setAttribute("to", dateTo.toString(Qt::ISODate));
       e.appendChild(f);
     }
   }
 }
 
 bool MyMoneyReport::read(const QDomElement& e)
 {
   // The goal of this reading method is 100% backward AND 100% forward
   // compatibility.  Any report ever created with any version of KMyMoney
   // should be able to be loaded by this method (as long as it's one of the
   // report types supported in this version, of course)
 
   bool result = false;
 
   if (
     "REPORT" == e.tagName()
     &&
     (
       (e.attribute("type").indexOf("pivottable 1.") == 0)
       ||
       (e.attribute("type").indexOf("querytable 1.") == 0)
       ||
       (e.attribute("type").indexOf("infotable 1.") == 0)
     )
   ) {
     result = true;
     clear();
 
     int i;
     m_name = e.attribute("name");
     m_comment = e.attribute("comment", "Extremely old report");
 
     //set report type
     if (!e.attribute("type").indexOf("pivottable")) {
       m_reportType = MyMoneyReport::ePivotTable;
     } else if (!e.attribute("type").indexOf("querytable")) {
       m_reportType = MyMoneyReport::eQueryTable;
     } else if (!e.attribute("type").indexOf("infotable")) {
       m_reportType = MyMoneyReport::eInfoTable;
     } else {
       m_reportType = MyMoneyReport::eNoReport;
     }
 
     // Removed the line that screened out loading reports that are called
     // "Default Report".  It's possible for the user to change the comment
     // to this, and we'd hate for it to break as a result.
     m_group = e.attribute("group");
     m_id = e.attribute("id");
 
     //check for reports with older settings which didn't have the detail attribute
     if (e.hasAttribute("detail")) {
       i = kDetailLevelText.indexOf(e.attribute("detail", "all"));
       if (i != -1)
         m_detailLevel = static_cast<EDetailLevel>(i);
     } else if (e.attribute("showsubaccounts", "0").toUInt()) {
       //set to show all accounts
       m_detailLevel = eDetailAll;
     } else {
       //set to show the top level account instead
       m_detailLevel = eDetailTop;
     }
 
     m_convertCurrency = e.attribute("convertcurrency", "1").toUInt();
     m_favorite = e.attribute("favorite", "0").toUInt();
     m_tax = e.attribute("tax", "0").toUInt();
     m_investments = e.attribute("investments", "0").toUInt();
     m_loans = e.attribute("loans", "0").toUInt();
     m_includeSchedules = e.attribute("includeschedules", "0").toUInt();
     m_columnsAreDays = e.attribute("columnsaredays", "0").toUInt();
     m_includeTransfers = e.attribute("includestransfers", "0").toUInt();
     if (e.hasAttribute("budget"))
       m_budgetId = e.attribute("budget");
     m_includeBudgetActuals = e.attribute("includesactuals", "0").toUInt();
     m_includeUnusedAccounts = e.attribute("includeunused", "0").toUInt();
     m_includeForecast = e.attribute("includesforecast", "0").toUInt();
     m_includePrice = e.attribute("includesprice", "0").toUInt();
     m_includeAveragePrice = e.attribute("includesaverageprice", "0").toUInt();
     m_mixedTime = e.attribute("mixedtime", "0").toUInt();
     m_includeMovingAverage = e.attribute("includesmovingaverage", "0").toUInt();
     m_skipZero = e.attribute("skipZero", "0").toUInt();
     if (m_includeMovingAverage)
       m_movingAverageDays = e.attribute("movingaveragedays", "1").toUInt();
 
     //only load chart data if it is a pivot table
     m_chartType = static_cast<EChartType>(0);
     if (m_reportType == ePivotTable) {
       i = kChartTypeText.indexOf(e.attribute("charttype"));
 
       if (i >= 0)
         m_chartType = static_cast<EChartType>(i);
 
       // if it is invalid, set to first type
       if (m_chartType >= eChartEnd)
         m_chartType = eChartLine;
 
       m_chartDataLabels = e.attribute("chartdatalabels", "1").toUInt();
       m_chartGridLines = e.attribute("chartgridlines", "1").toUInt();
       m_chartByDefault = e.attribute("chartbydefault", "0").toUInt();
       m_chartLineWidth = e.attribute("chartlinewidth", QString(m_lineWidth)).toUInt();
     } else {
       m_chartDataLabels = true;
       m_chartGridLines = true;
       m_chartByDefault = false;
       m_chartLineWidth = 1;
     }
 
     QString datelockstr = e.attribute("datelock", "userdefined");
     // Handle the pivot 1.2/query 1.1 case where the values were saved as
     // numbers
     bool ok = false;
     i = datelockstr.toUInt(&ok);
     if (!ok) {
       i = kDateLockText.indexOf(datelockstr);
       if (i == -1)
         i = userDefined;
     }
     setDateFilter(static_cast<dateOptionE>(i));
 
     i = kRowTypeText.indexOf(e.attribute("rowtype", "expenseincome"));
     if (i != -1) {
       setRowType(static_cast<ERowType>(i));
       // recent versions of KMyMoney always showed a total column for
       // income/expense reports. We turn it on for backward compatibility
       // here. If the total column is turned off, the flag will be reset
       // in the next step
       if (i == eExpenseIncome)
         m_showRowTotals = true;
     }
     if (e.hasAttribute("showrowtotals"))
       m_showRowTotals = e.attribute("showrowtotals").toUInt();
 
-    i = kColumnTypeText.indexOf(e.attribute("columntype", "months"));
+    i = Column::kTypeText.indexOf(e.attribute("columntype", "months"));
     if (i != -1)
-      setColumnType(static_cast<EColumnType>(i));
+      setColumnType(static_cast<Column::Type>(i));
 
     unsigned qc = 0;
     QStringList columns = e.attribute("querycolumns", "none").split(',');
     QStringList::const_iterator it_column = columns.constBegin();
     while (it_column != columns.constEnd()) {
       i = kQueryColumnsText.indexOf(*it_column);
       if (i > 0)
         qc |= (1 << (i - 1));
 
       ++it_column;
     }
     setQueryColumns(static_cast<EQueryColumns>(qc));
 
     QDomNode child = e.firstChild();
     while (!child.isNull() && child.isElement()) {
       QDomElement c = child.toElement();
       if ("TEXT" == c.tagName() && c.hasAttribute("pattern")) {
         setTextFilter(QRegExp(c.attribute("pattern"),
                               c.attribute("casesensitive", "1").toUInt()
                               ? Qt::CaseSensitive : Qt::CaseInsensitive,
                               c.attribute("regex", "1").toUInt()
                               ? QRegExp::Wildcard : QRegExp::RegExp),
                       c.attribute("inverttext", "0").toUInt());
       }
       if ("TYPE" == c.tagName() && c.hasAttribute("type")) {
         i = kTypeText.indexOf(c.attribute("type"));
         if (i != -1)
           addType(i);
       }
       if ("STATE" == c.tagName() && c.hasAttribute("state")) {
         i = kStateText.indexOf(c.attribute("state"));
         if (i != -1)
           addState(i);
       }
       if ("NUMBER" == c.tagName()) {
         setNumberFilter(c.attribute("from"), c.attribute("to"));
       }
       if ("AMOUNT" == c.tagName()) {
         setAmountFilter(MyMoneyMoney(c.attribute("from", "0/100")), MyMoneyMoney(c.attribute("to", "0/100")));
       }
       if ("DATES" == c.tagName()) {
         QDate from, to;
         if (c.hasAttribute("from"))
           from = QDate::fromString(c.attribute("from"), Qt::ISODate);
         if (c.hasAttribute("to"))
           to = QDate::fromString(c.attribute("to"), Qt::ISODate);
         MyMoneyTransactionFilter::setDateFilter(from, to);
       }
       if ("PAYEE" == c.tagName()) {
         addPayee(c.attribute("id"));
       }
       if ("TAG" == c.tagName()) {
         addTag(c.attribute("id"));
       }
       if ("CATEGORY" == c.tagName() && c.hasAttribute("id")) {
         addCategory(c.attribute("id"));
       }
       if ("ACCOUNT" == c.tagName() && c.hasAttribute("id")) {
         addAccount(c.attribute("id"));
       }
       if ("ACCOUNTGROUP" == c.tagName() && c.hasAttribute("group")) {
         i = kAccountTypeText.indexOf(c.attribute("group"));
         if (i != -1)
           addAccountGroup(static_cast<MyMoneyAccount::accountTypeE>(i));
       }
       child = child.nextSibling();
     }
   }
   return result;
 }
 
 void MyMoneyReport::writeXML(QDomDocument& document, QDomElement& parent) const
 {
   QDomElement el = document.createElement("REPORT");
   write(el, &document, false);
   parent.appendChild(el);
 }
 
 bool MyMoneyReport::hasReferenceTo(const QString& id) const
 {
   QStringList list;
 
   // collect all ids
   accounts(list);
   categories(list);
   payees(list);
   tags(list);
 
   return (list.contains(id) > 0);
 }
 
 int MyMoneyReport::m_lineWidth = 2;
 
 void MyMoneyReport::setLineWidth(int width)
 {
   m_lineWidth = width;
 }
 
 QString MyMoneyReport::toString(ERowType type)
 {
   switch(type) {
   case eNoRows             : return "eNoRows";
   case eAssetLiability     : return "eAssetLiability";
   case eExpenseIncome      : return "eExpenseIncome";
   case eCategory           : return "eCategory";
   case eTopCategory        : return "eTopCategory";
   case eAccount            : return "eAccount";
   case eTag                : return "eTag";
   case ePayee              : return "ePayee";
   case eMonth              : return "eMonth";
   case eWeek               : return "eWeek";
   case eTopAccount         : return "eTopAccount";
   case eAccountByTopAccount: return "eAccountByTopAccount";
   case eEquityType         : return "eEquityType";
   case eAccountType        : return "eAccountType";
   case eInstitution        : return "eInstitution";
   case eBudget             : return "eBudget";
   case eBudgetActual       : return "eBudgetActual";
   case eSchedule           : return "eSchedule";
   case eAccountInfo        : return "eAccountInfo";
   case eAccountLoanInfo    : return "eAccountLoanInfo";
   case eAccountReconcile   : return "eAccountReconcile";
   case eCashFlow           : return "eCashFlow";
   default                  : return "undefined";
   }
 }
 
 QString MyMoneyReport::toString(MyMoneyReport::EReportType type)
 {
   switch(type) {
   case eNoReport:   return "eNoReport";
   case ePivotTable: return "ePivotTable";
   case eQueryTable: return "eQueryTable";
   case eInfoTable:  return "eInfoTable";
   default:          return "undefined";
   }
 }
diff --git a/kmymoney/mymoney/mymoneyreport.h b/kmymoney/mymoney/mymoneyreport.h
index ea7b76a41..6ce13199a 100644
--- a/kmymoney/mymoney/mymoneyreport.h
+++ b/kmymoney/mymoney/mymoneyreport.h
@@ -1,713 +1,716 @@
 /***************************************************************************
                           mymoneyreport.h
                              -------------------
     begin                : Sun July 4 2004
     copyright            : (C) 2004-2005 by Ace Jones
     email                : 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.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #ifndef MYMONEYREPORT_H
 #define MYMONEYREPORT_H
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QMap>
 #include <QList>
 #include <QString>
 class QDomElement;
 class QDomDocument;
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include <mymoneyobject.h>
 #include <mymoneyaccount.h>
 #include <mymoneytransactionfilter.h>
 #include <kmm_mymoney_export.h>
 
 /**
   * This class defines a report within the MyMoneyEngine.  The report class
   * contains all the configuration parameters needed to run a report, plus
   * XML serialization.
   *
   * A report is a transactionfilter, so any report can specify which
   * transactions it's interested down to the most minute level of detail.
   * It extends the transactionfilter by providing identification (name,
   * comments, group type, etc) as well as layout information (what kind
   * of layout should be used, how the rows & columns should be presented,
   * currency converted, etc.)
   *
   * As noted above, this class only provides a report DEFINITION.  The
   * generation and presentation of the report itself are left to higher
   * level classes.
   *
   * @author Ace Jones <acejones@users.sourceforge.net>
   */
 
 class KMM_MYMONEY_EXPORT MyMoneyReport: public MyMoneyObject, public MyMoneyTransactionFilter
 {
 public:
   // When adding a new row type, be sure to add a corresponding entry in kTypeArray
   enum ERowType { eNoRows = 0, eAssetLiability, eExpenseIncome, eCategory, eTopCategory, eAccount, eTag, ePayee, eMonth, eWeek, eTopAccount, eAccountByTopAccount, eEquityType, eAccountType, eInstitution, eBudget, eBudgetActual, eSchedule, eAccountInfo, eAccountLoanInfo, eAccountReconcile, eCashFlow};
   enum EReportType { eNoReport = 0, ePivotTable, eQueryTable, eInfoTable };
-  enum EColumnType { eNoColumns = 0, eDays = 1, eMonths = 1, eBiMonths = 2, eQuarters = 3, eWeeks = 7, eYears = 12 };
+  class Column {
+  public:
+    enum Type { NoColumns = 0, Days = 1, Months = 1, BiMonths = 2, Quarters = 3, Weeks = 7, Years = 12 };
+    static const QStringList kTypeText;
+  };
 
   // if you add bits to this bitmask, start with the value currently assigned to eQCend and update its value afterwards
   // also don't forget to add column names to kQueryColumnsText in mymoneyreport.cpp
   enum EQueryColumns { eQCnone = 0x0, eQCbegin = 0x1, eQCnumber = 0x1, eQCpayee = 0x2, eQCcategory = 0x4, eQCtag = 0x8, eQCmemo = 0x10, eQCaccount = 0x20, eQCreconciled = 0x40, eQCaction = 0x80, eQCshares = 0x100, eQCprice = 0x200, eQCperformance = 0x400, eQCloan = 0x800, eQCbalance = 0x1000, eQCend = 0x2000 };
 
   enum EDetailLevel { eDetailNone = 0, eDetailAll, eDetailTop, eDetailGroup, eDetailTotal, eDetailEnd };
   enum EChartType { eChartNone = 0, eChartLine, eChartBar, eChartPie, eChartRing, eChartStackedBar, eChartEnd };
 
   static const QStringList kRowTypeText;
-  static const QStringList kColumnTypeText;
   static const QStringList kQueryColumnsText;
   static const QStringList kDetailLevelText;
   static const QStringList kChartTypeText;
   static const EReportType kTypeArray[];
 
 public:
   MyMoneyReport();
   MyMoneyReport(ERowType _rt, unsigned _ct, dateOptionE _dl, EDetailLevel _ss, const QString& _name, const QString& _comment);
   MyMoneyReport(const QString& id, const MyMoneyReport& right);
 
   /**
     * This constructor creates an object based on the data found in the
     * QDomElement referenced by @p node. If problems arise, the @p id of
     * the object is cleared (see MyMoneyObject::clearId()).
     */
   MyMoneyReport(const QDomElement& node);
 
   // Simple get operations
   const QString& name() const {
     return m_name;
   }
   bool isShowingRowTotals() const {
     return (m_showRowTotals);
   }
   EReportType reportType() const {
     return m_reportType;
   }
   ERowType rowType() const {
     return m_rowType;
   }
-  EColumnType columnType() const {
+  Column::Type columnType() const {
     return m_columnType;
   }
   bool isRunningSum() const {
     return (m_rowType == eAssetLiability);
   }
   bool isConvertCurrency() const {
     return m_convertCurrency;
   }
   unsigned columnPitch() const {
     return static_cast<unsigned>(m_columnType);
   }
   bool isShowingColumnTotals() const {
     return m_convertCurrency;
   }
   const QString& comment() const {
     return m_comment;
   }
   EQueryColumns queryColumns() const {
     return m_queryColumns;
   }
   const QString& group() const {
     return m_group;
   }
   bool isFavorite() const {
     return m_favorite;
   }
   bool isTax() const {
     return m_tax;
   }
   bool isInvestmentsOnly() const {
     return m_investments;
   }
   bool isLoansOnly() const {
     return m_loans;
   }
   EDetailLevel detailLevel() const {
     return m_detailLevel;
   }
   EChartType chartType() const {
     return m_chartType;
   }
   bool isChartDataLabels() const {
     return m_chartDataLabels;
   }
   bool isChartGridLines() const {
     return m_chartGridLines;
   }
   bool isChartByDefault() const {
     return m_chartByDefault;
   }
   uint chartLineWidth() const {
     return m_chartLineWidth;
   }
   bool isIncludingSchedules() const {
     return m_includeSchedules;
   }
   bool isColumnsAreDays() const {
     return m_columnsAreDays;
   }
   bool isIncludingTransfers() const {
     return m_includeTransfers;
   }
   bool isIncludingUnusedAccounts() const {
     return m_includeUnusedAccounts;
   }
   bool hasBudget() const {
     return !m_budgetId.isEmpty();
   }
   const QString& budget() const {
     return m_budgetId;
   }
   bool isIncludingBudgetActuals() const {
     return m_includeBudgetActuals;
   }
   bool isIncludingForecast() const {
     return m_includeForecast;
   }
   bool isIncludingMovingAverage() const {
     return m_includeMovingAverage;
   }
   int movingAverageDays() const {
     return m_movingAverageDays;
   }
   bool isIncludingPrice() const {
     return m_includePrice;
   }
   bool isIncludingAveragePrice() const {
     return m_includeAveragePrice;
   }
   bool isUserDefined() const {
     return m_dateLock == userDefined;
   }
   bool isMixedTime() const {
     return m_mixedTime;
   }
   int currentDateColumn() const {
     return m_currentDateColumn;
   }
   /**
    * @see #m_skipZero
    */
   bool isSkippingZero() const {
     return m_skipZero;
   }
 
   // Simple set operations
   void setName(const QString& _s) {
     m_name = _s;
   }
   void setConvertCurrency(bool _f) {
     m_convertCurrency = _f;
   }
   void setRowType(ERowType _rt);
-  void setColumnType(EColumnType _ct) {
+  void setColumnType(Column::Type _ct) {
     m_columnType = _ct;
   }
   void setComment(const QString& _comment) {
     m_comment = _comment;
   }
   void setGroup(const QString& _group) {
     m_group = _group;
   }
   void setFavorite(bool _f) {
     m_favorite = _f;
   }
   void setQueryColumns(EQueryColumns _qc) {
     m_queryColumns = _qc;
   }
   void setTax(bool _f) {
     m_tax = _f;
   }
   void setInvestmentsOnly(bool _f) {
     m_investments = _f; if (_f) m_loans = false;
   }
   void setLoansOnly(bool _f) {
     m_loans = _f; if (_f) m_investments = false;
   }
   void setDetailLevel(EDetailLevel _detail) {
     m_detailLevel = _detail;
   }
   void setChartType(EChartType _type) {
     m_chartType = _type;
   }
   void setChartDataLabels(bool _f) {
     m_chartDataLabels = _f;
   }
   void setChartGridLines(bool _f) {
     m_chartGridLines = _f;
   }
   void setChartByDefault(bool _f) {
     m_chartByDefault = _f;
   }
   void setChartLineWidth(uint _f) {
     m_chartLineWidth = _f;
   }
   void setIncludingSchedules(bool _f) {
     m_includeSchedules = _f;
   }
   void setColumnsAreDays(bool _f) {
     m_columnsAreDays = _f;
   }
   void setIncludingTransfers(bool _f) {
     m_includeTransfers = _f;
   }
   void setIncludingUnusedAccounts(bool _f) {
     m_includeUnusedAccounts = _f;
   }
   void setShowingRowTotals(bool _f) {
     m_showRowTotals = _f;
   }
   void setIncludingBudgetActuals(bool _f) {
     m_includeBudgetActuals = _f;
   }
   void setIncludingForecast(bool _f) {
     m_includeForecast = _f;
   }
   void setIncludingMovingAverage(bool _f) {
     m_includeMovingAverage = _f;
   }
   void setMovingAverageDays(int _days) {
     m_movingAverageDays = _days;
   }
   void setIncludingPrice(bool _f) {
     m_includePrice = _f;
   }
   void setIncludingAveragePrice(bool _f) {
     m_includeAveragePrice = _f;
   }
   void setMixedTime(bool _f) {
     m_mixedTime = _f;
   }
   void setCurrentDateColumn(int _f) {
     m_currentDateColumn = _f;
   }
   /**
    * @see #m_skipZero
    */
   void setSkipZero(int _f) {
     m_skipZero = _f;
   }
 
   /**
     * Sets the budget used for this report
     *
     * @param _budget The ID of the budget to use, or an empty string
     * to indicate a budget is NOT included
     * @param _fa Whether to display actual data alongside the budget.
     * Setting to false means the report displays ONLY the budget itself.
     * @warning For now, the budget ID is ignored.  The budget id is
     * simply checked for any non-empty string, and if so, hasBudget()
     * will return true.
     */
   void setBudget(const QString& _budget, bool _fa = true) {
     m_budgetId = _budget; m_includeBudgetActuals = _fa;
   }
 
   /**
     * This method allows you to clear the underlying transaction filter
     */
   void clear();
 
   /**
     * This method allows you to set the underlying transaction filter
     *
     * @param _filter The filter which should replace the existing transaction
     * filter.
     */
   void assignFilter(const MyMoneyTransactionFilter& _filter) {
     MyMoneyTransactionFilter::operator=(_filter);
   }
 
   /**
     * Set the underlying date filter and LOCK that filter to the specified
     * range.  For example, if @p _u is "CurrentMonth", this report should always
     * be updated to the current month no matter when the report is run.
     *
     * This updating is not entirely automatic, you should update it yourself by
     * calling updateDateFilter.
     *
     * @param _u The date range constant (MyMoneyTransactionFilter::dateRangeE)
     *          which this report should be locked to.
     */
 
   void setDateFilter(dateOptionE _u) {
     m_dateLock = _u;
     if (_u != userDefined)
       MyMoneyTransactionFilter::setDateFilter(_u);
   }
 
   /**
     * Set the underlying date filter using the start and end dates provided.
     * Note that this does not LOCK to any range like setDateFilter(unsigned)
     * above.  It is just a reimplementation of the MyMoneyTransactionFilter
     * version.
     *
     * @param _db The inclusive begin date of the date range
     * @param _de The inclusive end date of the date range
     */
 
   void setDateFilter(const QDate& _db, const QDate& _de) {
     MyMoneyTransactionFilter::setDateFilter(_db, _de);
   }
 
   /**
     * Set the underlying date filter using the 'date lock' property.
     *
     * Always call this function before executing the report to be sure that
     * the date filters properly match the plain-language 'date lock'.
     *
     * For example, if the report is date-locked to "Current Month", and the
     * last time you loaded or ran the report was in August, but it's now
     * September, this function will update the date range to be September,
     * as is proper.
     */
   void updateDateFilter() {
     if (m_dateLock != userDefined) MyMoneyTransactionFilter::setDateFilter(m_dateLock);
   }
 
   /**
     * Retrieves a VALID beginning & ending date for this report.
     *
     * The underlying date filter can return en empty QDate() for either the
     * begin or end date or both.  This is typically unacceptable for reports,
     * which need the REAL begin and end date.
     *
     * This function gets the underlying date filter range, and if either is
     * an empty QDate(), it determines the missing date from looking at all
     * the transactions which match the underlying filter, and returning the
     * date of the first or last transaction (as appropriate).
     *
     * @param _db The inclusive begin date of the date range
     * @param _de The inclusive end date of the date range
     */
   void validDateRange(QDate& _db, QDate& _de);
 
   /**
     * This method turns on the account group filter and adds the
     * @p type to the list of allowed groups.
     *
     * Note that account group filtering is handled differently
     * than all the filters of the underlying class.  This filter
     * is meant to be applied to individual splits of matched
     * transactions AFTER the underlying filter is used to find
     * the matching transactions.
     *
     * @param type the account group to add to the allowed groups list
     */
   void addAccountGroup(MyMoneyAccount::accountTypeE type);
 
   /**
     * This method returns whether an account group filter has been set,
     * and if so, it returns all the account groups set in the filter.
     *
     * @param list list to append account groups into
     * @return return true if an account group filter has been set
     */
   bool accountGroups(QList<MyMoneyAccount::accountTypeE>& list) const;
 
   /**
     * This method returns whether the specified account group
     * is allowed by the account groups filter.
     *
     * @param type group to append account groups into
     * @return return true if an account group filter has been set
     */
   bool includesAccountGroup(MyMoneyAccount::accountTypeE type) const;
 
   /**
     * This method is used to test whether a specific account
     * passes the accountGroup test and either the Account or
     * Category test, depending on which sort of Account it is.
     *
     * The m_tax and m_investments properties are also considered.
     *
     * @param acc the account in question
     * @return true if account is in filter set, false otherwise
     */
   bool includes(const MyMoneyAccount& acc) const;
 
   /**
     * This method writes this report to the DOM element @p e,
     * within the DOM document @p doc.
     *
     * @param e The element which should be populated with info from this report
     * @param doc The document which we can use to create new sub-elements
     *              if needed
     * @param anonymous Whether the sensitive parts of the report should be
     *              masked
     */
   void write(QDomElement& e, QDomDocument *doc, bool anonymous = false) const;
 
   /**
     * This method reads a report from the DOM element @p e, and
     * populates this report with the results.
     *
     * @param e The element from which the report should be read
     *
     * @return bool True if a report was successfully loaded from the
     *    element @p e.  If false is returned, the contents of this report
     *    object are undefined.
     */
   bool read(const QDomElement& e);
 
   /**
     * This method creates a QDomElement for the @p document
     * under the parent node @p parent.  (This version overwrites the
     * MMObject base class.)
     *
     * @param document reference to QDomDocument
     * @param parent reference to QDomElement parent node
     */
   virtual void writeXML(QDomDocument& document, QDomElement& parent) const;
 
   /**
     * 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.
     */
   virtual bool hasReferenceTo(const QString& id) const;
 
   /**
     * This method allows to modify the default lineWidth for graphs.
     * The default is 2.
     */
   static void setLineWidth(int width);
 
   /**
    * Return row type as string.
    *
    * @param type type to get string for
    * @return row type converted to string
    */
   static QString toString(ERowType type);
 
   /**
    * Return report type as string.
    *
    * @param type report type to get string for
    * @return report type converted to string
    */
   static QString toString(EReportType type);
 
 private:
   /**
     * The user-assigned name of the report
     */
   QString m_name;
   /**
     * The user-assigned comment for the report, in case they want to make
     * additional notes for themselves about the report.
     */
   QString m_comment;
   /**
     * Where to group this report amongst the others in the UI view.  This
     * should be assigned by the UI system.
     */
   QString m_group;
   /**
     * How much detail to show in the accounts
     */
   enum EDetailLevel m_detailLevel;
   /**
     * Whether to convert all currencies to the base currency of the file (true).
     * If this is false, it's up to the report generator to decide how to handle
     * the currency.
     */
   bool m_convertCurrency;
   /**
     * Whether this is one of the users' favorite reports
     */
   bool m_favorite;
   /**
     * Whether this report should only include categories marked as "Tax"="Yes"
     */
   bool m_tax;
   /**
     * Whether this report should only include investment accounts
     */
   bool m_investments;
   /**
     * Whether this report should only include loan accounts
     * Applies only to querytable reports.  Mutually exclusive with
     * m_investments.
     */
   bool m_loans;
   /**
     * What sort of algorithm should be used to run the report
     */
   enum EReportType m_reportType;
   /**
     * What sort of values should show up on the ROWS of this report
     */
   enum ERowType m_rowType;
   /**
     * What sort of values should show up on the COLUMNS of this report,
     * in the case of a 'PivotTable' report.  Really this is used more as a
     * QUANTITY of months or days.  Whether it's months or days is determined
     * by m_columnsAreDays.
     */
-  enum EColumnType m_columnType;
+  Column::Type m_columnType;
   /**
    * Whether the base unit of columns of this report is days.  Only applies to
    * 'PivotTable' reports.  If false, then columns are months or multiples thereof.
    */
   bool m_columnsAreDays;
   /**
      * What sort of values should show up on the COLUMNS of this report,
      * in the case of a 'QueryTable' report
      */
   enum EQueryColumns m_queryColumns;
 
   /**
     * The plain-language description of what the date range should be locked
     * to.  'userDefined' means NO locking, in any other case, the report
     * will be adjusted to match the date lock.  So if the date lock is
     * 'currentMonth', the start and end dates of the underlying filter will
     * be updated to whatever the current month is.  This updating happens
     * automatically when the report is loaded, and should also be done
     * manually by calling updateDateFilter() before generating the report
     */
   dateOptionE m_dateLock;
   /**
     * Which account groups should be included in the report.  This filter
     * is applied to the individual splits AFTER a transaction has been
     * matched using the underlying filter.
     */
   QList<MyMoneyAccount::accountTypeE> m_accountGroups;
   /**
     * Whether an account group filter has been set (see m_accountGroups)
     */
   bool m_accountGroupFilter;
   /**
     * What format should be used to draw this report as a chart
     */
   enum EChartType m_chartType;
   /**
     * Whether the value of individual data points should be drawn on the chart
     */
   bool m_chartDataLabels;
   /**
     * Whether grid lines should be drawn on the chart
     */
   bool m_chartGridLines;
   /**
     * Whether this report should be shown as a chart by default (otherwise it
     * should be shown as a textual report)
     */
   bool m_chartByDefault;
   /**
    * Width of the chart lines
    */
   uint m_chartLineWidth;
   /**
     * Whether to include scheduled transactions
     */
   bool m_includeSchedules;
   /**
     * Whether to include transfers.  Only applies to Income/Expense reports
     */
   bool m_includeTransfers;
   /**
     * The id of the budget associated with this report.
     */
   QString m_budgetId;
   /**
     * Whether this report should print the actual data to go along with
     * the budget.  This is only valid if the report has a budget.
     */
   bool m_includeBudgetActuals;
   /**
     * Whether this report should include all accounts and not only
     * accounts with transactions.
     */
   bool m_includeUnusedAccounts;
   /**
    * Whether this report should include columns for row totals
    */
   bool m_showRowTotals;
   /**
    * Whether this report should include forecast balance
    */
   bool m_includeForecast;
   /**
    * Whether this report should include moving average
    */
   bool m_includeMovingAverage;
   /**
    * The amount of days that spans each moving average
    */
   int m_movingAverageDays;
   /**
    * Whether this report should include prices
    */
   bool m_includePrice;
   /**
    * Whether this report should include moving average prices
    */
   bool m_includeAveragePrice;
   /**
    * Make the actual and forecast lines display as one
    */
   bool m_mixedTime;
   /**
    * This stores the column for the current date
    * This value is calculated dinamically and thus it is not saved in the file
    */
   int m_currentDateColumn;
 
   /**
     * This member keeps the current setting for line graphs lineWidth.
     * @sa setLineWidth()
     */
   static int m_lineWidth;
 
   /**
     * This option is for investments reports only which
     * show prices instead of balances as all other reports do.
     * <p>
     * Select this option to include prices for the given period (week, month,
     * quarter, ...) only.
     * </p>
     * <p>
     * If this option is off the last existing price is shown for a period, if
     * it is on, in a table the value is '0' shown and in a chart a linear
     * interpolation for the missing values will be performed.
     * <br>Example:
     * <br>There are prices for January and March, but there is no price for
     * February.
     * <ul>
     * <li><b>OFF</b>: shows the price for February as the last price of
     * January
     * <li><b>ON</b>: in a table the value is '0', in a chart a linear
     * interpolation for the February-price will be performed
     * (so it makes a kind of average-value using the January- and the
     * March-price in the chart)
     * </ul>
     * </p>
     */
   bool m_skipZero;
 };
 
 /**
   * Make it possible to hold @ref MyMoneyReport objects inside @ref QVariant objects.
   */
 Q_DECLARE_METATYPE(MyMoneyReport)
 
 #endif // MYMONEYREPORT_H
diff --git a/kmymoney/reports/pivottable.cpp b/kmymoney/reports/pivottable.cpp
index b29646369..62c719fc5 100644
--- a/kmymoney/reports/pivottable.cpp
+++ b/kmymoney/reports/pivottable.cpp
@@ -1,2294 +1,2294 @@
 /***************************************************************************
                           pivottable.cpp
                              -------------------
     begin                : Mon May 17 2004
     copyright            : (C) 2004-2005 by Ace Jones
     email                : <ace.j@hotpop.com>
                            Thomas Baumgart <ipwizard@users.sourceforge.net>
                            Alvaro Soliverez <asoliverez@gmail.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "pivottable.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 #include <QDateTime>
 #include <QRegExp>
 #include <QClipboard>
 #include <QApplication>
 #include <QPrinter>
 #include <QPainter>
 #include <QFile>
 #include <QTextStream>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kdebug.h>
 #include <kcalendarsystem.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include "pivotgrid.h"
 #include "reportdebug.h"
 #include "kreportchartview.h"
 #include "kmymoneyglobalsettings.h"
 #include "kmymoneyutils.h"
 #include "mymoneyforecast.h"
 #include <mymoneyprice.h>
 
 namespace reports
 {
 
 using KDChart::Widget;
 
 QString Debug::m_sTabs;
 bool Debug::m_sEnabled = DEBUG_ENABLED_BY_DEFAULT;
 QString Debug::m_sEnableKey;
 
 Debug::Debug(const QString& _name): m_methodName(_name), m_enabled(m_sEnabled)
 {
   if (!m_enabled && _name == m_sEnableKey)
     m_enabled = true;
 
   if (m_enabled) {
     qDebug("%s%s(): ENTER", qPrintable(m_sTabs), qPrintable(m_methodName));
     m_sTabs.append("--");
   }
 }
 
 Debug::~Debug()
 {
   if (m_enabled) {
     m_sTabs.remove(0, 2);
     qDebug("%s%s(): EXIT", qPrintable(m_sTabs), qPrintable(m_methodName));
 
     if (m_methodName == m_sEnableKey)
       m_enabled = false;
   }
 }
 
 void Debug::output(const QString& _text)
 {
   if (m_enabled)
     qDebug("%s%s(): %s", qPrintable(m_sTabs), qPrintable(m_methodName), qPrintable(_text));
 }
 
 PivotTable::PivotTable(const MyMoneyReport& _config_f):
     ReportTable(),
     m_runningSumsCalculated(false),
     m_config_f(_config_f)
 {
   init();
 }
 
 void PivotTable::init()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   //
   // Initialize locals
   //
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //
   // Initialize member variables
   //
 
   //make sure we have all subaccounts of investment accounts
   includeInvestmentSubAccounts();
 
   m_config_f.validDateRange(m_beginDate, m_endDate);
 
   // If we need to calculate running sums, it does not make sense
   // to show a row total column
   if (m_config_f.isRunningSum())
     m_config_f.setShowingRowTotals(false);
 
   // if this is a months-based report
   if (! m_config_f.isColumnsAreDays()) {
     // strip out the 'days' component of the begin and end dates.
     // we're only using these variables to contain year and month.
     m_beginDate =  QDate(m_beginDate.year(), m_beginDate.month(), 1);
     m_endDate = QDate(m_endDate.year(), m_endDate.month(), 1);
   }
 
   m_numColumns = columnValue(m_endDate) - columnValue(m_beginDate) + 2;
 
   //Load what types of row the report is going to show
   loadRowTypeList();
 
   //
   // Initialize outer groups of the grid
   //
   if (m_config_f.rowType() == MyMoneyReport::eAssetLiability) {
     m_grid.insert(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Asset), PivotOuterGroup(m_numColumns));
     m_grid.insert(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Liability), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder, true /* inverted */));
   } else {
     m_grid.insert(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Income), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder - 2));
     m_grid.insert(KMyMoneyUtils::accountTypeToString(MyMoneyAccount::Expense), PivotOuterGroup(m_numColumns, PivotOuterGroup::m_kDefaultSortOrder - 1, true /* inverted */));
     //
     // Create rows for income/expense reports with all accounts included
     //
     if (m_config_f.isIncludingUnusedAccounts())
       createAccountRows();
   }
 
   //
   // Initialize grid totals
   //
 
   m_grid.m_total = PivotGridRowSet(m_numColumns);
 
   //
   // Get opening balances
   // (for running sum reports only)
   //
 
   if (m_config_f.isRunningSum())
     calculateOpeningBalances();
 
   //
   // Calculate budget mapping
   // (for budget reports only)
   //
   if (m_config_f.hasBudget())
     calculateBudgetMapping();
 
   //
   // Populate all transactions into the row/column pivot grid
   //
 
   QList<MyMoneyTransaction> transactions;
   m_config_f.setReportAllSplits(false);
   m_config_f.setConsiderCategory(true);
   try {
     transactions = file->transactionList(m_config_f);
   } catch (const MyMoneyException &e) {
     qDebug("ERR: %s thrown in %s(%ld)", qPrintable(e.what()), qPrintable(e.file()), e.line());
     throw e;
   }
   DEBUG_OUTPUT(QString("Found %1 matching transactions").arg(transactions.count()));
 
 
   // Include scheduled transactions if required
   if (m_config_f.isIncludingSchedules()) {
     // Create a custom version of the report filter, excluding date
     // We'll use this to compare the transaction against
     MyMoneyTransactionFilter schedulefilter(m_config_f);
     schedulefilter.setDateFilter(QDate(), QDate());
 
     // Get the real dates from the config filter
     QDate configbegin, configend;
     m_config_f.validDateRange(configbegin, configend);
 
     QList<MyMoneySchedule> schedules = file->scheduleList();
     QList<MyMoneySchedule>::const_iterator it_schedule = schedules.constBegin();
     while (it_schedule != schedules.constEnd()) {
       // If the transaction meets the filter
       MyMoneyTransaction tx = (*it_schedule).transaction();
       if (!(*it_schedule).isFinished() && schedulefilter.match(tx)) {
         // Keep the id of the schedule with the transaction so that
         // we can do the autocalc later on in case of a loan payment
         tx.setValue("kmm-schedule-id", (*it_schedule).id());
 
         // Get the dates when a payment will be made within the report window
         QDate nextpayment = (*it_schedule).adjustedNextPayment(configbegin);
         if (nextpayment.isValid()) {
           // Add one transaction for each date
           QList<QDate> paymentDates = (*it_schedule).paymentDates(nextpayment, configend);
           QList<QDate>::const_iterator it_date = paymentDates.constBegin();
           while (it_date != paymentDates.constEnd()) {
             //if the payment occurs in the past, enter it tomorrow
             if (QDate::currentDate() >= *it_date) {
               tx.setPostDate(QDate::currentDate().addDays(1));
             } else {
               tx.setPostDate(*it_date);
             }
             if (tx.postDate() <= configend
                 && tx.postDate() >= configbegin) {
               transactions += tx;
             }
 
             DEBUG_OUTPUT(QString("Added transaction for schedule %1 on %2").arg((*it_schedule).id()).arg((*it_date).toString()));
 
             ++it_date;
           }
         }
       }
 
       ++it_schedule;
     }
   }
 
   // whether asset & liability transactions are actually to be considered
   // transfers
   bool al_transfers = (m_config_f.rowType() == MyMoneyReport::eExpenseIncome) && (m_config_f.isIncludingTransfers());
 
   //this is to store balance for loan accounts when not included in the report
   QMap<QString, MyMoneyMoney> loanBalances;
 
   QList<MyMoneyTransaction>::const_iterator it_transaction = transactions.constBegin();
   int colofs = columnValue(m_beginDate) - 1;
   while (it_transaction != transactions.constEnd()) {
     MyMoneyTransaction tx = (*it_transaction);
     QDate postdate = tx.postDate();
     if (postdate < m_beginDate) {
       qDebug("MyMoneyFile::transactionList returned a transaction that is outside the date filter, skipping it");
       ++it_transaction;
       continue;
     }
     int column = columnValue(postdate) - colofs;
 
     // check if we need to call the autocalculation routine
     if (tx.isLoanPayment() && tx.hasAutoCalcSplit() && (tx.value("kmm-schedule-id").length() > 0)) {
       // make sure to consider any autocalculation for loan payments
       MyMoneySchedule sched = file->schedule(tx.value("kmm-schedule-id"));
       const MyMoneySplit& split = tx.amortizationSplit();
       if (!split.id().isEmpty()) {
         ReportAccount splitAccount = file->account(split.accountId());
         MyMoneyAccount::accountTypeE type = splitAccount.accountGroup();
         QString outergroup = KMyMoneyUtils::accountTypeToString(type);
 
         //if the account is included in the report, calculate the balance from the cells
         if (m_config_f.includes(splitAccount)) {
           loanBalances[splitAccount.id()] = cellBalance(outergroup, splitAccount, column, false);
         } else {
           //if it is not in the report and also not in loanBalances, get the balance from the file
           if (!loanBalances.contains(splitAccount.id())) {
             QDate dueDate = sched.nextDueDate();
 
             //if the payment is overdue, use current date
             if (dueDate < QDate::currentDate())
               dueDate = QDate::currentDate();
 
             //get the balance from the file for the date
             loanBalances[splitAccount.id()] = file->balance(splitAccount.id(), dueDate.addDays(-1));
           }
         }
 
         KMyMoneyUtils::calculateAutoLoan(sched, tx, loanBalances);
 
         //if the loan split is not included in the report, update the balance for the next occurrence
         if (!m_config_f.includes(splitAccount)) {
           QList<MyMoneySplit>::ConstIterator it_loanSplits;
           for (it_loanSplits = tx.splits().constBegin(); it_loanSplits != tx.splits().constEnd(); ++it_loanSplits) {
             if ((*it_loanSplits).isAmortizationSplit() && (*it_loanSplits).accountId() == splitAccount.id())
               loanBalances[splitAccount.id()] = loanBalances[splitAccount.id()] + (*it_loanSplits).shares();
           }
         }
       }
     }
 
     QList<MyMoneySplit> splits = tx.splits();
     QList<MyMoneySplit>::const_iterator it_split = splits.constBegin();
     while (it_split != splits.constEnd()) {
       ReportAccount splitAccount = (*it_split).accountId();
 
       // Each split must be further filtered, because if even one split matches,
       // the ENTIRE transaction is returned with all splits (even non-matching ones)
       if (m_config_f.includes(splitAccount) && m_config_f.match(&(*it_split))) {
         // reverse sign to match common notation for cash flow direction, only for expense/income splits
         MyMoneyMoney reverse(splitAccount.isIncomeExpense() ? -1 : 1, 1);
 
         MyMoneyMoney value;
         // the outer group is the account class (major account type)
         MyMoneyAccount::accountTypeE type = splitAccount.accountGroup();
         QString outergroup = KMyMoneyUtils::accountTypeToString(type);
 
         value = (*it_split).shares();
         bool stockSplit = tx.isStockSplit();
         if (!stockSplit) {
           // retrieve the value in the account's underlying currency
           if (value != MyMoneyMoney::autoCalc) {
             value = value * reverse;
           } else {
             qDebug("PivotTable::PivotTable(): This must not happen");
             value = MyMoneyMoney();  // keep it 0 so far
           }
 
           // Except in the case of transfers on an income/expense report
           if (al_transfers && (type == MyMoneyAccount::Asset || type == MyMoneyAccount::Liability)) {
             outergroup = i18n("Transfers");
             value = -value;
           }
         }
         // add the value to its correct position in the pivot table
         assignCell(outergroup, splitAccount, column, value, false, stockSplit);
       }
       ++it_split;
     }
 
     ++it_transaction;
   }
 
   //
   // Get forecast data
   //
   if (m_config_f.isIncludingForecast())
     calculateForecast();
 
   //
   //Insert Price data
   //
   if (m_config_f.isIncludingPrice())
     fillBasePriceUnit(ePrice);
 
   //
   //Insert Average Price data
   //
   if (m_config_f.isIncludingAveragePrice()) {
     fillBasePriceUnit(eActual);
     calculateMovingAverage();
   }
 
   //
   // Collapse columns to match column type
   //
 
 
   if (m_config_f.columnPitch() > 1)
     collapseColumns();
 
   //
   // Calculate the running sums
   // (for running sum reports only)
   //
 
   if (m_config_f.isRunningSum())
     calculateRunningSums();
 
   //
   // Calculate Moving Average
   //
   if (m_config_f.isIncludingMovingAverage())
     calculateMovingAverage();
 
   //
   // Calculate Budget Difference
   //
 
   if (m_config_f.isIncludingBudgetActuals())
     calculateBudgetDiff();
 
   //
   // Convert all values to the deep currency
   //
 
   convertToDeepCurrency();
 
   //
   // Convert all values to the base currency
   //
 
   if (m_config_f.isConvertCurrency())
     convertToBaseCurrency();
 
   //
   // Determine column headings
   //
 
   calculateColumnHeadings();
 
   //
   // Calculate row and column totals
   //
 
   calculateTotals();
 
   //
   // If using mixed time, calculate column for current date
   //
   m_config_f.setCurrentDateColumn(currentDateColumn());
 }
 
 void PivotTable::collapseColumns()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   int columnpitch = m_config_f.columnPitch();
   if (columnpitch != 1) {
     int sourcemonth = (m_config_f.isColumnsAreDays())
                       // use the user's locale to determine the week's start
                       ? (m_beginDate.dayOfWeek() + 8 - KGlobal::locale()->weekStartDay()) % 7
                       : m_beginDate.month();
     int sourcecolumn = 1;
     int destcolumn = 1;
     while (sourcecolumn < m_numColumns) {
       if (sourcecolumn != destcolumn) {
 #if 0
         // TODO: Clean up this rather inefficient kludge. We really should jump by an entire
         // destcolumn at a time on RS reports, and calculate the proper sourcecolumn to use,
         // allowing us to clear and accumulate only ONCE per destcolumn
         if (m_config_f.isRunningSum())
           clearColumn(destcolumn);
 #endif
         accumulateColumn(destcolumn, sourcecolumn);
       }
 
       if (++sourcecolumn < m_numColumns) {
         if ((sourcemonth++ % columnpitch) == 0) {
           if (sourcecolumn != ++destcolumn)
             clearColumn(destcolumn);
         }
       }
     }
     m_numColumns = destcolumn + 1;
   }
 }
 
 void PivotTable::accumulateColumn(int destcolumn, int sourcecolumn)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("From Column %1 to %2").arg(sourcecolumn).arg(destcolumn));
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     // iterate over inner groups
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       // iterator over rows
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         if ((*it_row)[eActual].count() <= sourcecolumn)
           throw MYMONEYEXCEPTION(QString("Sourcecolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
         if ((*it_row)[eActual].count() <= destcolumn)
           throw MYMONEYEXCEPTION(QString("Destcolumn %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(sourcecolumn).arg((*it_row)[eActual].count()));
 
         (*it_row)[eActual][destcolumn] += (*it_row)[eActual][sourcecolumn];
         ++it_row;
       }
 
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::clearColumn(int column)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("Column %1").arg(column));
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     // iterate over inner groups
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       // iterator over rows
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         if ((*it_row)[eActual].count() <= column)
           throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::accumulateColumn").arg(column).arg((*it_row)[eActual].count()));
 
         (*it_row++)[eActual][column] = PivotCell();
       }
 
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::calculateColumnHeadings()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // one column for the opening balance
   m_columnHeadings.append("Opening");
 
   int columnpitch = m_config_f.columnPitch();
 
   if (columnpitch == 0) {
     // output the warning but don't crash by dividing with 0
     qWarning("PivotTable::calculateColumnHeadings() Invalid column pitch");
     return;
   }
 
   // if this is a days-based report
   if (m_config_f.isColumnsAreDays()) {
     if (columnpitch == 1) {
       QDate columnDate = m_beginDate;
       int column = 1;
       while (column++ < m_numColumns) {
         QString heading = KGlobal::locale()->calendar()->monthName(columnDate.month(), columnDate.year(), KCalendarSystem::ShortName) + ' ' + QString::number(columnDate.day());
         columnDate = columnDate.addDays(1);
         m_columnHeadings.append(heading);
       }
     } else {
       QDate day = m_beginDate;
       QDate prv = m_beginDate;
 
       // use the user's locale to determine the week's start
       int dow = (day.dayOfWeek() + 8 - KGlobal::locale()->weekStartDay()) % 7;
 
       while (day <= m_endDate) {
         if (((dow % columnpitch) == 0) || (day == m_endDate)) {
           m_columnHeadings.append(QString("%1&nbsp;%2 - %3&nbsp;%4")
                                   .arg(KGlobal::locale()->calendar()->monthName(prv.month(), prv.year(), KCalendarSystem::ShortName))
                                   .arg(prv.day())
                                   .arg(KGlobal::locale()->calendar()->monthName(day.month(), day.year(), KCalendarSystem::ShortName))
                                   .arg(day.day()));
           prv = day.addDays(1);
         }
         day = day.addDays(1);
         dow++;
       }
     }
   }
 
   // else it's a months-based report
   else {
     if (columnpitch == 12) {
       int year = m_beginDate.year();
       int column = 1;
       while (column++ < m_numColumns)
         m_columnHeadings.append(QString::number(year++));
     } else {
       int year = m_beginDate.year();
       bool includeyear = (m_beginDate.year() != m_endDate.year());
       int segment = (m_beginDate.month() - 1) / columnpitch;
       int column = 1;
       while (column++ < m_numColumns) {
         QString heading = KGlobal::locale()->calendar()->monthName(1 + segment * columnpitch, 2000, KCalendarSystem::ShortName);
         if (columnpitch != 1)
           heading += '-' + KGlobal::locale()->calendar()->monthName((1 + segment) * columnpitch, 2000, KCalendarSystem::ShortName);
         if (includeyear)
           heading += ' ' + QString::number(year);
         m_columnHeadings.append(heading);
         if (++segment >= 12 / columnpitch) {
           segment -= 12 / columnpitch;
           ++year;
         }
       }
     }
   }
 }
 
 void PivotTable::createAccountRows()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
 
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
 
   while (it_account != accounts.constEnd()) {
     ReportAccount account = *it_account;
 
     // only include this item if its account group is included in this report
     // and if the report includes this account
     if (m_config_f.includes(*it_account)) {
       DEBUG_OUTPUT(QString("Includes account %1").arg(account.name()));
 
       // the row group is the account class (major account type)
       QString outergroup = KMyMoneyUtils::accountTypeToString(account.accountGroup());
       // place into the 'opening' column...
       assignCell(outergroup, account, 0, MyMoneyMoney());
     }
     ++it_account;
   }
 }
 
 void PivotTable::calculateOpeningBalances()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // First, determine the inclusive dates of the report.  Normally, that's just
   // the begin & end dates of m_config_f.  However, if either of those dates are
   // blank, we need to use m_beginDate and/or m_endDate instead.
   QDate from = m_config_f.fromDate();
   QDate to = m_config_f.toDate();
   if (! from.isValid())
     from = m_beginDate;
   if (! to.isValid())
     to = m_endDate;
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   QList<MyMoneyAccount> accounts;
   file->accountList(accounts);
 
   QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
 
   while (it_account != accounts.constEnd()) {
     ReportAccount account = *it_account;
 
     // only include this item if its account group is included in this report
     // and if the report includes this account
     if (m_config_f.includes(*it_account)) {
 
       //do not include account if it is closed and it has no transactions in the report period
       if (account.isClosed()) {
         //check if the account has transactions for the report timeframe
         MyMoneyTransactionFilter filter;
         filter.addAccount(account.id());
         filter.setDateFilter(m_beginDate, m_endDate);
         filter.setReportAllSplits(false);
         QList<MyMoneyTransaction> transactions = file->transactionList(filter);
         //if a closed account has no transactions in that timeframe, do not include it
         if (transactions.size() == 0) {
           DEBUG_OUTPUT(QString("DOES NOT INCLUDE account %1").arg(account.name()));
           ++it_account;
           continue;
         }
       }
 
       DEBUG_OUTPUT(QString("Includes account %1").arg(account.name()));
       // the row group is the account class (major account type)
       QString outergroup = KMyMoneyUtils::accountTypeToString(account.accountGroup());
 
       // extract the balance of the account for the given begin date, which is
       // the opening balance plus the sum of all transactions prior to the begin
       // date
 
       // this is in the underlying currency
       MyMoneyMoney value = file->balance(account.id(), from.addDays(-1));
 
       // place into the 'opening' column...
       assignCell(outergroup, account, 0, value);
     } else {
       DEBUG_OUTPUT(QString("DOES NOT INCLUDE account %1").arg(account.name()));
     }
 
     ++it_account;
   }
 }
 
 void PivotTable::calculateRunningSums(PivotInnerGroup::iterator& it_row)
 {
   MyMoneyMoney runningsum = it_row.value()[eActual][0].calculateRunningSum(MyMoneyMoney());
   int column = 1;
   while (column < m_numColumns) {
     if (it_row.value()[eActual].count() <= column)
       throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
 
     runningsum = it_row.value()[eActual][column].calculateRunningSum(runningsum);
 
     ++column;
   }
 }
 
 void PivotTable::calculateRunningSums()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   m_runningSumsCalculated = true;
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
 #if 0
         MyMoneyMoney runningsum = it_row.value()[0];
         int column = 1;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
             throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateRunningSums").arg(column).arg(it_row.value()[eActual].count()));
 
           runningsum = (it_row.value()[eActual][column] += runningsum);
 
           ++column;
         }
 #endif
         calculateRunningSums(it_row);
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 MyMoneyMoney PivotTable::cellBalance(const QString& outergroup, const ReportAccount& _row, int _column, bool budget)
 {
   if (m_runningSumsCalculated) {
     qDebug("You must not call PivotTable::cellBalance() after calling PivotTable::calculateRunningSums()");
     throw MYMONEYEXCEPTION(QString("You must not call PivotTable::cellBalance() after calling PivotTable::calculateRunningSums()"));
   }
 
   // for budget reports, if this is the actual value, map it to the account which
   // holds its budget
   ReportAccount row = _row;
   if (!budget && m_config_f.hasBudget()) {
     QString newrow = m_budgetMap[row.id()];
 
     // if there was no mapping found, then the budget report is not interested
     // in this account.
     if (newrow.isEmpty())
       return MyMoneyMoney();
 
     row = newrow;
   }
 
   // ensure the row already exists (and its parental hierarchy)
   createRow(outergroup, row, true);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (m_numColumns <= _column)
     throw MYMONEYEXCEPTION(QString("Column %1 out of m_numColumns range (%2) in PivotTable::cellBalance").arg(_column).arg(m_numColumns));
   if (m_grid[outergroup][innergroup][row][eActual].count() <= _column)
     throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(_column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
 
   MyMoneyMoney balance;
   if (budget)
     balance = m_grid[outergroup][innergroup][row][eBudget][0].cellBalance(MyMoneyMoney());
   else
     balance = m_grid[outergroup][innergroup][row][eActual][0].cellBalance(MyMoneyMoney());
 
   int column = 1;
   while (column < _column) {
     if (m_grid[outergroup][innergroup][row][eActual].count() <= column)
       throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::cellBalance").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
 
     balance = m_grid[outergroup][innergroup][row][eActual][column].cellBalance(balance);
 
     ++column;
   }
 
   return balance;
 }
 
 
 void PivotTable::calculateBudgetMapping()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   // Only do this if there is at least one budget in the file
   if (file->countBudgets()) {
     // Select a budget
     //
     // It will choose the first budget in the list for the start year of the report if no budget is selected
     MyMoneyBudget budget = MyMoneyBudget();
     QList<MyMoneyBudget> budgets = file->budgetList();
     bool validBudget = false;
 
     //check that the selected budget is valid
     if (m_config_f.budget() != "Any") {
       QList<MyMoneyBudget>::const_iterator budgets_it = budgets.constBegin();
       while (budgets_it != budgets.constEnd()) {
         //pick the budget by id
         if ((*budgets_it).id() == m_config_f.budget()) {
           budget = file->budget((*budgets_it).id());
           validBudget = true;
           break;
         }
         ++budgets_it;
       }
     }
 
     //if no valid budget has been selected
     if (!validBudget) {
       //if the budget list is empty, just return
       if (budgets.count() == 0) {
         return;
       }
 
       QList<MyMoneyBudget>::const_iterator budgets_it = budgets.constBegin();
       while (budgets_it != budgets.constEnd()) {
         //pick the first budget that matches the report start year
         if ((*budgets_it).budgetStart().year() == QDate::currentDate().year()) {
           budget = file->budget((*budgets_it).id());
           break;
         }
         ++budgets_it;
       }
       //if it can't find a matching budget, take the first one on the list
       if (budget.id().isEmpty()) {
         budget = budgets[0];
       }
 
       //assign the budget to the report
       m_config_f.setBudget(budget.id(), m_config_f.isIncludingBudgetActuals());
     }
 
     // Dump the budget
     //kDebug(2) << "Budget " << budget.name() << ": ";
 
     // Go through all accounts in the system to build the mapping
     QList<MyMoneyAccount> accounts;
     file->accountList(accounts);
     QList<MyMoneyAccount>::const_iterator it_account = accounts.constBegin();
     while (it_account != accounts.constEnd()) {
       //include only the accounts selected for the report
       if (m_config_f.includes(*it_account)) {
         QString id = (*it_account).id();
         QString acid = id;
 
         // If the budget contains this account outright
         if (budget.contains(id)) {
           // Add it to the mapping
           m_budgetMap[acid] = id;
           // kDebug(2) << ReportAccount(acid).debugName() << " self-maps / type =" << budget.account(id).budgetLevel();
         }
         // Otherwise, search for a parent account which includes sub-accounts
         else {
           //if includeBudgetActuals, include all accounts regardless of whether in budget or not
           if (m_config_f.isIncludingBudgetActuals()) {
             m_budgetMap[acid] = id;
             // kDebug(2) << ReportAccount(acid).debugName() << " maps to " << ReportAccount(id).debugName();
           }
           do {
             id = file->account(id).parentAccountId();
             if (budget.contains(id)) {
               if (budget.account(id).budgetSubaccounts()) {
                 m_budgetMap[acid] = id;
                 // kDebug(2) << ReportAccount(acid).debugName() << " maps to " << ReportAccount(id).debugName();
                 break;
               }
             }
           } while (! id.isEmpty());
         }
       }
       ++it_account;
     } // end while looping through the accounts in the file
 
     // Place the budget values into the budget grid
     QList<MyMoneyBudget::AccountGroup> baccounts = budget.getaccounts();
     QList<MyMoneyBudget::AccountGroup>::const_iterator it_bacc = baccounts.constBegin();
     while (it_bacc != baccounts.constEnd()) {
       ReportAccount splitAccount = (*it_bacc).id();
 
       //include the budget account only if it is included in the report
       if (m_config_f.includes(splitAccount)) {
         MyMoneyAccount::accountTypeE type = splitAccount.accountGroup();
         QString outergroup = KMyMoneyUtils::accountTypeToString(type);
 
         // reverse sign to match common notation for cash flow direction, only for expense/income splits
         MyMoneyMoney reverse((splitAccount.accountType() == MyMoneyAccount::Expense) ? -1 : 1, 1);
 
         const QMap<QDate, MyMoneyBudget::PeriodGroup>& periods = (*it_bacc).getPeriods();
 
         // skip the account if it has no periods
         if (periods.count() < 1) {
           ++it_bacc;
           continue;
         }
 
         MyMoneyMoney value = (*periods.begin()).amount() * reverse;
         int column = 1;
 
         // based on the kind of budget it is, deal accordingly
         switch ((*it_bacc).budgetLevel()) {
           case MyMoneyBudget::AccountGroup::eYearly:
             // divide the single yearly value by 12 and place it in each column
             value /= MyMoneyMoney(12, 1);
           case MyMoneyBudget::AccountGroup::eNone:
           case MyMoneyBudget::AccountGroup::eMax:
           case MyMoneyBudget::AccountGroup::eMonthly:
             // place the single monthly value in each column of the report
             // only add the value if columns are monthly or longer
-            if (m_config_f.columnType() == MyMoneyReport::eBiMonths
-                || m_config_f.columnType() == MyMoneyReport::eMonths
-                || m_config_f.columnType() == MyMoneyReport::eYears
-                || m_config_f.columnType() == MyMoneyReport::eQuarters) {
+            if (m_config_f.columnType() == MyMoneyReport::Column::BiMonths
+                || m_config_f.columnType() == MyMoneyReport::Column::Months
+                || m_config_f.columnType() == MyMoneyReport::Column::Years
+                || m_config_f.columnType() == MyMoneyReport::Column::Quarters) {
               QDate budgetDate = budget.budgetStart();
               while (column < m_numColumns && budget.budgetStart().addYears(1) > budgetDate) {
                 //only show budget values if the budget year and the column date match
                 //no currency conversion is done here because that is done for all columns later
                 if (budgetDate > columnDate(column)) {
                   ++column;
                 } else {
                   if (budgetDate >= m_beginDate.addDays(-m_beginDate.day() + 1)
                       && budgetDate <= m_endDate.addDays(m_endDate.daysInMonth() - m_endDate.day())
                       && budgetDate > (columnDate(column).addMonths(-m_config_f.columnType()))) {
                     assignCell(outergroup, splitAccount, column, value, true /*budget*/);
                   }
                   budgetDate = budgetDate.addMonths(1);
                 }
               }
             }
             break;
           case MyMoneyBudget::AccountGroup::eMonthByMonth:
             // place each value in the appropriate column
             // budget periods are supposed to come in order just like columns
             {
               QMap<QDate, MyMoneyBudget::PeriodGroup>::const_iterator it_period = periods.begin();
               while (it_period != periods.end() && column < m_numColumns) {
                 if ((*it_period).startDate() > columnDate(column)) {
                   ++column;
                 } else {
                   switch (m_config_f.columnType()) {
-                    case MyMoneyReport::eYears:
-                    case MyMoneyReport::eBiMonths:
-                    case MyMoneyReport::eQuarters:
-                    case MyMoneyReport::eMonths: {
+                    case MyMoneyReport::Column::Years:
+                    case MyMoneyReport::Column::BiMonths:
+                    case MyMoneyReport::Column::Quarters:
+                    case MyMoneyReport::Column::Months: {
                         if ((*it_period).startDate() >= m_beginDate.addDays(-m_beginDate.day() + 1)
                             && (*it_period).startDate() <= m_endDate.addDays(m_endDate.daysInMonth() - m_endDate.day())
                             && (*it_period).startDate() > (columnDate(column).addMonths(-m_config_f.columnType()))) {
                           //no currency conversion is done here because that is done for all columns later
                           value = (*it_period).amount() * reverse;
                           assignCell(outergroup, splitAccount, column, value, true /*budget*/);
                         }
                         ++it_period;
                         break;
                       }
                     default:
                       break;
                   }
                 }
               }
               break;
             }
         }
       }
       ++it_bacc;
     }
   } // end if there was a budget
 }
 
 void PivotTable::convertToBaseCurrency()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   int fraction = MyMoneyFile::instance()->baseCurrency().smallestAccountFraction();
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
             throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::convertToBaseCurrency").arg(column).arg(it_row.value()[eActual].count()));
 
           QDate valuedate = columnDate(column);
 
           //get base price for that date
           MyMoneyMoney conversionfactor = it_row.key().baseCurrencyPrice(valuedate, m_config_f.isSkippingZero());
 
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             if (m_rowTypeList[i] != eAverage) {
               //calculate base value
               MyMoneyMoney oldval = it_row.value()[ m_rowTypeList[i] ][column];
               MyMoneyMoney value = (oldval * conversionfactor).reduce();
 
               //convert to lowest fraction
               it_row.value()[ m_rowTypeList[i] ][column] = PivotCell(value.convert(fraction));
 
               DEBUG_OUTPUT_IF(conversionfactor != MyMoneyMoney::ONE , QString("Factor of %1, value was %2, now %3").arg(conversionfactor.toDouble()).arg(DEBUG_SENSITIVE(oldval.toDouble())).arg(DEBUG_SENSITIVE(it_row.value()[m_rowTypeList[i]][column].toDouble())));
             }
           }
 
 
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::convertToDeepCurrency()
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   MyMoneyFile* file = MyMoneyFile::instance();
 
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
         while (column < m_numColumns) {
           if (it_row.value()[eActual].count() <= column)
             throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::convertToDeepCurrency").arg(column).arg(it_row.value()[eActual].count()));
 
           QDate valuedate = columnDate(column);
 
           //get conversion factor for the account and date
           MyMoneyMoney conversionfactor = it_row.key().deepCurrencyPrice(valuedate, m_config_f.isSkippingZero());
 
           //use the fraction relevant to the account at hand
           int fraction = it_row.key().currency().smallestAccountFraction();
 
           //use base currency fraction if not initialized
           if (fraction == -1)
             fraction = file->baseCurrency().smallestAccountFraction();
 
           //convert to deep currency
           MyMoneyMoney oldval = it_row.value()[eActual][column];
           MyMoneyMoney value = (oldval * conversionfactor).reduce();
           //reduce to lowest fraction
           it_row.value()[eActual][column] = PivotCell(value.convert(fraction));
 
           //convert price data
           if (m_config_f.isIncludingPrice()) {
             MyMoneyMoney oldPriceVal = it_row.value()[ePrice][column];
             MyMoneyMoney priceValue = (oldPriceVal * conversionfactor).reduce();
             it_row.value()[ePrice][column] = PivotCell(priceValue.convert(10000));
           }
 
           DEBUG_OUTPUT_IF(conversionfactor != MyMoneyMoney::ONE , QString("Factor of %1, value was %2, now %3").arg(conversionfactor.toDouble()).arg(DEBUG_SENSITIVE(oldval.toDouble())).arg(DEBUG_SENSITIVE(it_row.value()[eActual][column].toDouble())));
 
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::calculateTotals()
 {
   //insert the row type that is going to be used
   for (int i = 0; i < m_rowTypeList.size(); ++i) {
     for (int k = 0; k < m_numColumns; ++k) {
       m_grid.m_total[ m_rowTypeList[i] ].append(PivotCell());
     }
   }
   //
   // Outer groups
   //
 
   // iterate over outer groups
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     for (int i = 0; i < m_rowTypeList.size(); ++i) {
       for (int k = 0; k < m_numColumns; ++k) {
         (*it_outergroup).m_total[ m_rowTypeList[i] ].append(PivotCell());
       }
     }
 
     //
     // Inner Groups
     //
 
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         for (int k = 0; k < m_numColumns; ++k) {
           (*it_innergroup).m_total[ m_rowTypeList[i] ].append(PivotCell());
         }
       }
       //
       // Rows
       //
 
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         //
         // Columns
         //
 
         int column = 1;
         while (column < m_numColumns) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             if (it_row.value()[ m_rowTypeList[i] ].count() <= column)
               throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, row columns").arg(column).arg(it_row.value()[ m_rowTypeList[i] ].count()));
             if ((*it_innergroup).m_total[ m_rowTypeList[i] ].count() <= column)
               throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
             //calculate total
             MyMoneyMoney value = it_row.value()[ m_rowTypeList[i] ][column];
             (*it_innergroup).m_total[ m_rowTypeList[i] ][column] += value;
             (*it_row)[ m_rowTypeList[i] ].m_total += value;
           }
           ++column;
         }
         ++it_row;
       }
 
       //
       // Inner Row Group Totals
       //
 
       int column = 1;
       while (column < m_numColumns) {
         for (int i = 0; i < m_rowTypeList.size(); ++i) {
           if ((*it_innergroup).m_total[ m_rowTypeList[i] ].count() <= column)
             throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, inner group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
           if ((*it_outergroup).m_total[ m_rowTypeList[i] ].count() <= column)
             throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, outer group totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
           //calculate totals
           MyMoneyMoney value = (*it_innergroup).m_total[ m_rowTypeList[i] ][column];
           (*it_outergroup).m_total[ m_rowTypeList[i] ][column] += value;
           (*it_innergroup).m_total[ m_rowTypeList[i] ].m_total += value;
         }
         ++column;
       }
 
       ++it_innergroup;
     }
 
     //
     // Outer Row Group Totals
     //
 
     const bool isIncomeExpense = (m_config_f.rowType() == MyMoneyReport::eExpenseIncome);
     const bool invert_total = (*it_outergroup).m_inverted;
     int column = 1;
     while (column < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         if (m_grid.m_total[ m_rowTypeList[i] ].count() <= column)
           throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(column).arg((*it_innergroup).m_total[ m_rowTypeList[i] ].count()));
 
         //calculate actual totals
         MyMoneyMoney value = (*it_outergroup).m_total[ m_rowTypeList[i] ][column];
         (*it_outergroup).m_total[ m_rowTypeList[i] ].m_total += value;
 
         //so far the invert only applies to actual and budget
         if (invert_total && m_rowTypeList[i] != eBudgetDiff && m_rowTypeList[i] != eForecast)
           value = -value;
         // forecast income expense reports should be inverted as oposed to asset/liability reports
         if (invert_total && isIncomeExpense && m_rowTypeList[i] == eForecast)
           value = -value;
 
         m_grid.m_total[ m_rowTypeList[i] ][column] += value;
       }
       ++column;
     }
     ++it_outergroup;
   }
 
   //
   // Report Totals
   //
 
   int totalcolumn = 1;
   while (totalcolumn < m_numColumns) {
     for (int i = 0; i < m_rowTypeList.size(); ++i) {
       if (m_grid.m_total[ m_rowTypeList[i] ].count() <= totalcolumn)
         throw MYMONEYEXCEPTION(QString("Total column %1 out of grid range (%2) in PivotTable::calculateTotals, grid totals").arg(totalcolumn).arg(m_grid.m_total[ m_rowTypeList[i] ].count()));
 
       //calculate actual totals
       MyMoneyMoney value = m_grid.m_total[ m_rowTypeList[i] ][totalcolumn];
       m_grid.m_total[ m_rowTypeList[i] ].m_total += value;
     }
     ++totalcolumn;
   }
 }
 
 void PivotTable::assignCell(const QString& outergroup, const ReportAccount& _row, int column, MyMoneyMoney value, bool budget, bool stockSplit)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
   DEBUG_OUTPUT(QString("Parameters: %1,%2,%3,%4,%5").arg(outergroup).arg(_row.debugName()).arg(column).arg(DEBUG_SENSITIVE(value.toDouble())).arg(budget));
 
   // for budget reports, if this is the actual value, map it to the account which
   // holds its budget
   ReportAccount row = _row;
   if (!budget && m_config_f.hasBudget()) {
     QString newrow = m_budgetMap[row.id()];
 
     // if there was no mapping found, then the budget report is not interested
     // in this account.
     if (newrow.isEmpty())
       return;
 
     row = newrow;
   }
 
   // ensure the row already exists (and its parental hierarchy)
   createRow(outergroup, row, true);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (m_numColumns <= column)
     throw MYMONEYEXCEPTION(QString("Column %1 out of m_numColumns range (%2) in PivotTable::assignCell").arg(column).arg(m_numColumns));
   if (m_grid[outergroup][innergroup][row][eActual].count() <= column)
     throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eActual].count()));
   if (m_grid[outergroup][innergroup][row][eBudget].count() <= column)
     throw MYMONEYEXCEPTION(QString("Column %1 out of grid range (%2) in PivotTable::assignCell").arg(column).arg(m_grid[outergroup][innergroup][row][eBudget].count()));
 
   if (!stockSplit) {
     // Determine whether the value should be inverted before being placed in the row
     if (m_grid[outergroup].m_inverted)
       value = -value;
 
     // Add the value to the grid cell
     if (budget) {
       m_grid[outergroup][innergroup][row][eBudget][column] += value;
     } else {
       // If it is loading an actual value for a budget report
       // check whether it is a subaccount of a budget account (include subaccounts)
       // If so, check if is the same currency and convert otherwise
       if (m_config_f.hasBudget() &&
           row.id() != _row.id() &&
           row.currencyId() != _row.currencyId()) {
         ReportAccount origAcc = _row;
         MyMoneyMoney rate = origAcc.foreignCurrencyPrice(row.currencyId(), columnDate(column), false);
         m_grid[outergroup][innergroup][row][eActual][column] += (value * rate).reduce();
       } else {
         m_grid[outergroup][innergroup][row][eActual][column] += value;
       }
     }
   } else {
     m_grid[outergroup][innergroup][row][eActual][column] += PivotCell::stockSplit(value);
   }
 
 }
 
 void PivotTable::createRow(const QString& outergroup, const ReportAccount& row, bool recursive)
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   // Determine the inner group from the top-most parent account
   QString innergroup(row.topParentName());
 
   if (! m_grid.contains(outergroup)) {
     DEBUG_OUTPUT(QString("Adding group [%1]").arg(outergroup));
     m_grid[outergroup] = PivotOuterGroup(m_numColumns);
   }
 
   if (! m_grid[outergroup].contains(innergroup)) {
     DEBUG_OUTPUT(QString("Adding group [%1][%2]").arg(outergroup).arg(innergroup));
     m_grid[outergroup][innergroup] = PivotInnerGroup(m_numColumns);
   }
 
   if (! m_grid[outergroup][innergroup].contains(row)) {
     DEBUG_OUTPUT(QString("Adding row [%1][%2][%3]").arg(outergroup).arg(innergroup).arg(row.debugName()));
     m_grid[outergroup][innergroup][row] = PivotGridRowSet(m_numColumns);
 
     if (recursive && !row.isTopLevel())
       createRow(outergroup, row.parent(), recursive);
   }
 }
 
 int PivotTable::columnValue(const QDate& _date) const
 {
   if (m_config_f.isColumnsAreDays())
     return (m_beginDate.daysTo(_date));
   else
     return (_date.year() * 12 + _date.month());
 }
 
 QDate PivotTable::columnDate(int column) const
 {
   if (m_config_f.isColumnsAreDays())
     return m_beginDate.addDays(m_config_f.columnPitch() * column - 1);
   else
     return m_beginDate.addMonths(m_config_f.columnPitch() * column).addDays(-1);
 }
 
 QString PivotTable::renderCSV() const
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   //
   // Report Title
   //
 
   QString result = QString("\"Report: %1\"\n").arg(m_config_f.name());
   result += i18nc("Report date range", "%1 through %2\n", KGlobal::locale()->formatDate(m_config_f.fromDate(), KLocale::ShortDate), KGlobal::locale()->formatDate(m_config_f.toDate(), KLocale::ShortDate));
   if (m_config_f.isConvertCurrency())
     result += i18n("All currencies converted to %1\n", MyMoneyFile::instance()->baseCurrency().name());
   else
     result += i18n("All values shown in %1 unless otherwise noted\n", MyMoneyFile::instance()->baseCurrency().name());
 
   //
   // Table Header
   //
 
   result += i18n("Account");
 
   int column = 1;
   while (column < m_numColumns) {
     result += QString(",%1").arg(QString(m_columnHeadings[column++]));
     if (m_rowTypeList.size() > 1) {
       QString separator;
       separator = separator.fill(',', m_rowTypeList.size() - 1);
       result += separator;
     }
   }
 
   //show total columns
   if (m_config_f.isShowingRowTotals())
     result += QString(",%1").arg(i18nc("Total balance", "Total"));
 
   result += '\n';
 
   // Row Type Header
   if (m_rowTypeList.size() > 1) {
     int column = 1;
     while (column < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString(",%1").arg(m_columnTypeHeaderList[i]);
       }
       column++;
     }
     if (m_config_f.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString(",%1").arg(m_columnTypeHeaderList[i]);
       }
     }
     result += '\n';
   }
 
   int fraction = MyMoneyFile::instance()->baseCurrency().smallestAccountFraction();
 
   //
   // Outer groups
   //
 
   // iterate over outer groups
   PivotGrid::const_iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     //
     // Outer Group Header
     //
 
     result += it_outergroup.key() + '\n';
 
     //
     // Inner Groups
     //
 
     PivotOuterGroup::const_iterator it_innergroup = (*it_outergroup).begin();
     int rownum = 0;
     while (it_innergroup != (*it_outergroup).end()) {
       //
       // Rows
       //
 
       QString innergroupdata;
       PivotInnerGroup::const_iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         ReportAccount rowname = it_row.key();
         int fraction = rowname.currency().smallestAccountFraction();
 
         //
         // Columns
         //
 
         QString rowdata;
         int column = 1;
 
         bool isUsed = false;
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           isUsed |= it_row.value()[ m_rowTypeList[i] ][0].isUsed();
 
         while (column < m_numColumns) {
           //show columns
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             isUsed |= it_row.value()[ m_rowTypeList[i] ][column].isUsed();
             rowdata += QString(",\"%1\"").arg(it_row.value()[ m_rowTypeList[i] ][column].formatMoney(fraction, false));
           }
           column++;
         }
 
         if (m_config_f.isShowingRowTotals()) {
           for (int i = 0; i < m_rowTypeList.size(); ++i)
             rowdata += QString(",\"%1\"").arg((*it_row)[ m_rowTypeList[i] ].m_total.formatMoney(fraction, false));
         }
 
         //
         // Row Header
         //
 
         if (!rowname.isClosed() || isUsed) {
           innergroupdata += "\"" + QString().fill(' ', rowname.hierarchyDepth() - 1) + rowname.name();
 
           // if we don't convert the currencies to the base currency and the
           // current row contains a foreign currency, then we append the currency
           // to the name of the account
           if (!m_config_f.isConvertCurrency() && rowname.isForeignCurrency())
             innergroupdata += QString(" (%1)").arg(rowname.currencyId());
 
           innergroupdata += '\"';
 
           if (isUsed)
             innergroupdata += rowdata;
 
           innergroupdata += '\n';
         }
         ++it_row;
       }
 
       //
       // Inner Row Group Totals
       //
 
       bool finishrow = true;
       QString finalRow;
       bool isUsed = false;
       if (m_config_f.detailLevel() == MyMoneyReport::eDetailAll && ((*it_innergroup).size() > 1)) {
         // Print the individual rows
         result += innergroupdata;
 
         if (m_config_f.isShowingColumnTotals()) {
           // Start the TOTALS row
           finalRow = i18nc("Total balance", "Total");
           isUsed = true;
         } else {
           ++rownum;
           finishrow = false;
         }
       } else {
         // Start the single INDIVIDUAL ACCOUNT row
         ReportAccount rowname = (*it_innergroup).begin().key();
         isUsed |= !rowname.isClosed();
 
         finalRow = "\"" + QString().fill(' ', rowname.hierarchyDepth() - 1) + rowname.name();
         if (!m_config_f.isConvertCurrency() && rowname.isForeignCurrency())
           finalRow += QString(" (%1)").arg(rowname.currencyId());
         finalRow += "\"";
       }
 
       // Finish the row started above, unless told not to
       if (finishrow) {
         int column = 1;
 
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][0].isUsed();
 
         while (column < m_numColumns) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][column].isUsed();
             finalRow += QString(",\"%1\"").arg((*it_innergroup).m_total[ m_rowTypeList[i] ][column].formatMoney(fraction, false));
           }
           column++;
         }
 
         if (m_config_f.isShowingRowTotals()) {
           for (int i = 0; i < m_rowTypeList.size(); ++i)
             finalRow += QString(",\"%1\"").arg((*it_innergroup).m_total[ m_rowTypeList[i] ].m_total.formatMoney(fraction, false));
         }
 
         finalRow += '\n';
       }
 
       if (isUsed) {
         result += finalRow;
         ++rownum;
       }
       ++it_innergroup;
     }
 
     //
     // Outer Row Group Totals
     //
 
     if (m_config_f.isShowingColumnTotals()) {
       result += QString("%1 %2").arg(i18nc("Total balance", "Total")).arg(it_outergroup.key());
       int column = 1;
       while (column < m_numColumns) {
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           result += QString(",\"%1\"").arg((*it_outergroup).m_total[ m_rowTypeList[i] ][column].formatMoney(fraction, false));
 
         column++;
       }
 
       if (m_config_f.isShowingRowTotals()) {
         for (int i = 0; i < m_rowTypeList.size(); ++i)
           result += QString(",\"%1\"").arg((*it_outergroup).m_total[ m_rowTypeList[i] ].m_total.formatMoney(fraction, false));
       }
 
       result += '\n';
     }
     ++it_outergroup;
   }
 
   //
   // Report Totals
   //
 
   if (m_config_f.isShowingColumnTotals()) {
     result += i18n("Grand Total");
     int totalcolumn = 1;
     while (totalcolumn < m_numColumns) {
       for (int i = 0; i < m_rowTypeList.size(); ++i)
         result += QString(",\"%1\"").arg(m_grid.m_total[ m_rowTypeList[i] ][totalcolumn].formatMoney(fraction, false));
 
       totalcolumn++;
     }
 
     if (m_config_f.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i)
         result += QString(",\"%1\"").arg(m_grid.m_total[ m_rowTypeList[i] ].m_total.formatMoney(fraction, false));
     }
 
     result += '\n';
   }
 
   return result;
 }
 
 QString PivotTable::renderBody() const
 {
   DEBUG_ENTER(Q_FUNC_INFO);
 
   QString colspan = QString(" colspan=\"%1\"").arg(m_numColumns + 1 + (m_config_f.isShowingRowTotals() ? 1 : 0));
 
   //
   // Report Title
   //
 
   QString result = QString("<h2 class=\"report\">%1</h2>\n").arg(m_config_f.name());
 
   //actual dates of the report
   result += QString("<div class=\"subtitle\">");
   result += i18nc("Report date range", "%1 through %2", KGlobal::locale()->formatDate(m_config_f.fromDate(), KLocale::ShortDate), KGlobal::locale()->formatDate(m_config_f.toDate(), KLocale::ShortDate));
   result += QString("</div>\n");
   result += QString("<div class=\"gap\">&nbsp;</div>\n");
 
   //currency conversion message
   result += QString("<div class=\"subtitle\">");
   if (m_config_f.isConvertCurrency())
     result += i18n("All currencies converted to %1", MyMoneyFile::instance()->baseCurrency().name());
   else
     result += i18n("All values shown in %1 unless otherwise noted", MyMoneyFile::instance()->baseCurrency().name());
   result += QString("</div>\n");
   result += QString("<div class=\"gap\">&nbsp;</div>\n");
 
   // setup a leftborder for better readability of budget vs actual reports
   QString leftborder;
   if (m_rowTypeList.size() > 1)
     leftborder = " class=\"leftborder\"";
 
   //
   // Table Header
   //
   result += QString("\n\n<table class=\"report\" cellspacing=\"0\">\n"
                     "<thead><tr class=\"itemheader\">\n<th>%1</th>").arg(i18n("Account"));
 
   QString headerspan;
   int span = m_rowTypeList.size();
 
   headerspan = QString(" colspan=\"%1\"").arg(span);
 
   int column = 1;
   while (column < m_numColumns)
     result += QString("<th%1>%2</th>").arg(headerspan, QString(m_columnHeadings[column++]).replace(QRegExp(" "), "<br>"));
 
   if (m_config_f.isShowingRowTotals())
     result += QString("<th%1>%2</th>").arg(headerspan).arg(i18nc("Total balance", "Total"));
 
   result += "</tr></thead>\n";
 
   //
   // Header for multiple columns
   //
   if (span > 1) {
     result += "<tr><td></td>";
 
     int column = 1;
     while (column < m_numColumns) {
       QString lb;
       if (column != 1)
         lb = leftborder;
 
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(m_columnTypeHeaderList[i])
                   .arg(i == 0 ? lb : QString());
       }
       column++;
     }
     if (m_config_f.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(m_columnTypeHeaderList[i])
                   .arg(i == 0 ? leftborder : QString());
       }
     }
     result += "</tr>";
   }
 
 
   // Skip the body of the report if the report only calls for totals to be shown
   if (m_config_f.detailLevel() != MyMoneyReport::eDetailTotal) {
     //
     // Outer groups
     //
 
     // Need to sort the outergroups.  They can't always be sorted by name.  So we create a list of
     // map iterators, and sort that.  Then we'll iterate through the map iterators and use those as
     // before.
     //
     // I hope this doesn't bog the performance of reports, given that we're copying the entire report
     // data.  If this is a perf hit, we could change to storing outergroup pointers, I think.
     QList<PivotOuterGroup> outergroups;
     PivotGrid::const_iterator it_outergroup_map = m_grid.begin();
     while (it_outergroup_map != m_grid.end()) {
       outergroups.push_back(it_outergroup_map.value());
 
       // copy the name into the outergroup, because we will now lose any association with
       // the map iterator
       outergroups.back().m_displayName = it_outergroup_map.key();
 
       ++it_outergroup_map;
     }
     qSort(outergroups.begin(), outergroups.end());
 
     QList<PivotOuterGroup>::const_iterator it_outergroup = outergroups.constBegin();
     while (it_outergroup != outergroups.constEnd()) {
       //
       // Outer Group Header
       //
 
       result += QString("<tr class=\"sectionheader\"><td class=\"left\"%1>%2</td></tr>\n").arg(colspan).arg((*it_outergroup).m_displayName);
 
       // Skip the inner groups if the report only calls for outer group totals to be shown
       if (m_config_f.detailLevel() != MyMoneyReport::eDetailGroup) {
 
         //
         // Inner Groups
         //
 
         PivotOuterGroup::const_iterator it_innergroup = (*it_outergroup).begin();
         int rownum = 0;
         while (it_innergroup != (*it_outergroup).end()) {
           //
           // Rows
           //
 
           QString innergroupdata;
           PivotInnerGroup::const_iterator it_row = (*it_innergroup).begin();
           while (it_row != (*it_innergroup).end()) {
             //
             // Columns
             //
 
             QString rowdata;
             int column = 1;
             bool isUsed = it_row.value()[eActual][0].isUsed();
             while (column < m_numColumns) {
               QString lb;
               if (column != 1)
                 lb = leftborder;
 
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 rowdata += QString("<td%2>%1</td>")
                            .arg(coloredAmount(it_row.value()[ m_rowTypeList[i] ][column]))
                            .arg(i == 0 ? lb : QString());
 
                 isUsed |= it_row.value()[ m_rowTypeList[i] ][column].isUsed();
               }
 
               column++;
             }
 
             if (m_config_f.isShowingRowTotals()) {
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 rowdata += QString("<td%2>%1</td>")
                            .arg(coloredAmount(it_row.value()[ m_rowTypeList[i] ].m_total))
                            .arg(i == 0 ? leftborder : QString());
               }
             }
 
             //
             // Row Header
             //
 
             ReportAccount rowname = it_row.key();
 
             // don't show closed accounts if they have not been used
             if (!rowname.isClosed() || isUsed) {
               innergroupdata += QString("<tr class=\"row-%1\"%2><td%3 class=\"left\" style=\"text-indent: %4.0em\">%5%6</td>")
                                 .arg(rownum & 0x01 ? "even" : "odd")
                                 .arg(rowname.isTopLevel() ? " id=\"topparent\"" : "")
                                 .arg("") //.arg((*it_row).m_total.isZero() ? colspan : "")  // colspan the distance if this row will be blank
                                 .arg(rowname.hierarchyDepth() - 1)
                                 .arg(rowname.name().replace(QRegExp(" "), "&nbsp;"))
                                 .arg((m_config_f.isConvertCurrency() || !rowname.isForeignCurrency()) ? QString() : QString(" (%1)").arg(rowname.currency().id()));
 
               // Don't print this row if it's going to be all zeros
               // TODO: Uncomment this, and deal with the case where the data
               // is zero, but the budget is non-zero
               //if ( !(*it_row).m_total.isZero() )
               innergroupdata += rowdata;
 
               innergroupdata += "</tr>\n";
             }
 
             ++it_row;
           }
 
           //
           // Inner Row Group Totals
           //
 
           bool finishrow = true;
           QString finalRow;
           bool isUsed = false;
           if (m_config_f.detailLevel() == MyMoneyReport::eDetailAll && ((*it_innergroup).size() > 1)) {
             // Print the individual rows
             result += innergroupdata;
 
             if (m_config_f.isShowingColumnTotals()) {
               // Start the TOTALS row
               finalRow = QString("<tr class=\"row-%1\" id=\"subtotal\"><td class=\"left\">&nbsp;&nbsp;%2</td>")
                          .arg(rownum & 0x01 ? "even" : "odd")
                          .arg(i18nc("Total balance", "Total"));
               // don't suppress display of totals
               isUsed = true;
             } else {
               finishrow = false;
               ++rownum;
             }
           } else {
             // Start the single INDIVIDUAL ACCOUNT row
             // FIXME: There is a bit of a bug here with class=leftX.  There's only a finite number
             // of classes I can define in the .CSS file, and the user can theoretically nest deeper.
             // The right solution is to use style=Xem, and calculate X.  Let's see if anyone complains
             // first :)  Also applies to the row header case above.
             // FIXED: I found it in one of my reports and changed it to the proposed method.
             // This works for me (ipwizard)
             ReportAccount rowname = (*it_innergroup).begin().key();
             isUsed |= !rowname.isClosed();
             finalRow = QString("<tr class=\"row-%1\"%2><td class=\"left\" style=\"text-indent: %3.0em;\">%5%6</td>")
                        .arg(rownum & 0x01 ? "even" : "odd")
                        .arg(m_config_f.detailLevel() == MyMoneyReport::eDetailAll ? "id=\"solo\"" : "")
                        .arg(rowname.hierarchyDepth() - 1)
                        .arg(rowname.name().replace(QRegExp(" "), "&nbsp;"))
                        .arg((m_config_f.isConvertCurrency() || !rowname.isForeignCurrency()) ? QString() : QString(" (%1)").arg(rowname.currency().id()));
           }
 
           // Finish the row started above, unless told not to
           if (finishrow) {
             int column = 1;
             isUsed |= (*it_innergroup).m_total[eActual][0].isUsed();
             while (column < m_numColumns) {
               QString lb;
               if (column != 1)
                 lb = leftborder;
 
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 finalRow += QString("<td%2>%1</td>")
                             .arg(coloredAmount((*it_innergroup).m_total[ m_rowTypeList[i] ][column]))
                             .arg(i == 0 ? lb : QString());
                 isUsed |= (*it_innergroup).m_total[ m_rowTypeList[i] ][column].isUsed();
               }
 
               column++;
             }
 
             if (m_config_f.isShowingRowTotals()) {
               for (int i = 0; i < m_rowTypeList.size(); ++i) {
                 finalRow += QString("<td%2>%1</td>")
                             .arg(coloredAmount((*it_innergroup).m_total[ m_rowTypeList[i] ].m_total))
                             .arg(i == 0 ? leftborder : QString());
               }
             }
 
             finalRow += "</tr>\n";
             if (isUsed) {
               result += finalRow;
               ++rownum;
             }
           }
 
           ++it_innergroup;
 
         } // end while iterating on the inner groups
 
       } // end if detail level is not "group"
 
       //
       // Outer Row Group Totals
       //
 
       if (m_config_f.isShowingColumnTotals()) {
         result += QString("<tr class=\"sectionfooter\"><td class=\"left\">%1&nbsp;%2</td>").arg(i18nc("Total balance", "Total")).arg((*it_outergroup).m_displayName);
         int column = 1;
         while (column < m_numColumns) {
           QString lb;
           if (column != 1)
             lb = leftborder;
 
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             result += QString("<td%2>%1</td>")
                       .arg(coloredAmount((*it_outergroup).m_total[ m_rowTypeList[i] ][column]))
                       .arg(i == 0 ? lb : QString());
           }
 
           column++;
         }
 
         if (m_config_f.isShowingRowTotals()) {
           for (int i = 0; i < m_rowTypeList.size(); ++i) {
             result += QString("<td%2>%1</td>")
                       .arg(coloredAmount((*it_outergroup).m_total[ m_rowTypeList[i] ].m_total))
                       .arg(i == 0 ? leftborder : QString());
           }
         }
         result += "</tr>\n";
       }
 
       ++it_outergroup;
 
     } // end while iterating on the outergroups
 
   } // end if detail level is not "total"
 
   //
   // Report Totals
   //
 
   if (m_config_f.isShowingColumnTotals()) {
     result += QString("<tr class=\"spacer\"><td>&nbsp;</td></tr>\n");
     result += QString("<tr class=\"reportfooter\"><td class=\"left\">%1</td>").arg(i18n("Grand Total"));
     int totalcolumn = 1;
     while (totalcolumn < m_numColumns) {
       QString lb;
       if (totalcolumn != 1)
         lb = leftborder;
 
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(coloredAmount(m_grid.m_total[ m_rowTypeList[i] ][totalcolumn]))
                   .arg(i == 0 ? lb : QString());
       }
 
       totalcolumn++;
     }
 
     if (m_config_f.isShowingRowTotals()) {
       for (int i = 0; i < m_rowTypeList.size(); ++i) {
         result += QString("<td%2>%1</td>")
                   .arg(coloredAmount(m_grid.m_total[ m_rowTypeList[i] ].m_total))
                   .arg(i == 0 ? leftborder : QString());
       }
     }
 
     result += "</tr>\n";
   }
 
   result += QString("<tr class=\"spacer\"><td>&nbsp;</td></tr>\n");
   result += QString("<tr class=\"spacer\"><td>&nbsp;</td></tr>\n");
   result += "</table>\n";
 
   return result;
 }
 
 void PivotTable::dump(const QString& file, const QString& /* context */) const
 {
   QFile g(file);
   g.open(QIODevice::WriteOnly);
   QTextStream(&g) << renderBody();
   g.close();
 }
 
 void PivotTable::drawChart(KReportChartView& chartView) const
 {
   chartView.drawPivotChart(m_grid, m_config_f, m_numColumns, m_columnHeadings, m_rowTypeList, m_columnTypeHeaderList);
 }
 
 QString PivotTable::coloredAmount(const MyMoneyMoney& amount, const QString& currencySymbol, int prec) const
 {
   QString result;
   if (amount.isNegative())
     result += QString("<font color=\"rgb(%1,%2,%3)\">")
               .arg(KMyMoneyGlobalSettings::listNegativeValueColor().red())
               .arg(KMyMoneyGlobalSettings::listNegativeValueColor().green())
               .arg(KMyMoneyGlobalSettings::listNegativeValueColor().blue());
   result += amount.formatMoney(currencySymbol, prec);
   if (amount.isNegative())
     result += QString("</font>");
   return result;
 }
 
 void PivotTable::calculateBudgetDiff()
 {
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
         switch (it_row.key().accountGroup()) {
           case MyMoneyAccount::Income:
           case MyMoneyAccount::Asset:
             while (column < m_numColumns) {
               it_row.value()[eBudgetDiff][column] = it_row.value()[eActual][column] - it_row.value()[eBudget][column];
               ++column;
             }
             break;
           case MyMoneyAccount::Expense:
           case MyMoneyAccount::Liability:
             while (column < m_numColumns) {
               it_row.value()[eBudgetDiff][column] = it_row.value()[eBudget][column] - it_row.value()[eActual][column];
               ++column;
             }
             break;
           default:
             break;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 
 }
 
 void PivotTable::calculateForecast()
 {
   //setup forecast
   MyMoneyForecast forecast = KMyMoneyGlobalSettings::forecast();
 
   //since this is a net worth forecast we want to include all account even those that are not in use
   forecast.setIncludeUnusedAccounts(true);
 
   //setup forecast dates
   if (m_endDate > QDate::currentDate()) {
     forecast.setForecastEndDate(m_endDate);
     forecast.setForecastStartDate(QDate::currentDate());
     forecast.setForecastDays(QDate::currentDate().daysTo(m_endDate));
   } else {
     forecast.setForecastStartDate(m_beginDate);
     forecast.setForecastEndDate(m_endDate);
     forecast.setForecastDays(m_beginDate.daysTo(m_endDate) + 1);
   }
 
   //adjust history dates if beginning date is before today
   if (m_beginDate < QDate::currentDate()) {
     forecast.setHistoryEndDate(m_beginDate.addDays(-1));
     forecast.setHistoryStartDate(forecast.historyEndDate().addDays(-forecast.accountsCycle()*forecast.forecastCycles()));
   }
 
   //run forecast
   if (m_config_f.rowType() == MyMoneyReport::eAssetLiability) { //asset and liability
     forecast.doForecast();
   } else { //income and expenses
     MyMoneyBudget budget;
     forecast.createBudget(budget, m_beginDate.addYears(-1), m_beginDate.addDays(-1), m_beginDate, m_endDate, false);
   }
 
   //go through the data and add forecast
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
         QDate forecastDate = m_beginDate;
         //check whether columns are days or months
         if (m_config_f.isColumnsAreDays()) {
           while (column < m_numColumns) {
             it_row.value()[eForecast][column] = forecast.forecastBalance(it_row.key(), forecastDate);
 
             forecastDate = forecastDate.addDays(1);
             ++column;
           }
         } else {
           //if columns are months
           while (column < m_numColumns) {
             // the forecast balance is on the first day of the month see MyMoneyForecast::calculateScheduledMonthlyBalances()
             forecastDate = QDate(forecastDate.year(), forecastDate.month(), 1);
             //check that forecastDate is not over ending date
             if (forecastDate > m_endDate)
               forecastDate = m_endDate;
 
             //get forecast balance and set the corresponding column
             it_row.value()[eForecast][column] = forecast.forecastBalance(it_row.key(), forecastDate);
 
             forecastDate = forecastDate.addMonths(1);
             ++column;
           }
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::loadRowTypeList()
 {
   if ((m_config_f.isIncludingBudgetActuals()) ||
       (!m_config_f.hasBudget()
        && !m_config_f.isIncludingForecast()
        && !m_config_f.isIncludingMovingAverage()
        && !m_config_f.isIncludingPrice()
        && !m_config_f.isIncludingAveragePrice())
      ) {
     m_rowTypeList.append(eActual);
     m_columnTypeHeaderList.append(i18n("Actual"));
   }
 
   if (m_config_f.hasBudget()) {
     m_rowTypeList.append(eBudget);
     m_columnTypeHeaderList.append(i18n("Budget"));
   }
 
   if (m_config_f.isIncludingBudgetActuals()) {
     m_rowTypeList.append(eBudgetDiff);
     m_columnTypeHeaderList.append(i18n("Difference"));
   }
 
   if (m_config_f.isIncludingForecast()) {
     m_rowTypeList.append(eForecast);
     m_columnTypeHeaderList.append(i18n("Forecast"));
   }
 
   if (m_config_f.isIncludingMovingAverage()) {
     m_rowTypeList.append(eAverage);
     m_columnTypeHeaderList.append(i18n("Moving Average"));
   }
 
   if (m_config_f.isIncludingAveragePrice()) {
     m_rowTypeList.append(eAverage);
     m_columnTypeHeaderList.append(i18n("Moving Average Price"));
   }
 
   if (m_config_f.isIncludingPrice()) {
     m_rowTypeList.append(ePrice);
     m_columnTypeHeaderList.append(i18n("Price"));
   }
 }
 
 
 void PivotTable::calculateMovingAverage()
 {
   int delta = m_config_f.movingAverageDays() / 2;
 
   //go through the data and add the moving average
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
 
         //check whether columns are days or months
-        if (m_config_f.columnType() == MyMoneyReport::eDays) {
+        if (m_config_f.columnType() == MyMoneyReport::Column::Days) {
           while (column < m_numColumns) {
             MyMoneyMoney totalPrice = MyMoneyMoney();
 
             QDate averageStart = columnDate(column).addDays(-delta);
             QDate averageEnd = columnDate(column).addDays(delta);
             for (QDate averageDate = averageStart; averageDate <= averageEnd; averageDate = averageDate.addDays(1)) {
               if (m_config_f.isConvertCurrency()) {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate) * it_row.key().baseCurrencyPrice(averageDate);
               } else {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate);
               }
               totalPrice = totalPrice.convert(10000);
             }
 
             //calculate the average price
             MyMoneyMoney averagePrice = totalPrice / MyMoneyMoney((averageStart.daysTo(averageEnd) + 1), 1);
 
             //get the actual value, multiply by the average price and save that value
             MyMoneyMoney averageValue = it_row.value()[eActual][column] * averagePrice;
             it_row.value()[eAverage][column] = averageValue.convert(10000);
 
             ++column;
           }
         } else {
           //if columns are months
           while (column < m_numColumns) {
             QDate averageStart = columnDate(column);
 
             //set the right start date depending on the column type
             switch (m_config_f.columnType()) {
-              case MyMoneyReport::eYears: {
+              case MyMoneyReport::Column::Years: {
                   averageStart = QDate(columnDate(column).year(), 1, 1);
                   break;
                 }
-              case MyMoneyReport::eBiMonths: {
+              case MyMoneyReport::Column::BiMonths: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1).addMonths(-1);
                   break;
                 }
-              case MyMoneyReport::eQuarters: {
+              case MyMoneyReport::Column::Quarters: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1).addMonths(-1);
                   break;
                 }
-              case MyMoneyReport::eMonths: {
+              case MyMoneyReport::Column::Months: {
                   averageStart = QDate(columnDate(column).year(), columnDate(column).month(), 1);
                   break;
                 }
-              case MyMoneyReport::eWeeks: {
+              case MyMoneyReport::Column::Weeks: {
                   averageStart = columnDate(column).addDays(-columnDate(column).dayOfWeek() + 1);
                   break;
                 }
               default:
                 break;
             }
 
             //gather the actual data and calculate the average
             MyMoneyMoney totalPrice = MyMoneyMoney();
             QDate averageEnd = columnDate(column);
             for (QDate averageDate = averageStart; averageDate <= averageEnd; averageDate = averageDate.addDays(1)) {
               if (m_config_f.isConvertCurrency()) {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate) * it_row.key().baseCurrencyPrice(averageDate);
               } else {
                 totalPrice += it_row.key().deepCurrencyPrice(averageDate);
               }
               totalPrice = totalPrice.convert(10000);
             }
 
             MyMoneyMoney averagePrice = totalPrice / MyMoneyMoney((averageStart.daysTo(averageEnd) + 1), 1);
             MyMoneyMoney averageValue = it_row.value()[eActual][column] * averagePrice;
 
             //fill in the average
             it_row.value()[eAverage][column] = averageValue.convert(10000);
 
             ++column;
           }
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 void PivotTable::fillBasePriceUnit(ERowType rowType)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QString baseCurrencyId = file->baseCurrency().id();
 
   //get the first price date for securities
   QMap<QString, QDate> securityDates = securityFirstPrice();
 
   //go through the data
   PivotGrid::iterator it_outergroup = m_grid.begin();
   while (it_outergroup != m_grid.end()) {
     PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
     while (it_innergroup != (*it_outergroup).end()) {
       PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
       while (it_row != (*it_innergroup).end()) {
         int column = 1;
 
         //if it is a base currency fill all the values
         bool firstPriceExists = false;
         if (it_row.key().currencyId() == baseCurrencyId) {
           firstPriceExists = true;
         }
 
         while (column < m_numColumns) {
           //check whether the date for that column is on or after the first price
           if (!firstPriceExists
               && securityDates.contains(it_row.key().currencyId())
               && columnDate(column) >= securityDates.value(it_row.key().currencyId())) {
             firstPriceExists = true;
           }
 
           //only add the dummy value if there is a price for that date
           if (firstPriceExists) {
             //insert a unit of currency for each account
             it_row.value()[rowType][column] = MyMoneyMoney::ONE;
           }
           ++column;
         }
         ++it_row;
       }
       ++it_innergroup;
     }
     ++it_outergroup;
   }
 }
 
 QMap<QString, QDate> PivotTable::securityFirstPrice()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyPriceList priceList = file->priceList();
   QMap<QString, QDate> securityPriceDate;
 
   MyMoneyPriceList::const_iterator prices_it;
   for (prices_it = priceList.constBegin(); prices_it != priceList.constEnd(); ++prices_it) {
     MyMoneyPrice firstPrice = (*((*prices_it).constBegin()));
 
     //check the security in the from field
     //if it is there, check if it is older
     if (securityPriceDate.contains(firstPrice.from())) {
       if (securityPriceDate.value(firstPrice.from()) > firstPrice.date()) {
         securityPriceDate[firstPrice.from()] = firstPrice.date();
       }
     } else {
       securityPriceDate.insert(firstPrice.from(), firstPrice.date());
     }
 
     //check the security in the to field
     //if it is there, check if it is older
     if (securityPriceDate.contains(firstPrice.to())) {
       if (securityPriceDate.value(firstPrice.to()) > firstPrice.date()) {
         securityPriceDate[firstPrice.to()] = firstPrice.date();
       }
     } else {
       securityPriceDate.insert(firstPrice.to(), firstPrice.date());
     }
   }
   return securityPriceDate;
 }
 
 void PivotTable::includeInvestmentSubAccounts()
 {
   // if we're not in expert mode, we need to make sure
   // that all stock accounts for the selected investment
   // account are also selected
   QStringList accountList;
   if (m_config_f.accounts(accountList)) {
     if (!KMyMoneyGlobalSettings::expertMode()) {
       QStringList::const_iterator it_a, it_b;
       for (it_a = accountList.constBegin(); it_a != accountList.constEnd(); ++it_a) {
         MyMoneyAccount acc = MyMoneyFile::instance()->account(*it_a);
         if (acc.accountType() == MyMoneyAccount::Investment) {
           for (it_b = acc.accountList().constBegin(); it_b != acc.accountList().constEnd(); ++it_b) {
             if (!accountList.contains(*it_b)) {
               m_config_f.addAccount(*it_b);
             }
           }
         }
       }
     }
   }
 }
 
 int PivotTable::currentDateColumn()
 {
 
   //return -1 if the columns do not include the current date
   if (m_beginDate > QDate::currentDate() || m_endDate < QDate::currentDate()) {
     return -1;
   }
 
   //check the date of each column and return if it is the one for the current date
   //if columns are not days, return the one for the current month or year
   int column = 1;
 
   while (column < m_numColumns) {
     if (columnDate(column) >= QDate::currentDate()) {
       break;
     }
     column++;
   }
 
   //if there is no column matching the current date, return -1
   if (column == m_numColumns) {
     column = -1;
   }
   return column;
 }
 
 } // namespace
diff --git a/kmymoney/reports/pivottabletest.cpp b/kmymoney/reports/pivottabletest.cpp
index 613ed0549..f3d206201 100644
--- a/kmymoney/reports/pivottabletest.cpp
+++ b/kmymoney/reports/pivottabletest.cpp
@@ -1,1030 +1,1030 @@
 /***************************************************************************
                           pivottabletest.cpp
                           -------------------
     copyright            : (C) 2002-2005 by Thomas Baumgart
     email                : ipwizard@users.sourceforge.net
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "pivottabletest.h"
 
 #include <QList>
 #include <QFile>
 
 #include <kdebug.h>
 #include <kdeversion.h>
 #include <kglobal.h>
 #include <kglobalsettings.h>
 #include <klocale.h>
 #include <kstandarddirs.h>
 #include <qtest_kde.h>
 
 // DOH, mmreport.h uses this without including it!!
 #include "mymoneyaccount.h"
 
 #include "mymoneysecurity.h"
 #include "mymoneyprice.h"
 #include "mymoneyreport.h"
 #include "mymoneystatement.h"
 #include "mymoneystoragedump.h"
 #include "mymoneystoragexml.h"
 
 #include "pivottable.h"
 #include "reportstestcommon.h"
 
 using namespace reports;
 using namespace test;
 
 QTEST_KDEMAIN_CORE_WITH_COMPONENTNAME(PivotTableTest, "kmymoney")
 
 void PivotTableTest::init()
 {
   storage = new MyMoneySeqAccessMgr;
   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), 100, 1));
   file->addCurrency(MyMoneySecurity("GBP", "British Pound",           "#"));
   file->setBaseCurrency(file->currency("USD"));
 
   MyMoneyPayee payeeTest("Test Payee");
   file->addPayee(payeeTest);
   MyMoneyPayee payeeTest2("Thomas Baumgart");
   file->addPayee(payeeTest2);
 
   acAsset = (MyMoneyFile::instance()->asset().id());
   acLiability = (MyMoneyFile::instance()->liability().id());
   acExpense = (MyMoneyFile::instance()->expense().id());
   acIncome = (MyMoneyFile::instance()->income().id());
   acChecking = makeAccount(QString("Checking Account"), MyMoneyAccount::Checkings, moCheckingOpen, QDate(2004, 5, 15), acAsset);
   acCredit = makeAccount(QString("Credit Card"), MyMoneyAccount::CreditCard, moCreditOpen, QDate(2004, 7, 15), acLiability);
   acSolo = makeAccount(QString("Solo"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acParent = makeAccount(QString("Parent"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
   acChild = makeAccount(QString("Child"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acForeign = makeAccount(QString("Foreign"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 1, 11), acExpense);
 
   acSecondChild = makeAccount(QString("Second Child"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acParent);
   acGrandChild1 = makeAccount(QString("Grand Child 1"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild);
   acGrandChild2 = makeAccount(QString("Grand Child 2"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acChild);
 
   MyMoneyInstitution i("Bank of the World", "", "", "", "", "", "");
   file->addInstitution(i);
   inBank = i.id();
   ft.commit();
 }
 
 void PivotTableTest::cleanup()
 {
   file->detachStorage(storage);
   delete storage;
 }
 
 void PivotTableTest::testNetWorthSingle()
 {
   try {
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eAssetLiability);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 7, 1).addDays(-1));
     XMLandback(filter);
     PivotTable networth_f(filter);
     writeTabletoCSV(networth_f);
 
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"][acChecking][eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"][acChecking][eActual][6] == moCheckingOpen);
     QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid.m_total[eActual][0] == moZero);
     QVERIFY(networth_f.m_grid.m_total[eActual][4] == moZero);
     QVERIFY(networth_f.m_grid.m_total[eActual][5] == moCheckingOpen);
     QVERIFY(networth_f.m_grid.m_total[eActual][6] == moCheckingOpen);
   } catch (const MyMoneyException &e) {
     QFAIL(qPrintable(e.what()));
   }
 }
 
 void PivotTableTest::testNetWorthOfsetting()
 {
   // Test the net worth report to make sure it picks up the opening balance for two
   // accounts opened during the period of the report, one asset & one liability.  Test
   // that it calculates the totals correctly.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"][acCredit][eActual][7] == -moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(networth_f.m_grid.m_total[eActual][12] == moCheckingOpen + moCreditOpen);
 
 }
 
 void PivotTableTest::testNetWorthOpeningPrior()
 {
   // Test the net worth report to make sure it's picking up opening balances PRIOR to
   // the period of the report.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2005, 8, 1), QDate(2005, 12, 31));
   filter.setName("Net Worth Opening Prior 1");
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoCSV(networth_f);
 
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"].m_total[eActual][0] == -moCreditOpen);
   QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][0] == moCheckingOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][0] == moCheckingOpen + moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][1] == moCheckingOpen + moCreditOpen);
 
   // Test the net worth report to make sure that transactions prior to the report
   // period are included in the opening balance
 
   TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acChecking, acChild);
 
   filter.setName("Net Worth Opening Prior 2");
   PivotTable networth_f2(filter);
   writeTabletoCSV(networth_f2);
 
   MyMoneyMoney m1 = (networth_f2.m_grid["Liability"]["Credit Card"].m_total[eActual][1]);
   MyMoneyMoney m2 = (-moCreditOpen + moParent);
 
   QVERIFY((networth_f2.m_grid["Liability"]["Credit Card"].m_total[eActual][1]) == (-moCreditOpen + moParent));
   QVERIFY(networth_f2.m_grid["Asset"]["Checking Account"].m_total[eActual][1] == moCheckingOpen - moChild);
   QVERIFY(networth_f2.m_grid.m_total[eActual][1] == moCheckingOpen + moCreditOpen - moChild - moParent);
 }
 
 void PivotTableTest::testNetWorthDateFilter()
 {
   // Test a net worth report whose period is prior to the time any accounts are open,
   // so the report should be zero.
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 2, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid.m_total[eActual][1] == moZero);
 
 }
 
 void PivotTableTest::testSpendingEmpty()
 {
   // test a spending report with no entries
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   XMLandback(filter);
   PivotTable spending_f1(filter);
   QVERIFY(spending_f1.m_grid.m_total[eActual].m_total == moZero);
 
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   PivotTable spending_f2(filter);
   QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == moZero);
 }
 
 void PivotTableTest::testSingleTransaction()
 {
   // Test a single transaction
   TransactionHelper t(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setName("Spending with Single Transaction.html");
   XMLandback(filter);
   PivotTable spending_f(filter);
   writeTabletoHTML(spending_f, "Spending with Single Transaction.html");
 
   QVERIFY(spending_f.m_grid["Expense"]["Solo"][acSolo][eActual][2] == moSolo);
   QVERIFY(spending_f.m_grid["Expense"]["Solo"].m_total[eActual][2] == moSolo);
   QVERIFY(spending_f.m_grid["Expense"]["Solo"].m_total[eActual][1] == moZero);
   QVERIFY(spending_f.m_grid.m_total[eActual][2] == (-moSolo));
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == (-moSolo));
 
   filter.clear();
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid["Asset"]["Checking Account"].m_total[eActual][2] == (moCheckingOpen - moSolo));
 }
 
 void PivotTableTest::testSubAccount()
 {
   // Test a sub-account with a value, under an account with a value
 
   TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setName("Spending with Sub-Account");
   XMLandback(filter);
   PivotTable spending_f(filter);
   writeTabletoHTML(spending_f, "Spending with Sub-Account.html");
 
   QVERIFY(spending_f.m_grid["Expense"]["Parent"][acParent][eActual][3] == moParent);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"][acChild][eActual][3] == moChild);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][3] == moParent + moChild);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][2] == moZero);
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual].m_total == moParent + moChild);
   QVERIFY(spending_f.m_grid.m_total[eActual][3] == (-moParent - moChild));
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == (-moParent - moChild));
 
   filter.clear();
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setName("Net Worth with Sub-Account");
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoHTML(networth_f, "Net Worth with Sub-Account.html");
   QVERIFY(networth_f.m_grid["Liability"]["Credit Card"].m_total[eActual][3] == moParent + moChild - moCreditOpen);
   QVERIFY(networth_f.m_grid.m_total[eActual][4] == -moParent - moChild + moCreditOpen + moCheckingOpen);
 
 }
 
 void PivotTableTest::testFilterIEvsIE()
 {
   // Test that removing an income/spending account will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acChild);
   filter.addCategory(acSolo);
   XMLandback(filter);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"]["Parent"].m_total[eActual][3] == moChild);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][2] == moSolo);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moChild);
 
 }
 
 void PivotTableTest::testFilterALvsAL()
 {
   // Test that removing an asset/liability account will remove the entry from an asset/liability report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acChecking);
   filter.addCategory(acChild);
   filter.addCategory(acSolo);
   XMLandback(filter);
   PivotTable networth_f(filter);
   QVERIFY(networth_f.m_grid.m_total[eActual][3] == -moSolo + moCheckingOpen);
 }
 
 void PivotTableTest::testFilterALvsIE()
 {
   // Test that removing an asset/liability account will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acChecking);
   QVERIFY(file->transactionList(filter).count() == 1);
 
   XMLandback(filter);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][3] == moZero);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][2] == moSolo);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 }
 
 void PivotTableTest::testFilterAllvsIE()
 {
   // Test that removing an asset/liability account AND an income/expense
   // category will remove the entry from an income/spending report
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addAccount(acCredit);
   filter.addCategory(acChild);
   PivotTable spending_f(filter);
 
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][2] == moZero);
   QVERIFY(spending_f.m_grid["Expense"].m_total[eActual][3] == moChild);
   QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moChild);
 }
 
 void PivotTableTest::testFilterBasics()
 {
   // Test that the filters are operating the way that the reports expect them to
   TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
   TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
   MyMoneyTransactionFilter filter;
   filter.clear();
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acSolo);
   filter.setReportAllSplits(false);
   filter.setConsiderCategory(true);
 
   QVERIFY(file->transactionList(filter).count() == 1);
 
   filter.addCategory(acParent);
 
   QVERIFY(file->transactionList(filter).count() == 3);
 
   filter.addAccount(acChecking);
 
   QVERIFY(file->transactionList(filter).count() == 1);
 
   filter.clear();
   filter.setDateFilter(QDate(2004, 9, 1), QDate(2005, 1, 1).addDays(-1));
   filter.addCategory(acParent);
   filter.addAccount(acCredit);
   filter.setReportAllSplits(false);
   filter.setConsiderCategory(true);
 
   QVERIFY(file->transactionList(filter).count() == 2);
 }
 
 void PivotTableTest::testMultipleCurrencies()
 {
   MyMoneyMoney moCanOpening(0.0, 100);
   MyMoneyMoney moJpyOpening(0.0, 100);
   MyMoneyMoney moCanPrice(0.75, 100);
   MyMoneyMoney moJpyPrice(0.010, 100);
   MyMoneyMoney moJpyPrice2(0.011, 100);
   MyMoneyMoney moJpyPrice3(0.014, 100);
   MyMoneyMoney moJpyPrice4(0.0395, 100);
   MyMoneyMoney moCanTransaction(100.0, 100);
   MyMoneyMoney moJpyTransaction(100.0, 100);
 
   QString acCanChecking = makeAccount(QString("Canadian Checking"), MyMoneyAccount::Checkings, moCanOpening, QDate(2003, 11, 15), acAsset, "CAD");
   QString acJpyChecking = makeAccount(QString("Japanese Checking"), MyMoneyAccount::Checkings, moJpyOpening, QDate(2003, 11, 15), acAsset, "JPY");
   QString acCanCash = makeAccount(QString("Canadian"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acForeign, "CAD");
   QString acJpyCash = makeAccount(QString("Japanese"), MyMoneyAccount::Expense, MyMoneyMoney(), QDate(2004, 2, 11), acForeign, "JPY");
 
   makePrice("CAD", QDate(2004, 1, 1), MyMoneyMoney(moCanPrice));
   makePrice("JPY", QDate(2004, 1, 1), MyMoneyMoney(moJpyPrice));
   makePrice("JPY", QDate(2004, 5, 1), MyMoneyMoney(moJpyPrice2));
   makePrice("JPY", QDate(2004, 6, 30), MyMoneyMoney(moJpyPrice3));
   makePrice("JPY", QDate(2004, 7, 15), MyMoneyMoney(moJpyPrice4));
 
   TransactionHelper t1(QDate(2004, 2, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t2(QDate(2004, 3, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t3(QDate(2004, 4, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moJpyTransaction), acJpyChecking, acJpyCash, "JPY");
   TransactionHelper t4(QDate(2004, 2, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
   TransactionHelper t5(QDate(2004, 3, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
   TransactionHelper t6(QDate(2004, 4, 20), MyMoneySplit::ActionWithdrawal, MyMoneyMoney(moCanTransaction), acCanChecking, acCanCash, "CAD");
 
 #if 0
   QFile g("multicurrencykmy.xml");
   g.open(QIODevice::WriteOnly);
   MyMoneyStorageXML xml;
   IMyMoneyStorageFormat& interface = xml;
   interface.writeFile(&g, dynamic_cast<IMyMoneySerialize*>(MyMoneyFile::instance()->storage()));
   g.close();
 #endif
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setConvertCurrency(true);
   filter.setName("Multiple Currency Spending Rerport (with currency conversion)");
   XMLandback(filter);
 
   PivotTable spending_f(filter);
 
   writeTabletoCSV(spending_f);
 
   // test single foreign currency
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acCanCash][eActual][2] == (moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acCanCash][eActual][3] == (moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acCanCash][eActual][4] == (moCanTransaction*moCanPrice));
 
   // test multiple foreign currencies under a common parent
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acJpyCash][eActual][2] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acJpyCash][eActual][3] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"][acJpyCash][eActual][4] == (moJpyTransaction*moJpyPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"].m_total[eActual][2] == (moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice));
   QVERIFY(spending_f.m_grid["Expense"]["Foreign"].m_total[eActual].m_total == (moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice + moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice + moJpyTransaction*moJpyPrice + moCanTransaction*moCanPrice));
 
   // Test the report type where we DO NOT convert the currency
   filter.setConvertCurrency(false);
   filter.setDetailLevel(MyMoneyReport::eDetailAll);
   filter.setName("Multiple Currency Spending Report (WITHOUT currency conversion)");
   XMLandback(filter);
   PivotTable spending_fnc(filter);
   writeTabletoCSV(spending_fnc);
 
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acCanCash][eActual][2] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acCanCash][eActual][3] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acCanCash][eActual][4] == (moCanTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acJpyCash][eActual][2] == (moJpyTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acJpyCash][eActual][3] == (moJpyTransaction));
   QVERIFY(spending_fnc.m_grid["Expense"]["Foreign"][acJpyCash][eActual][4] == (moJpyTransaction));
 
   filter.setConvertCurrency(true);
   filter.clear();
   filter.setName("Multiple currency net worth");
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
   writeTabletoCSV(networth_f);
 
   // test single foreign currency
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][acCanChecking][eActual][1] == (moCanOpening*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][acCanChecking][eActual][2] == ((moCanOpening - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][acCanChecking][eActual][3] == ((moCanOpening - moCanTransaction - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][acCanChecking][eActual][4] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Canadian Checking"][acCanChecking][eActual][12] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice));
 
   // test Stable currency price, fluctuating account balance
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][1] == (moJpyOpening*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][2] == ((moJpyOpening - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][3] == ((moJpyOpening - moJpyTransaction - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][4] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice));
 
   // test Fluctuating currency price, stable account balance
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][5] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice2));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][6] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice3));
   QVERIFY(networth_f.m_grid["Asset"]["Japanese Checking"][acJpyChecking][eActual][7] == ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice4));
 
   // test multiple currencies totalled up
   QVERIFY(networth_f.m_grid["Asset"].m_total[eActual][4] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice) + ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice));
   QVERIFY(networth_f.m_grid["Asset"].m_total[eActual][5] == ((moCanOpening - moCanTransaction - moCanTransaction - moCanTransaction)*moCanPrice) + ((moJpyOpening - moJpyTransaction - moJpyTransaction - moJpyTransaction)*moJpyPrice2) + moCheckingOpen);
 
 }
 
 void PivotTableTest::testAdvancedFilter()
 {
   // test more advanced filtering capabilities
 
   // amount
   {
     TransactionHelper t1(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setAmountFilter(moChild, moChild);
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moChild);
   }
 
   // payee (specific)
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moThomas, acCredit, acParent, QString(), "Thomas Baumgart");
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addPayee(MyMoneyFile::instance()->payeeByName("Thomas Baumgart").id());
     filter.setName("Spending with Payee Filter");
     XMLandback(filter);
     PivotTable spending_f(filter);
     writeTabletoHTML(spending_f, "Spending with Payee Filter.html");
 
     QVERIFY(spending_f.m_grid["Expense"]["Parent"][acParent][eActual][11] == moThomas);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moThomas);
   }
   // payee (no payee)
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moNoPayee, acCredit, acParent, QString(), QString());
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addPayee(QString());
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid["Expense"]["Parent"][acParent][eActual][11] == moNoPayee);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moNoPayee);
   }
 
   // text
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moThomas, acCredit, acParent, QString(), "Thomas Baumgart");
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setTextFilter(QRegExp("Thomas"));
     XMLandback(filter);
     PivotTable spending_f(filter);
   }
 
   // type (payment, deposit, transfer)
   {
     TransactionHelper t1(QDate(2004, 1, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 2, 1), MyMoneySplit::ActionDeposit, -moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 1), MyMoneySplit::ActionTransfer, moChild, acCredit, acChecking);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.addType(MyMoneyTransactionFilter::payments);
     XMLandback(filter);
     PivotTable spending_f(filter);
 
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 
     filter.clear();
     filter.addType(MyMoneyTransactionFilter::deposits);
     XMLandback(filter);
     PivotTable spending_f2(filter);
 
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == moParent1);
 
     filter.clear();
     filter.addType(MyMoneyTransactionFilter::transfers);
     XMLandback(filter);
     PivotTable spending_f3(filter);
 
     QVERIFY(spending_f3.m_grid.m_total[eActual].m_total == moZero);
 
     filter.setRowType(MyMoneyReport::eAssetLiability);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31));
     XMLandback(filter);
     PivotTable networth_f4(filter);
 
     QVERIFY(networth_f4.m_grid["Asset"].m_total[eActual][11] == moCheckingOpen + moChild);
     QVERIFY(networth_f4.m_grid["Liability"].m_total[eActual][11] == - moCreditOpen + moChild);
     QVERIFY(networth_f4.m_grid.m_total[eActual][10] == moCheckingOpen + moCreditOpen);
     QVERIFY(networth_f4.m_grid.m_total[eActual][11] == moCheckingOpen + moCreditOpen);
   }
 
   // state (reconciled, cleared, not)
   {
     TransactionHelper t1(QDate(2004, 1, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 2, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 3, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
     TransactionHelper t4(QDate(2004, 4, 1), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
     QList<MyMoneySplit> splits = t1.splits();
     splits[0].setReconcileFlag(MyMoneySplit::Cleared);
     splits[1].setReconcileFlag(MyMoneySplit::Cleared);
     t1.modifySplit(splits[0]);
     t1.modifySplit(splits[1]);
     t1.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setReconcileFlag(MyMoneySplit::Reconciled);
     splits[1].setReconcileFlag(MyMoneySplit::Reconciled);
     t2.modifySplit(splits[0]);
     t2.modifySplit(splits[1]);
     t2.update();
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.addState(MyMoneyTransactionFilter::cleared);
     XMLandback(filter);
     PivotTable spending_f(filter);
 
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo);
 
     filter.addState(MyMoneyTransactionFilter::reconciled);
     XMLandback(filter);
     PivotTable spending_f2(filter);
 
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == -moSolo - moParent1);
 
     filter.clear();
     filter.addState(MyMoneyTransactionFilter::notReconciled);
     XMLandback(filter);
     PivotTable spending_f3(filter);
 
     QVERIFY(spending_f3.m_grid.m_total[eActual].m_total == -moChild - moParent2);
   }
 
   // number
   {
     TransactionHelper t1(QDate(2004, 10, 31), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
     TransactionHelper t4(QDate(2004, 11, 7), MyMoneySplit::ActionWithdrawal, moChild, acCredit, acChild);
 
     QList<MyMoneySplit> splits = t1.splits();
     splits[0].setNumber("1");
     splits[1].setNumber("1");
     t1.modifySplit(splits[0]);
     t1.modifySplit(splits[1]);
     t1.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setNumber("2");
     splits[1].setNumber("2");
     t2.modifySplit(splits[0]);
     t2.modifySplit(splits[1]);
     t2.update();
 
     splits.clear();
     splits = t3.splits();
     splits[0].setNumber("3");
     splits[1].setNumber("3");
     t3.modifySplit(splits[0]);
     t3.modifySplit(splits[1]);
     t3.update();
 
     splits.clear();
     splits = t2.splits();
     splits[0].setNumber("4");
     splits[1].setNumber("4");
     t4.modifySplit(splits[0]);
     t4.modifySplit(splits[1]);
     t4.update();
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
     filter.setNumberFilter("1", "3");
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2);
   }
 
   // blank dates
   {
     TransactionHelper t1y1(QDate(2003, 10, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2y1(QDate(2003, 11, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3y1(QDate(2003, 12, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
     TransactionHelper t1y2(QDate(2004, 4, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2y2(QDate(2004, 5, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3y2(QDate(2004, 6, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
     TransactionHelper t1y3(QDate(2005, 1, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
     TransactionHelper t2y3(QDate(2005, 5, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
     TransactionHelper t3y3(QDate(2005, 9, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
     MyMoneyReport filter;
     filter.setRowType(MyMoneyReport::eExpenseIncome);
     filter.setDateFilter(QDate(), QDate(2004, 7, 1));
     XMLandback(filter);
     PivotTable spending_f(filter);
     QVERIFY(spending_f.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2);
 
     filter.clear();
     XMLandback(filter);
     PivotTable spending_f2(filter);
     QVERIFY(spending_f2.m_grid.m_total[eActual].m_total == -moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2 - moSolo - moParent1 - moParent2);
 
   }
 
 }
 
 void PivotTableTest::testColumnType()
 {
   // test column type values of other than 'month'
 
   TransactionHelper t1q1(QDate(2004, 1, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2q1(QDate(2004, 2, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3q1(QDate(2004, 3, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   TransactionHelper t1q2(QDate(2004, 4, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2q2(QDate(2004, 5, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3q2(QDate(2004, 6, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   TransactionHelper t1y2(QDate(2005, 1, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2y2(QDate(2005, 5, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3y2(QDate(2005, 9, 1), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eExpenseIncome);
   filter.setDateFilter(QDate(2003, 12, 31), QDate(2005, 12, 31));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
-  filter.setColumnType(MyMoneyReport::eBiMonths);
+  filter.setColumnType(MyMoneyReport::Column::BiMonths);
   XMLandback(filter);
   PivotTable spending_b(filter);
 
   QVERIFY(spending_b.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][2] == -moParent1 - moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][3] == -moParent2 - moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][4] == -moParent);
   QVERIFY(spending_b.m_grid.m_total[eActual][5] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][6] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][7] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][8] == -moSolo);
   QVERIFY(spending_b.m_grid.m_total[eActual][9] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][10] == -moParent1);
   QVERIFY(spending_b.m_grid.m_total[eActual][11] == moZero);
   QVERIFY(spending_b.m_grid.m_total[eActual][12] == -moParent2);
   QVERIFY(spending_b.m_grid.m_total[eActual][13] == moZero);
 
-  filter.setColumnType(MyMoneyReport::eQuarters);
+  filter.setColumnType(MyMoneyReport::Column::Quarters);
   XMLandback(filter);
   PivotTable spending_q(filter);
 
   QVERIFY(spending_q.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][2] == -moSolo - moParent);
   QVERIFY(spending_q.m_grid.m_total[eActual][3] == -moSolo - moParent);
   QVERIFY(spending_q.m_grid.m_total[eActual][4] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][5] == moZero);
   QVERIFY(spending_q.m_grid.m_total[eActual][6] == -moSolo);
   QVERIFY(spending_q.m_grid.m_total[eActual][7] == -moParent1);
   QVERIFY(spending_q.m_grid.m_total[eActual][8] == -moParent2);
   QVERIFY(spending_q.m_grid.m_total[eActual][9] == moZero);
 
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setName("Net Worth by Quarter");
   XMLandback(filter);
   PivotTable networth_q(filter);
   writeTabletoHTML(networth_q, "Net Worth by Quarter.html");
 
   QVERIFY(networth_q.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(networth_q.m_grid.m_total[eActual][2] == -moSolo - moParent);
   QVERIFY(networth_q.m_grid.m_total[eActual][3] == -moSolo - moParent - moSolo - moParent + moCheckingOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][4] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][5] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][6] == -moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][7] == -moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][8] == -moParent2 - moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_q.m_grid.m_total[eActual][9] == -moParent2 - moParent1 - moSolo - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
 
   filter.setRowType(MyMoneyReport::eExpenseIncome);
-  filter.setColumnType(MyMoneyReport::eYears);
+  filter.setColumnType(MyMoneyReport::Column::Years);
   XMLandback(filter);
   PivotTable spending_y(filter);
 
   QVERIFY(spending_y.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(spending_y.m_grid.m_total[eActual][2] == -moSolo - moParent - moSolo - moParent);
   QVERIFY(spending_y.m_grid.m_total[eActual][3] == -moSolo - moParent);
   QVERIFY(spending_y.m_grid.m_total[eActual].m_total == -moSolo - moParent - moSolo - moParent - moSolo - moParent);
 
   filter.setRowType(MyMoneyReport::eAssetLiability);
   XMLandback(filter);
   PivotTable networth_y(filter);
 
   QVERIFY(networth_y.m_grid.m_total[eActual][1] == moZero);
   QVERIFY(networth_y.m_grid.m_total[eActual][2] == -moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
   QVERIFY(networth_y.m_grid.m_total[eActual][3] == -moSolo - moParent - moSolo - moParent - moSolo - moParent + moCheckingOpen + moCreditOpen);
 
   // Test days-based reports
 
   TransactionHelper t1d1(QDate(2004, 7, 1), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2d1(QDate(2004, 7, 1), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3d1(QDate(2004, 7, 5), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   TransactionHelper t1d2(QDate(2004, 7, 14), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2d2(QDate(2004, 7, 15), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3d2(QDate(2004, 7, 20), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   TransactionHelper t1d3(QDate(2004, 8, 2), MyMoneySplit::ActionWithdrawal, moSolo, acChecking, acSolo);
   TransactionHelper t2d3(QDate(2004, 8, 3), MyMoneySplit::ActionWithdrawal, moParent1, acCredit, acParent);
   TransactionHelper t3d3(QDate(2004, 8, 4), MyMoneySplit::ActionWithdrawal, moParent2, acCredit, acParent);
 
   filter.setDateFilter(QDate(2004, 7, 2), QDate(2004, 7, 14));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
-  filter.setColumnType(MyMoneyReport::eMonths);
+  filter.setColumnType(MyMoneyReport::Column::Months);
   filter.setColumnsAreDays(true);
   filter.setName("Spending by Days");
 
   XMLandback(filter);
   PivotTable spending_days(filter);
   writeTabletoHTML(spending_days, "Spending by Days.html");
 
   QVERIFY(spending_days.m_grid.m_total[eActual][4] == -moParent2);
   QVERIFY(spending_days.m_grid.m_total[eActual][13] == -moSolo);
   QVERIFY(spending_days.m_grid.m_total[eActual].m_total == -moSolo - moParent2);
 
   unsigned save_dayweekstart = KGlobal::locale()->weekStartDay();
   KGlobal::locale()->setWeekStartDay(2);
 
   filter.setDateFilter(QDate(2004, 7, 2), QDate(2004, 8, 1));
   filter.setRowType(MyMoneyReport::eExpenseIncome);
-  filter.setColumnType(static_cast<MyMoneyReport::EColumnType>(7));
+  filter.setColumnType(static_cast<MyMoneyReport::Column::Type>(7));
   filter.setColumnsAreDays(true);
   filter.setName("Spending by Weeks");
 
   XMLandback(filter);
   PivotTable spending_weeks(filter);
   writeTabletoHTML(spending_weeks, "Spending by Weeks.html");
 
   KGlobal::locale()->setWeekStartDay(save_dayweekstart);
 
   QVERIFY(spending_weeks.m_grid.m_total[eActual][0] == moZero);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][1] == -moParent2);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][2] == moZero);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][3] == -moSolo - moParent1);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][4] == -moParent2);
   QVERIFY(spending_weeks.m_grid.m_total[eActual][5] == moZero);
   QVERIFY(spending_weeks.m_grid.m_total[eActual].m_total == -moSolo - moParent - moParent2);
 
 
 }
 
 void PivotTableTest::testInvestment()
 {
   try {
     // Equities
     eqStock1 = makeEquity("Stock1", "STK1");
     eqStock2 = makeEquity("Stock2", "STK2");
 
     // Accounts
     acInvestment = makeAccount("Investment", MyMoneyAccount::Investment, moZero, QDate(2004, 1, 1), acAsset);
     acStock1 = makeAccount("Stock 1", MyMoneyAccount::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock1);
     acStock2 = makeAccount("Stock 2", MyMoneyAccount::Stock, moZero, QDate(2004, 1, 1), acInvestment, eqStock2);
     acDividends = makeAccount("Dividends", MyMoneyAccount::Income, moZero, QDate(2004, 1, 1), acIncome);
 
     // Transactions
     //                         Date             Action                                              Shares                 Price   Stock     Asset       Income
     InvTransactionHelper s1b1(QDate(2004, 2, 1), MyMoneySplit::ActionBuyShares,        MyMoneyMoney(1000.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1b2(QDate(2004, 3, 1), MyMoneySplit::ActionBuyShares,        MyMoneyMoney(1000.00), MyMoneyMoney(110.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s1(QDate(2004, 4, 1), MyMoneySplit::ActionBuyShares,        MyMoneyMoney(-200.00), MyMoneyMoney(120.00), acStock1, acChecking, QString());
     InvTransactionHelper s1s2(QDate(2004, 5, 1), MyMoneySplit::ActionBuyShares,        MyMoneyMoney(-200.00), MyMoneyMoney(100.00), acStock1, acChecking, QString());
     InvTransactionHelper s1r1(QDate(2004, 6, 1), MyMoneySplit::ActionReinvestDividend, MyMoneyMoney(50.00), MyMoneyMoney(100.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1r2(QDate(2004, 7, 1), MyMoneySplit::ActionReinvestDividend, MyMoneyMoney(50.00), MyMoneyMoney(80.00), acStock1, QString(), acDividends);
     InvTransactionHelper s1c1(QDate(2004, 8, 1), MyMoneySplit::ActionDividend,         MyMoneyMoney(10.00), MyMoneyMoney(100.00), acStock1, acChecking, acDividends);
     InvTransactionHelper s1c2(QDate(2004, 9, 1), MyMoneySplit::ActionDividend,         MyMoneyMoney(10.00), MyMoneyMoney(120.00), acStock1, acChecking, acDividends);
 
     makeEquityPrice(eqStock1, QDate(2004, 10, 1), MyMoneyMoney(100.00));
 
     //
     // Net Worth Report (with investments)
     //
 
     MyMoneyReport networth_r;
     networth_r.setRowType(MyMoneyReport::eAssetLiability);
     networth_r.setDateFilter(QDate(2004, 1, 1), QDate(2004, 12, 31).addDays(-1));
     XMLandback(networth_r);
     PivotTable networth(networth_r);
 
     networth.dump("networth_i.html");
 
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][1] == moZero);
     // 1000 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][2] == MyMoneyMoney(100000.0));
     // 2000 shares @ $110.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][3] == MyMoneyMoney(220000.0));
     // 1800 shares @ $120.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][4] == MyMoneyMoney(216000.0));
     // 1600 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][5] == MyMoneyMoney(160000.0));
     // 1650 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][6] == MyMoneyMoney(165000.0));
     // 1700 shares @ $ 80.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][7] == MyMoneyMoney(136000.0));
     // 1700 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][8] == MyMoneyMoney(170000.0));
     // 1700 shares @ $120.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][9] == MyMoneyMoney(204000.0));
     // 1700 shares @ $100.00
     QVERIFY(networth.m_grid["Asset"]["Investment"].m_total[eActual][10] == MyMoneyMoney(170000.0));
 
 #if 0
     // Dump file & reports
     QFile g("investmentkmy.xml");
     g.open(QIODevice::WriteOnly);
     MyMoneyStorageXML xml;
     IMyMoneyStorageFormat& interface = xml;
     interface.writeFile(&g, dynamic_cast<IMyMoneySerialize*>(MyMoneyFile::instance()->storage()));
     g.close();
 
     invtran.dump("invtran.html", "<html><head></head><body>%1</body></html>");
     invhold.dump("invhold.html", "<html><head></head><body>%1</body></html>");
 #endif
 
   } catch (const MyMoneyException &e) {
     QFAIL(qPrintable(e.what()));
   }
 }
 
 void PivotTableTest::testBudget()
 {
 
   // 1. Budget on A, transactions on A
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSolo, false, MyMoneyMoney(100.0));
 
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
-                         MyMoneyReport::eMonths,
+                         MyMoneyReport::Column::Months,
                          MyMoneyTransactionFilter::yearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   // 2. Budget on B, not applying to sub accounts, transactions on B and B:1
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, false, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
-                         MyMoneyReport::eMonths,
+                         MyMoneyReport::Column::Months,
                          MyMoneyTransactionFilter::yearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Both B and B:1 totals should show up
   //  - B actuals compare against B budget
   //  - B:1 actuals compare against 0
 
   // 3. Budget on C, applying to sub accounts, transactions on C and C:1 and C:1:a
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, true, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
-                         MyMoneyReport::eMonths,
+                         MyMoneyReport::Column::Months,
                          MyMoneyTransactionFilter::yearToDate,
                          MyMoneyReport::eDetailTop ,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Only C totals show up, not C:1 or C:1:a totals
   //  - C + C:1 totals compare against C budget
 
   // 4. Budget on D, not applying to sub accounts, budget on D:1 not applying, budget on D:2 applying.  Transactions on D, D:1, D:2, D:2:a, D:2:b
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acParent, false, MyMoneyMoney(100.0));
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acChild, false, MyMoneyMoney(100.0));
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSecondChild, true, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
-                         MyMoneyReport::eMonths,
+                         MyMoneyReport::Column::Months,
                          MyMoneyTransactionFilter::yearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 
   //  - Totals for D, D:1, D:2 show up.  D:2:a and D:2:b do not
   //  - D actuals (only) compare against D budget
   //  - Ditto for D:1
   //  - D:2 acutals and children compare against D:2 budget
 
   // 5. Budget on E, no transactions on E
   {
     BudgetHelper budget;
     budget += BudgetEntryHelper(QDate(2006, 1, 1), acSolo, false, MyMoneyMoney(100.0));
     MyMoneyReport report(MyMoneyReport::eBudgetActual,
-                         MyMoneyReport::eMonths,
+                         MyMoneyReport::Column::Months,
                          MyMoneyTransactionFilter::yearToDate,
                          MyMoneyReport::eDetailTop,
                          "Yearly Budgeted vs. Actual", "Default Report");
     PivotTable table(report);
   }
 }
 
 void PivotTableTest::testHtmlEncoding()
 {
   MyMoneyReport filter;
   filter.setRowType(MyMoneyReport::eAssetLiability);
   filter.setDateFilter(QDate(2004, 1, 1), QDate(2005, 1, 1).addDays(-1));
   XMLandback(filter);
   PivotTable networth_f(filter);
 
   QByteArray encoding = KGlobal::locale()->encoding();
 
   QString html = networth_f.renderHTML(0, encoding, filter.name(), false);
 
   QRegExp rx("*<meta * charset=" + encoding + "*>*");
   rx.setPatternSyntax(QRegExp::Wildcard);
   rx.setCaseSensitivity(Qt::CaseInsensitive);
   QVERIFY(rx.exactMatch(html));
 }
diff --git a/kmymoney/views/kforecastview.cpp b/kmymoney/views/kforecastview.cpp
index 8e620a3dc..9e40eeb8a 100644
--- a/kmymoney/views/kforecastview.cpp
+++ b/kmymoney/views/kforecastview.cpp
@@ -1,1037 +1,1037 @@
 /***************************************************************************
                           kforecastview.cpp
                              -------------------
     copyright            : (C) 2007 by Alvaro Soliverez
     email                : asoliverez@gmail.com
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kforecastview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QTabWidget>
 #include <QLabel>
 #include <QLayout>
 #include <QList>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <KDebug>
 #include <KLocale>
 #include <KTextEdit>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <mymoneyfile.h>
 #include "kmymoneyglobalsettings.h"
 #include "kmymoney.h"
 #include "kmymoneyutils.h"
 #include "mymoneyforecast.h"
 #include "pivottable.h"
 #include "pivotgrid.h"
 #include "fixedcolumntreeview.h"
 
 KForecastView::KForecastView(QWidget *parent) :
     QWidget(parent),
     m_totalItem(0),
     m_assetItem(0),
     m_liabilityItem(0),
     m_incomeItem(0),
     m_expenseItem(0),
     m_chartLayout(0),
     m_forecastChart(0)
 {
   setupUi(this);
 
   m_forecastChart = new KReportChartView(m_tabChart);
 
   for (int i = 0; i < MaxViewTabs; ++i)
     m_needReload[i] = false;
 
   KSharedConfigPtr config = KGlobal::config();
   KConfigGroup grp = config->group("Last Use Settings");
   m_tab->setCurrentIndex(grp.readEntry("KForecastView_LastType", 0));
 
   m_forecastButton->setIcon(KIcon("view-financial-forecast"));
 
   connect(m_tab, SIGNAL(currentChanged(int)), this, SLOT(slotTabChanged(int)));
 
   connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadForecast()));
 
   connect(m_forecastButton, SIGNAL(clicked()), this, SLOT(slotManualForecast()));
 
   m_forecastList->setUniformRowHeights(true);
   m_forecastList->setAllColumnsShowFocus(true);
   m_summaryList->setAllColumnsShowFocus(true);
   m_budgetList->setAllColumnsShowFocus(true);
   m_advancedList->setAlternatingRowColors(true);
 
   connect(m_forecastList, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(itemExpanded(QTreeWidgetItem*)));
   connect(m_forecastList, SIGNAL(itemCollapsed(QTreeWidgetItem*)), this, SLOT(itemCollapsed(QTreeWidgetItem*)));
   connect(m_summaryList, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(itemExpanded(QTreeWidgetItem*)));
   connect(m_summaryList, SIGNAL(itemCollapsed(QTreeWidgetItem*)), this, SLOT(itemCollapsed(QTreeWidgetItem*)));
   connect(m_budgetList, SIGNAL(itemExpanded(QTreeWidgetItem*)), this, SLOT(itemExpanded(QTreeWidgetItem*)));
   connect(m_budgetList, SIGNAL(itemCollapsed(QTreeWidgetItem*)), this, SLOT(itemCollapsed(QTreeWidgetItem*)));
 
   m_forecastChart->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   m_chartLayout = m_tabChart->layout();
   m_chartLayout->setSpacing(6);
   m_chartLayout->addWidget(m_forecastChart);
 
   loadForecastSettings();
 }
 
 KForecastView::~KForecastView()
 {
 }
 
 void KForecastView::slotTabChanged(int index)
 {
   ForecastViewTab tab = static_cast<ForecastViewTab>(index);
 
   // remember this setting for startup
   KSharedConfigPtr config = KGlobal::config();
   KConfigGroup grp = config->group("Last Use Settings");
   grp.writeEntry("KForecastView_LastType", QVariant(tab).toString());
 
   loadForecast(tab);
 
 }
 
 void KForecastView::loadForecast(ForecastViewTab tab)
 {
   if (m_needReload[tab]) {
     switch (tab) {
       case ListView:
         loadListView();
         break;
       case SummaryView:
         loadSummaryView();
         break;
       case AdvancedView:
         loadAdvancedView();
         break;
       case BudgetView:
         loadBudgetView();
         break;
       case ChartView:
         loadChartView();
         break;
       default:
         break;
     }
     m_needReload[tab] = false;
   }
 }
 
 void KForecastView::showEvent(QShowEvent* event)
 {
   emit aboutToShow();
 
   slotTabChanged(m_tab->currentIndex());
 
   // don't forget base class implementation
   QWidget::showEvent(event);
 }
 
 void KForecastView::slotLoadForecast()
 {
   m_needReload[SummaryView] = true;
   m_needReload[ListView] = true;
   m_needReload[AdvancedView] = true;
   m_needReload[BudgetView] = true;
   m_needReload[ChartView] = true;
 
   //refresh settings
   loadForecastSettings();
 
   if (isVisible())
     slotTabChanged(m_tab->currentIndex());
 }
 
 void KForecastView::slotManualForecast()
 {
   m_needReload[SummaryView] = true;
   m_needReload[ListView] = true;
   m_needReload[AdvancedView] = true;
   m_needReload[BudgetView] = true;
   m_needReload[ChartView] = true;
 
   if (isVisible())
     slotTabChanged(m_tab->currentIndex());
 }
 
 void KForecastView::loadForecastSettings()
 {
   //fill the settings controls
   m_forecastDays->setValue(KMyMoneyGlobalSettings::forecastDays());
   m_accountsCycle->setValue(KMyMoneyGlobalSettings::forecastAccountCycle());
   m_beginDay->setValue(KMyMoneyGlobalSettings::beginForecastDay());
   m_forecastCycles->setValue(KMyMoneyGlobalSettings::forecastCycles());
   m_historyMethod->setId(radioButton11, 0); // simple moving avg
   m_historyMethod->setId(radioButton12, 1); // weighted moving avg
   m_historyMethod->setId(radioButton13, 2); // linear regression
   m_historyMethod->button(KMyMoneyGlobalSettings::historyMethod())->setChecked(true);
   switch (KMyMoneyGlobalSettings::forecastMethod()) {
     case 0:
       m_forecastMethod->setText(i18nc("Scheduled method", "Scheduled"));
       m_forecastCycles->setDisabled(true);
       m_historyMethodGroupBox->setDisabled(true);
       break;
     case 1:
       m_forecastMethod->setText(i18nc("History-based method", "History"));
       m_forecastCycles->setEnabled(true);
       m_historyMethodGroupBox->setEnabled(true);
       break;
     default:
       m_forecastMethod->setText(i18nc("Unknown forecast method", "Unknown"));
       break;
   }
 }
 
 void KForecastView::loadListView()
 {
   MyMoneyForecast forecast = KMyMoneyGlobalSettings::forecast();
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //get the settings from current page
   forecast.setForecastDays(m_forecastDays->value());
   forecast.setAccountsCycle(m_accountsCycle->value());
   forecast.setBeginForecastDay(m_beginDay->value());
   forecast.setForecastCycles(m_forecastCycles->value());
   forecast.setHistoryMethod(m_historyMethod->checkedId());
   forecast.doForecast();
 
   m_forecastList->clear();
   m_forecastList->setColumnCount(0);
   m_forecastList->setIconSize(QSize(22, 22));
   m_forecastList->setSortingEnabled(true);
   m_forecastList->sortByColumn(0, Qt::AscendingOrder);
 
   //add columns
   QStringList headerLabels;
   headerLabels << i18n("Account");
 
   //add cycle interval columns
   headerLabels << i18nc("Today's forecast", "Current");
 
   for (int i = 1; i <= forecast.forecastDays(); ++i) {
     QDate forecastDate = QDate::currentDate().addDays(i);
     headerLabels << KGlobal::locale()->formatDate(forecastDate, KLocale::LongDate);
   }
 
   //add variation columns
   headerLabels << i18n("Total variation");
 
   //set the columns
   m_forecastList->setHeaderLabels(headerLabels);
 
   //add default rows
   addTotalRow(m_forecastList, forecast);
   addAssetLiabilityRows(forecast);
 
   //load asset and liability forecast accounts
   loadAccounts(forecast, file->asset(), m_assetItem, eDetailed);
   loadAccounts(forecast, file->liability(), m_liabilityItem, eDetailed);
 
   adjustHeadersAndResizeToContents(m_forecastList);
 
   // add the fixed column only if the horizontal scroll bar is visible
   m_fixedColumnView.reset(m_forecastList->horizontalScrollBar()->isVisible() ? new FixedColumnTreeView(m_forecastList) : 0);
 }
 
 void KForecastView::loadSummaryView()
 {
   MyMoneyForecast forecast = KMyMoneyGlobalSettings::forecast();
   QList<MyMoneyAccount> accList;
   int dropMinimum;
   int dropZero;
 
   MyMoneyFile* file = MyMoneyFile::instance();
 
   //get the settings from current page
   forecast.setForecastDays(m_forecastDays->value());
   forecast.setAccountsCycle(m_accountsCycle->value());
   forecast.setBeginForecastDay(m_beginDay->value());
   forecast.setForecastCycles(m_forecastCycles->value());
   forecast.setHistoryMethod(m_historyMethod->checkedId());
   forecast.doForecast();
 
   //add columns
   QStringList headerLabels;
   headerLabels << i18n("Account");
   headerLabels << i18nc("Today's forecast", "Current");
 
   //if beginning of forecast is today, set the begin day to next cycle to avoid repeating the first cycle
   int daysToBeginDay;
   if (QDate::currentDate() < forecast.beginForecastDate()) {
     daysToBeginDay = QDate::currentDate().daysTo(forecast.beginForecastDate());
   } else {
     daysToBeginDay = forecast.accountsCycle();
   }
   for (int i = 0; ((i*forecast.accountsCycle()) + daysToBeginDay) <= forecast.forecastDays(); ++i) {
     int intervalDays = ((i * forecast.accountsCycle()) + daysToBeginDay);
     headerLabels << i18np("1 day", "%1 days", intervalDays);
   }
 
   //add variation columns
   headerLabels << i18n("Total variation");
 
   m_summaryList->clear();
   //set the columns
   m_summaryList->setHeaderLabels(headerLabels);
 
   m_summaryList->setIconSize(QSize(22, 22));
   m_summaryList->setSortingEnabled(true);
   m_summaryList->sortByColumn(0, Qt::AscendingOrder);
 
   //add default rows
   addTotalRow(m_summaryList, forecast);
   addAssetLiabilityRows(forecast);
 
   loadAccounts(forecast, file->asset(), m_assetItem, eSummary);
   loadAccounts(forecast, file->liability(), m_liabilityItem, eSummary);
 
   adjustHeadersAndResizeToContents(m_summaryList);
 
   //Add comments to the advice list
   m_adviceText->clear();
 
   //Get all accounts of the right type to calculate forecast
   m_nameIdx.clear();
   accList = forecast.accountList();
   QList<MyMoneyAccount>::const_iterator accList_t = accList.constBegin();
   for (; accList_t != accList.constEnd(); ++accList_t) {
     MyMoneyAccount acc = *accList_t;
     if (m_nameIdx[acc.id()] != acc.id()) { //Check if the account is there
       m_nameIdx[acc.id()] = acc.id();
     }
   }
 
   QMap<QString, QString>::ConstIterator it_nc;
   for (it_nc = m_nameIdx.constBegin(); it_nc != m_nameIdx.constEnd(); ++it_nc) {
 
     const MyMoneyAccount& acc = file->account(*it_nc);
     MyMoneySecurity currency;
 
     //change currency to deep currency if account is an investment
     if (acc.isInvest()) {
       MyMoneySecurity underSecurity = file->security(acc.currencyId());
       currency = file->security(underSecurity.tradingCurrency());
     } else {
       currency = file->security(acc.currencyId());
     }
 
     //Check if the account is going to be below zero or below the minimal balance in the forecast period
     QString minimumBalance = acc.value("minimumBalance");
     MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
 
     //Check if the account is going to be below minimal balance
     dropMinimum = forecast.daysToMinimumBalance(acc);
 
     //Check if the account is going to be below zero in the future
     dropZero = forecast.daysToZeroBalance(acc);
 
     // spit out possible warnings
     QString msg;
 
     // if a minimum balance has been specified, an appropriate warning will
     // only be shown, if the drop below 0 is on a different day or not present
 
     if (dropMinimum != -1
         && !minBalance.isZero()
         && (dropMinimum < dropZero
             || dropZero == -1)) {
       switch (dropMinimum) {
         case -1:
           break;
         case 0:
           msg = QString("<font color=\"%1\">").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name());
           msg += i18n("The balance of %1 is below the minimum balance %2 today.", acc.name(), MyMoneyUtils::formatMoney(minBalance, acc, currency));
           msg += QString("</font>");
           break;
         default:
           msg = QString("<font color=\"%1\">").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name());
           msg += i18np("The balance of %2 will drop below the minimum balance %3 in %1 day.",
                        "The balance of %2 will drop below the minimum balance %3 in %1 days.",
                        dropMinimum - 1, acc.name(), MyMoneyUtils::formatMoney(minBalance, acc, currency));
           msg += QString("</font>");
       }
 
       if (!msg.isEmpty()) {
         m_adviceText->append(msg);
       }
     }
 
     // a drop below zero is always shown
     msg.clear();
     switch (dropZero) {
       case -1:
         break;
       case 0:
         if (acc.accountGroup() == MyMoneyAccount::Asset) {
           msg = QString("<font color=\"%1\">").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name());
           msg += i18n("The balance of %1 is below %2 today.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), acc, currency));
           msg += QString("</font>");
           break;
         }
         if (acc.accountGroup() == MyMoneyAccount::Liability) {
           msg = i18n("The balance of %1 is above %2 today.", acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), acc, currency));
           break;
         }
         break;
       default:
         if (acc.accountGroup() == MyMoneyAccount::Asset) {
           msg = QString("<font color=\"%1\">").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name());
           msg += i18np("The balance of %2 will drop below %3 in %1 day.",
                        "The balance of %2 will drop below %3 in %1 days.",
                        dropZero, acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), acc, currency));
           msg += QString("</font>");
           break;
         }
         if (acc.accountGroup() == MyMoneyAccount::Liability) {
           msg = i18np("The balance of %2 will raise above %3 in %1 day.",
                       "The balance of %2 will raise above %3 in %1 days.",
                       dropZero, acc.name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), acc, currency));
           break;
         }
     }
     if (!msg.isEmpty()) {
       m_adviceText->append(msg);
     }
 
     //advice about trends
     msg.clear();
     MyMoneyMoney accCycleVariation = forecast.accountCycleVariation(acc);
     if (accCycleVariation < MyMoneyMoney()) {
       msg = QString("<font color=\"%1\">").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name());
       msg += i18n("The account %1 is decreasing %2 per cycle.", acc.name(), MyMoneyUtils::formatMoney(accCycleVariation, acc, currency));
       msg += QString("</font>");
     }
 
     if (!msg.isEmpty()) {
       m_adviceText->append(msg);
     }
   }
   m_adviceText->show();
 }
 
 void KForecastView::loadAdvancedView()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<MyMoneyAccount> accList;
   MyMoneySecurity baseCurrency = file->baseCurrency();
   MyMoneyForecast forecast = KMyMoneyGlobalSettings::forecast();
   int daysToBeginDay;
 
   //get the settings from current page
   forecast.setForecastDays(m_forecastDays->value());
   forecast.setAccountsCycle(m_accountsCycle->value());
   forecast.setBeginForecastDay(m_beginDay->value());
   forecast.setForecastCycles(m_forecastCycles->value());
   forecast.setHistoryMethod(m_historyMethod->checkedId());
   forecast.doForecast();
 
   //Get all accounts of the right type to calculate forecast
   m_nameIdx.clear();
   accList = forecast.accountList();
   QList<MyMoneyAccount>::const_iterator accList_t = accList.constBegin();
   for (; accList_t != accList.constEnd(); ++accList_t) {
     MyMoneyAccount acc = *accList_t;
     if (m_nameIdx[acc.id()] != acc.id()) { //Check if the account is there
       m_nameIdx[acc.id()] = acc.id();
     }
   }
   //clear the list, including columns
   m_advancedList->clear();
   m_advancedList->setColumnCount(0);
   m_advancedList->setIconSize(QSize(22, 22));
 
   QStringList headerLabels;
 
   //add first column of both lists
   headerLabels << i18n("Account");
 
   //if beginning of forecast is today, set the begin day to next cycle to avoid repeating the first cycle
   if (QDate::currentDate() < forecast.beginForecastDate()) {
     daysToBeginDay = QDate::currentDate().daysTo(forecast.beginForecastDate());
   } else {
     daysToBeginDay = forecast.accountsCycle();
   }
 
   //add columns
   for (int i = 1; ((i * forecast.accountsCycle()) + daysToBeginDay) <= forecast.forecastDays(); ++i) {
     headerLabels << i18n("Min Bal %1", i);
     headerLabels << i18n("Min Date %1", i);
   }
   for (int i = 1; ((i * forecast.accountsCycle()) + daysToBeginDay) <= forecast.forecastDays(); ++i) {
     headerLabels << i18n("Max Bal %1", i);
     headerLabels << i18n("Max Date %1", i);
   }
   headerLabels << i18nc("Average balance", "Average");
 
   m_advancedList->setHeaderLabels(headerLabels);
 
   QTreeWidgetItem *advancedItem = 0;
 
   QMap<QString, QString>::ConstIterator it_nc;
   for (it_nc = m_nameIdx.constBegin(); it_nc != m_nameIdx.constEnd(); ++it_nc) {
     const MyMoneyAccount& acc = file->account(*it_nc);
     QString amount;
     MyMoneyMoney amountMM;
     MyMoneySecurity currency;
 
     //change currency to deep currency if account is an investment
     if (acc.isInvest()) {
       MyMoneySecurity underSecurity = file->security(acc.currencyId());
       currency = file->security(underSecurity.tradingCurrency());
     } else {
       currency = file->security(acc.currencyId());
     }
 
 
     advancedItem = new QTreeWidgetItem(m_advancedList, advancedItem, false);
     advancedItem->setText(0, acc.name());
     advancedItem->setIcon(0, acc.accountPixmap());
     int it_c = 1; // iterator for the columns of the listview
 
     //get minimum balance list
     QList<QDate> minBalanceList = forecast.accountMinimumBalanceDateList(acc);
     QList<QDate>::Iterator t_min;
     for (t_min = minBalanceList.begin(); t_min != minBalanceList.end() ; ++t_min) {
       QDate minDate = *t_min;
       amountMM = forecast.forecastBalance(acc, minDate);
 
       amount = MyMoneyUtils::formatMoney(amountMM, acc, currency);
       advancedItem->setText(it_c, amount);
       advancedItem->setTextAlignment(it_c, Qt::AlignRight | Qt::AlignVCenter);
       if (amountMM.isNegative()) {
         advancedItem->setForeground(it_c, KMyMoneyGlobalSettings::listNegativeValueColor());
       }
       it_c++;
 
       QString dateString = KGlobal::locale()->formatDate(minDate, KLocale::ShortDate);
       advancedItem->setText(it_c, dateString);
       advancedItem->setTextAlignment(it_c, Qt::AlignRight | Qt::AlignVCenter);
       if (amountMM.isNegative()) {
         advancedItem->setForeground(it_c, KMyMoneyGlobalSettings::listNegativeValueColor());
       }
       it_c++;
     }
 
     //get maximum balance list
     QList<QDate> maxBalanceList = forecast.accountMaximumBalanceDateList(acc);
     QList<QDate>::Iterator t_max;
     for (t_max = maxBalanceList.begin(); t_max != maxBalanceList.end() ; ++t_max) {
       QDate maxDate = *t_max;
       amountMM = forecast.forecastBalance(acc, maxDate);
 
       amount = MyMoneyUtils::formatMoney(amountMM, acc, currency);
       advancedItem->setText(it_c, amount);
       advancedItem->setTextAlignment(it_c, Qt::AlignRight | Qt::AlignVCenter);
       if (amountMM.isNegative()) {
         advancedItem->setForeground(it_c, KMyMoneyGlobalSettings::listNegativeValueColor());
       }
       it_c++;
 
       QString dateString = KGlobal::locale()->formatDate(maxDate, KLocale::ShortDate);
       advancedItem->setText(it_c, dateString);
       advancedItem->setTextAlignment(it_c, Qt::AlignRight | Qt::AlignVCenter);
       if (amountMM.isNegative()) {
         advancedItem->setForeground(it_c, KMyMoneyGlobalSettings::listNegativeValueColor());
       }
       it_c++;
     }
     //get average balance
     amountMM = forecast.accountAverageBalance(acc);
     amount = MyMoneyUtils::formatMoney(amountMM, acc, currency);
     advancedItem->setText(it_c, amount);
     advancedItem->setTextAlignment(it_c, Qt::AlignRight | Qt::AlignVCenter);
     if (amountMM.isNegative()) {
       advancedItem->setForeground(it_c, KMyMoneyGlobalSettings::listNegativeValueColor());
     }
     it_c++;
   }
 
   // make sure all data is shown
   adjustHeadersAndResizeToContents(m_advancedList);
 
   m_advancedList->show();
 }
 
 void KForecastView::loadBudgetView()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyForecast forecast = KMyMoneyGlobalSettings::forecast();
 
   //get the settings from current page and calculate this year based on last year
   QDate historyEndDate = QDate(QDate::currentDate().year() - 1, 12, 31);
   QDate historyStartDate = historyEndDate.addDays(-m_accountsCycle->value() * m_forecastCycles->value());
   QDate forecastStartDate = QDate(QDate::currentDate().year(), 1, 1);
   QDate forecastEndDate = QDate::currentDate().addDays(m_forecastDays->value());
   forecast.setHistoryMethod(m_historyMethod->checkedId());
 
   MyMoneyBudget budget;
   forecast.createBudget(budget, historyStartDate, historyEndDate, forecastStartDate, forecastEndDate, false);
 
   m_budgetList->clear();
   m_budgetList->setIconSize(QSize(22, 22));
   m_budgetList->setSortingEnabled(true);
   m_budgetList->sortByColumn(0, Qt::AscendingOrder);
 
   //add columns
   QStringList headerLabels;
   headerLabels << i18n("Account");
 
   {
     QDate forecastStartDate = forecast.forecastStartDate();
     QDate forecastEndDate = forecast.forecastEndDate();
 
     //add cycle interval columns
     QDate f_date = forecastStartDate;
     for (; f_date <= forecastEndDate; f_date = f_date.addMonths(1)) {
       headerLabels << QDate::longMonthName(f_date.month());
     }
   }
   //add total column
   headerLabels << i18nc("Total balance", "Total");
 
   //set the columns
   m_budgetList->setHeaderLabels(headerLabels);
 
   //add default rows
   addTotalRow(m_budgetList, forecast);
   addIncomeExpenseRows(forecast);
 
   //load income and expense budget accounts
   loadAccounts(forecast, file->income(), m_incomeItem, eBudget);
   loadAccounts(forecast, file->expense(), m_expenseItem, eBudget);
 
   adjustHeadersAndResizeToContents(m_budgetList);
 }
 
 QList<MyMoneyPrice> KForecastView::getAccountPrices(const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<MyMoneyPrice> prices;
   MyMoneySecurity security = file->baseCurrency();
   try {
     if (acc.isInvest()) {
       security = file->security(acc.currencyId());
       if (security.tradingCurrency() != file->baseCurrency().id()) {
         MyMoneySecurity sec = file->security(security.tradingCurrency());
         prices += file->price(sec.id(), file->baseCurrency().id());
       }
     } else if (acc.currencyId() != file->baseCurrency().id()) {
       if (acc.currencyId() != file->baseCurrency().id()) {
         security = file->security(acc.currencyId());
         prices += file->price(acc.currencyId(), file->baseCurrency().id());
       }
     }
 
   } catch (const MyMoneyException &e) {
     kDebug(2) << Q_FUNC_INFO << " caught exception while adding " << acc.name() << "[" << acc.id() << "]: " << e.what();
   }
   return prices;
 }
 
 void KForecastView::addAssetLiabilityRows(const MyMoneyForecast& forecast)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   m_assetItem = new QTreeWidgetItem(m_totalItem);
   m_assetItem->setText(0, file->asset().name());
   m_assetItem->setIcon(0, file->asset().accountPixmap());
   m_assetItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
   m_assetItem->setData(0, AccountRole, QVariant::fromValue(file->asset()));
   m_assetItem->setExpanded(true);
 
   m_liabilityItem = new QTreeWidgetItem(m_totalItem);
   m_liabilityItem->setText(0, file->liability().name());
   m_liabilityItem->setIcon(0, file->liability().accountPixmap());
   m_liabilityItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
   m_liabilityItem->setData(0, AccountRole, QVariant::fromValue(file->liability()));
   m_liabilityItem->setExpanded(true);
 }
 
 void KForecastView::addIncomeExpenseRows(const MyMoneyForecast& forecast)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   m_incomeItem = new QTreeWidgetItem(m_totalItem);
   m_incomeItem->setText(0, file->income().name());
   m_incomeItem->setIcon(0, file->income().accountPixmap());
   m_incomeItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
   m_incomeItem->setData(0, AccountRole, QVariant::fromValue(file->income()));
   m_incomeItem->setExpanded(true);
 
   m_expenseItem = new QTreeWidgetItem(m_totalItem);
   m_expenseItem->setText(0, file->expense().name());
   m_expenseItem->setIcon(0, file->expense().accountPixmap());
   m_expenseItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
   m_expenseItem->setData(0, AccountRole, QVariant::fromValue(file->expense()));
   m_expenseItem->setExpanded(true);
 }
 
 void KForecastView::addTotalRow(QTreeWidget* forecastList, const MyMoneyForecast& forecast)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   m_totalItem = new QTreeWidgetItem(forecastList);
   QFont font;
   font.setBold(true);
   m_totalItem->setFont(0, font);
   m_totalItem->setText(0, i18nc("Total balance", "Total"));
   m_totalItem->setIcon(0, file->asset().accountPixmap());
   m_totalItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
   m_totalItem->setData(0, AccountRole, QVariant::fromValue(file->asset()));
   m_totalItem->setExpanded(true);
 }
 
 bool KForecastView::includeAccount(MyMoneyForecast& forecast, const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   if (forecast.isForecastAccount(acc))
     return true;
 
   QStringList accounts = acc.accountList();
 
   if (accounts.size() > 0) {
     QStringList::ConstIterator it_acc;
     for (it_acc = accounts.constBegin(); it_acc != accounts.constEnd(); ++it_acc) {
       MyMoneyAccount account = file->account(*it_acc);
       if (includeAccount(forecast, account))
         return true;
     }
   }
   return false;
 }
 
 void KForecastView::adjustHeadersAndResizeToContents(QTreeWidget *widget)
 {
   QSize sizeHint(0, widget->sizeHintForRow(0));
   QTreeWidgetItem *header = widget->headerItem();
   for (int i = 0; i < header->columnCount(); ++i) {
     if (i > 0) {
       header->setData(i, Qt::TextAlignmentRole, Qt::AlignRight);
       // make sure that the row height stays the same even when the column that has icons is not visible
       if (m_totalItem) {
         m_totalItem->setSizeHint(i, sizeHint);
       }
     }
     widget->resizeColumnToContents(i);
   }
 }
 
 void KForecastView::loadAccounts(MyMoneyForecast& forecast, const MyMoneyAccount& account, QTreeWidgetItem* parentItem, int forecastType)
 {
   QMap<QString, QString> nameIdx;
   QStringList accList;
   MyMoneyFile* file = MyMoneyFile::instance();
   QTreeWidgetItem *forecastItem = 0;
 
   //Get all accounts of the right type to calculate forecast
   accList = account.accountList();
 
   if (accList.size() == 0)
     return;
 
   QStringList::ConstIterator accList_t;
   for (accList_t = accList.constBegin(); accList_t != accList.constEnd(); ++accList_t) {
     MyMoneyAccount subAccount = file->account(*accList_t);
     //only add the account if it is a forecast account or the parent of a forecast account
     if (includeAccount(forecast, subAccount)) {
       nameIdx[subAccount.id()] = subAccount.id();
     }
   }
 
   QMap<QString, QString>::ConstIterator it_nc;
   for (it_nc = nameIdx.constBegin(); it_nc != nameIdx.constEnd(); ++it_nc) {
 
     const MyMoneyAccount subAccount = file->account(*it_nc);
     MyMoneySecurity currency;
     if (subAccount.isInvest()) {
       MyMoneySecurity underSecurity = file->security(subAccount.currencyId());
       currency = file->security(underSecurity.tradingCurrency());
     } else {
       currency = file->security(subAccount.currencyId());
     }
 
     forecastItem = new QTreeWidgetItem(parentItem);
     forecastItem->setText(0, subAccount.name());
     forecastItem->setIcon(0, subAccount.accountPixmap());
     forecastItem->setData(0, ForecastRole, QVariant::fromValue(forecast));
     forecastItem->setData(0, AccountRole, QVariant::fromValue(subAccount));
     forecastItem->setExpanded(true);
 
     switch (forecastType) {
       case eSummary:
         updateSummary(forecastItem);
         break;
       case eDetailed:
         updateDetailed(forecastItem);
         break;
       case eBudget:
         updateBudget(forecastItem);
         break;
       default:
         break;
     }
 
     loadAccounts(forecast, subAccount, forecastItem, forecastType);
   }
 }
 
 void KForecastView::updateSummary(QTreeWidgetItem *item)
 {
   MyMoneyMoney amountMM;
   int it_c = 1; // iterator for the columns of the listview
   MyMoneyFile* file = MyMoneyFile::instance();
   int daysToBeginDay;
 
   MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
 
   if (QDate::currentDate() < forecast.beginForecastDate()) {
     daysToBeginDay = QDate::currentDate().daysTo(forecast.beginForecastDate());
   } else {
     daysToBeginDay = forecast.accountsCycle();
   }
 
   MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
   MyMoneySecurity currency;
   if (account.isInvest()) {
     MyMoneySecurity underSecurity = file->security(account.currencyId());
     currency = file->security(underSecurity.tradingCurrency());
   } else {
     currency = file->security(account.currencyId());
   }
 
 
   //add current balance column
   QDate summaryDate = QDate::currentDate();
   amountMM = forecast.forecastBalance(account, summaryDate);
 
   //calculate the balance in base currency for the total row
   setAmount(item, it_c, amountMM);
   setValue(item, it_c, amountMM, summaryDate);
   showAmount(item, it_c, amountMM, currency);
   it_c++;
 
   //iterate through all other columns
   for (QDate summaryDate = QDate::currentDate().addDays(daysToBeginDay); summaryDate <= forecast.forecastEndDate(); summaryDate = summaryDate.addDays(forecast.accountsCycle()), ++it_c) {
     amountMM = forecast.forecastBalance(account, summaryDate);
 
     //calculate the balance in base currency for the total row
     setAmount(item, it_c, amountMM);
     setValue(item, it_c, amountMM, summaryDate);
     showAmount(item, it_c, amountMM, currency);
   }
   //calculate and add variation per cycle
   setNegative(item, forecast.accountTotalVariation(account).isNegative());
   setAmount(item, it_c, forecast.accountTotalVariation(account));
   setValue(item, it_c, forecast.accountTotalVariation(account), forecast.forecastEndDate());
   showAmount(item, it_c, forecast.accountTotalVariation(account), currency);
 }
 
 void KForecastView::updateDetailed(QTreeWidgetItem *item)
 {
   QString amount;
   QString vAmount;
   MyMoneyMoney vAmountMM;
   MyMoneyFile* file = MyMoneyFile::instance();
 
   MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
 
   MyMoneySecurity currency;
   if (account.isInvest()) {
     MyMoneySecurity underSecurity = file->security(account.currencyId());
     currency = file->security(underSecurity.tradingCurrency());
   } else {
     currency = file->security(account.currencyId());
   }
 
   int it_c = 1; // iterator for the columns of the listview
 
   MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
 
   for (QDate forecastDate = QDate::currentDate(); forecastDate <= forecast.forecastEndDate(); ++it_c, forecastDate = forecastDate.addDays(1)) {
     MyMoneyMoney amountMM = forecast.forecastBalance(account, forecastDate);
 
     //calculate the balance in base currency for the total row
     setAmount(item, it_c, amountMM);
     setValue(item, it_c, amountMM, forecastDate);
     showAmount(item, it_c, amountMM, currency);
   }
 
   //calculate and add variation per cycle
   vAmountMM = forecast.accountTotalVariation(account);
   setAmount(item, it_c, vAmountMM);
   setValue(item, it_c, vAmountMM, forecast.forecastEndDate());
   showAmount(item, it_c, vAmountMM, currency);
 }
 
 void KForecastView::updateBudget(QTreeWidgetItem *item)
 {
   MyMoneySecurity currency;
   MyMoneyMoney tAmountMM;
 
   MyMoneyForecast forecast = item->data(0, ForecastRole).value<MyMoneyForecast>();
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int it_c = 1; // iterator for the columns of the listview
   QDate forecastDate = forecast.forecastStartDate();
 
   MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
 
   if (account.isInvest()) {
     MyMoneySecurity underSecurity = file->security(account.currencyId());
     currency = file->security(underSecurity.tradingCurrency());
   } else {
     currency = file->security(account.currencyId());
   }
 
   //iterate columns
   for (; forecastDate <= forecast.forecastEndDate(); forecastDate = forecastDate.addMonths(1), ++it_c) {
     MyMoneyMoney amountMM;
     amountMM = forecast.forecastBalance(account, forecastDate);
     if (account.accountType() == MyMoneyAccount::Expense)
       amountMM = -amountMM;
 
     tAmountMM += amountMM;
     setAmount(item, it_c, amountMM);
     setValue(item, it_c, amountMM, forecastDate);
     showAmount(item, it_c, amountMM, currency);
   }
 
   //set total column
   setAmount(item, it_c, tAmountMM);
   setValue(item, it_c, tAmountMM, forecast.forecastEndDate());
   showAmount(item, it_c, tAmountMM, currency);
 }
 
 void KForecastView::setNegative(QTreeWidgetItem *item, bool isNegative)
 {
   if (isNegative) {
     for (int i = 0; i < item->columnCount(); ++i) {
       item->setForeground(i, KMyMoneyGlobalSettings::listNegativeValueColor());
     }
   }
 }
 
 void KForecastView::showAmount(QTreeWidgetItem* item, int column, const MyMoneyMoney& amount, const MyMoneySecurity& security)
 {
   item->setText(column, MyMoneyUtils::formatMoney(amount, item->data(0, AccountRole).value<MyMoneyAccount>(), security));
   item->setTextAlignment(column, Qt::AlignRight | Qt::AlignVCenter);
   item->setFont(column, item->font(0));
   if (amount.isNegative()) {
     item->setForeground(column, KMyMoneyGlobalSettings::listNegativeValueColor());
   }
 }
 
 void KForecastView::adjustParentValue(QTreeWidgetItem *item, int column, const MyMoneyMoney& value)
 {
   if (!item)
     return;
 
   item->setData(column, ValueRole, QVariant::fromValue(item->data(column, ValueRole).value<MyMoneyMoney>() + value));
   item->setData(column, ValueRole, QVariant::fromValue(item->data(column, ValueRole).value<MyMoneyMoney>().convert(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction())));
 
   // if the entry has no children,
   // or it is the top entry
   // or it is currently not open
   // we need to display the value of it
   if (item->childCount() == 0 || !item->parent() || (!item->isExpanded() && item->childCount() > 0) || (item->parent() && !item->parent()->parent())) {
     if (item->childCount() > 0)
       item->setText(column, " ");
     MyMoneyMoney amount = item->data(column, ValueRole).value<MyMoneyMoney>();
     showAmount(item, column, amount, MyMoneyFile::instance()->baseCurrency());
   }
 
   // now make sure, the upstream accounts also get notified about the value change
   adjustParentValue(item->parent(), column, value);
 }
 
 void KForecastView::setValue(QTreeWidgetItem* item, int column, const MyMoneyMoney& amount, const QDate& forecastDate)
 {
   MyMoneyAccount account = item->data(0, AccountRole).value<MyMoneyAccount>();
   //calculate the balance in base currency for the total row
   if (account.currencyId() != MyMoneyFile::instance()->baseCurrency().id()) {
     ReportAccount repAcc = ReportAccount(account.id());
     MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(forecastDate);
     MyMoneyMoney baseAmountMM = amount * curPrice;
     MyMoneyMoney value = baseAmountMM.convert(MyMoneyFile::instance()->baseCurrency().smallestAccountFraction());
     item->setData(column, ValueRole, QVariant::fromValue(value));
     adjustParentValue(item->parent(), column, value);
   } else {
     item->setData(column, ValueRole, QVariant::fromValue(item->data(column, ValueRole).value<MyMoneyMoney>() + amount));
     adjustParentValue(item->parent(), column, amount);
   }
 }
 
 void KForecastView::setAmount(QTreeWidgetItem* item, int column, const MyMoneyMoney& amount)
 {
   item->setData(column, AmountRole, QVariant::fromValue(amount));
   item->setTextAlignment(column, Qt::AlignRight | Qt::AlignVCenter);
 }
 
 void KForecastView::itemExpanded(QTreeWidgetItem *item)
 {
   if (!item->parent() || !item->parent()->parent())
     return;
   for (int i = 1; i < item->columnCount(); ++i) {
     showAmount(item, i, item->data(i, AmountRole).value<MyMoneyMoney>(), MyMoneyFile::instance()->security(item->data(0, AccountRole).value<MyMoneyAccount>().currencyId()));
   }
 }
 
 void KForecastView::itemCollapsed(QTreeWidgetItem *item)
 {
   for (int i = 1; i < item->columnCount(); ++i) {
     showAmount(item, i, item->data(i, ValueRole).value<MyMoneyMoney>(), MyMoneyFile::instance()->baseCurrency());
   }
 }
 
 void KForecastView::loadChartView()
 {
   MyMoneyReport::EDetailLevel detailLevel[4] = { MyMoneyReport::eDetailAll, MyMoneyReport::eDetailTop, MyMoneyReport::eDetailGroup, MyMoneyReport::eDetailTotal };
 
   MyMoneyReport reportCfg = MyMoneyReport(
                               MyMoneyReport::eAssetLiability,
-                              MyMoneyReport::eMonths,
+                              MyMoneyReport::Column::Months,
                               MyMoneyTransactionFilter::userDefined, // overridden by the setDateFilter() call below
                               detailLevel[m_comboDetail->currentIndex()],
                               i18n("Net Worth Forecast"),
                               i18n("Generated Report"));
 
   reportCfg.setChartByDefault(true);
   reportCfg.setChartGridLines(false);
   reportCfg.setChartType(MyMoneyReport::eChartLine);
   reportCfg.setIncludingSchedules(false);
   // FIXME: this causes a crash
   //reportCfg.setColumnsAreDays( true );
   reportCfg.setChartDataLabels(false);
   reportCfg.setConvertCurrency(true);
   reportCfg.setIncludingForecast(true);
   reportCfg.setDateFilter(QDate::currentDate(), QDate::currentDate().addDays(m_forecastDays->value()));
   reports::PivotTable table(reportCfg);
 
   table.drawChart(*m_forecastChart);
 
   // Adjust the size
   m_forecastChart->resize(m_tab->width() - 10, m_tab->height());
   //m_forecastChart->show();
   m_forecastChart->update();
 
 }
diff --git a/kmymoney/views/khomeview.cpp b/kmymoney/views/khomeview.cpp
index 9b76ee597..cc0121047 100644
--- a/kmymoney/views/khomeview.cpp
+++ b/kmymoney/views/khomeview.cpp
@@ -1,2025 +1,2025 @@
 /***************************************************************************
                           khomeview.cpp  -  description
                              -------------------
     begin                : Tue Jan 22 2002
     copyright            : (C) 2000-2002 by Michael Edwardes <mte@users.sourceforge.net>
                            Javier Campos Morales <javi_c@users.sourceforge.net>
                            Felix Rodriguez <frodriguez@users.sourceforge.net>
                            John C <thetacoturtle@users.sourceforge.net>
                            Thomas Baumgart <ipwizard@users.sourceforge.net>
                            Kevin Tambascio <ktambascio@users.sourceforge.net>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   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 "khomeview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QLayout>
 #include <QDateTime>
 #include <QApplication>
 #include <QList>
 #include <QPixmap>
 #include <QDomDocument>
 #include <QDomElement>
 #include <QDomText>
 #include <QFile>
 #include <QTimer>
 #include <QBuffer>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <kglobal.h>
 #include <klocale.h>
 #include <kstandarddirs.h>
 #include <khtmlview.h>
 #include <kconfig.h>
 #include <kstandardaction.h>
 #include <kxmlguiwindow.h>
 #include <kactioncollection.h>
 #include <kapplication.h>
 #include <kmessagebox.h>
 #include <kdebug.h>
 #include <kcodecs.h>
 #include <kglobalsettings.h>
 #include <kiconloader.h>
 #include <ktoolinvocation.h>
 #include <KToggleAction>
 #include <khtml_part.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 #include "kmymoneyutils.h"
 #include "kwelcomepage.h"
 #include "kmymoneyglobalsettings.h"
 #include "mymoneyfile.h"
 #include "mymoneyforecast.h"
 #include "kmymoney.h"
 #include "kreportchartview.h"
 #include "pivottable.h"
 #include "pivotgrid.h"
 #include "reportaccount.h"
 
 #define VIEW_LEDGER         "ledger"
 #define VIEW_SCHEDULE       "schedule"
 #define VIEW_WELCOME        "welcome"
 #define VIEW_HOME           "home"
 #define VIEW_REPORTS        "reports"
 
 bool accountNameLess(const MyMoneyAccount &acc1, const MyMoneyAccount &acc2)
 {
   return acc1.name().localeAwareCompare(acc2.name()) < 0;
 }
 
 using namespace reports;
 
 class KHomeView::Private
 {
 public:
   Private() :
       m_showAllSchedules(false),
       m_needReload(false),
       m_netWorthGraphLastValidSize(400, 300) {
   }
 
   /**
    * daily balances of an account
    */
   typedef QMap<QDate, MyMoneyMoney> dailyBalances;
 
   KHTMLPart*      m_part;
   QString         m_html;
   bool            m_showAllSchedules;
   bool            m_needReload;
   MyMoneyForecast m_forecast;
   MyMoneyMoney    m_total;
   /**
     * Hold the last valid size of the net worth graph
     * for the times when the needed size can't be computed.
     */
   QSize           m_netWorthGraphLastValidSize;
 
   /**
     * daily forecast balance of accounts
     */
   QMap<QString, dailyBalances> m_accountList;
 };
 
 /**
  * @brief Converts a QPixmap to an data URI scheme
  *
  * According to RFC 2397
  *
  * @param pixmap Source to convert
  * @return full data URI
  */
 QString QPixmapToDataUri(const QPixmap& pixmap)
 {
   QImage image(pixmap.toImage());
   QByteArray byteArray;
   QBuffer buffer(&byteArray);
   buffer.open(QIODevice::WriteOnly);
   image.save(&buffer, "PNG"); // writes the image in PNG format inside the buffer
   return QLatin1String("data:image/png;base64,") + QString(byteArray.toBase64());
 }
 
 KHomeView::KHomeView(QWidget *parent, const char *name) :
     KMyMoneyViewBase(parent, name, i18n("Home")),
     d(new Private)
 {
   d->m_part = new KHTMLPart(this);
   addWidget(d->m_part->view());
 
   d->m_part->begin();
   d->m_part->write(KWelcomePage::welcomePage());
   d->m_part->end();
 
   // we are going to handle the zoom view signal to change the font scale
   connect(d->m_part->view(), SIGNAL(zoomView(int)), this, SLOT(slotZoomView(int)));
   disconnect(d->m_part->view(), SIGNAL(zoomView(int)), d->m_part, SLOT(slotZoomView(int)));
 
   connect(d->m_part->browserExtension(), SIGNAL(openUrlRequest(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)),
           this, SLOT(slotOpenUrl(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)));
 }
 
 KHomeView::~KHomeView()
 {
   // if user wants to remember the font size, store it here
   if (KMyMoneyGlobalSettings::rememberFontSize()) {
     KMyMoneyGlobalSettings::setFontSizePercentage(d->m_part->fontScaleFactor());
     KMyMoneyGlobalSettings::self()->writeConfig();
   }
   //This is to prevent a crash on exit with KDE 4.3.2
   delete d->m_part;
 
   delete d;
 }
 
 void KHomeView::slotLoadView()
 {
   d->m_needReload = true;
   if (isVisible()) {
     loadView();
     d->m_needReload = false;
   }
 }
 
 void KHomeView::showEvent(QShowEvent* event)
 {
   emit aboutToShow();
 
   if (d->m_needReload) {
     loadView();
     d->m_needReload = false;
   }
 
   QWidget::showEvent(event);
 }
 
 void KHomeView::slotPrintView()
 {
   if (d->m_part && d->m_part->view())
     d->m_part->view()->print();
 }
 
 void KHomeView::slotZoomView(int delta)
 {
   const int fontScaleStepping = 10;
   if (delta > 0)
     d->m_part->setFontScaleFactor(d->m_part->fontScaleFactor() + fontScaleStepping);
   else
     d->m_part->setFontScaleFactor(d->m_part->fontScaleFactor() - fontScaleStepping);
 }
 
 void KHomeView::loadView()
 {
   d->m_part->setFontScaleFactor(KMyMoneyGlobalSettings::fontSizePercentage());
 
   QList<MyMoneyAccount> list;
   MyMoneyFile::instance()->accountList(list);
   if (list.count() == 0) {
     d->m_part->begin();
     d->m_part->write(KWelcomePage::welcomePage());
     d->m_part->end();
   } else {
     //clear the forecast flag so it will be reloaded
     d->m_forecast.setForecastDone(false);
 
     const QString filename = KGlobal::dirs()->findResource("appdata", "html/kmymoney.css");
     QString header = QString("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0//EN\">\n<html><head><link rel=\"stylesheet\" type=\"text/css\" href=\"%1\">\n").arg(filename);
 
     header += KMyMoneyUtils::variableCSS();
 
     header += "</head><body id=\"summaryview\">\n";
 
     QString footer = "</body></html>\n";
 
     d->m_html.clear();
     d->m_html += header;
 
     d->m_html += QString("<div id=\"summarytitle\">%1</div>").arg(i18n("Your Financial Summary"));
 
     QStringList settings = KMyMoneyGlobalSettings::itemList();
 
     QStringList::ConstIterator it;
 
     for (it = settings.constBegin(); it != settings.constEnd(); ++it) {
       int option = (*it).toInt();
       if (option > 0) {
         switch (option) {
           case 1:         // payments
             showPayments();
             break;
 
           case 2:         // preferred accounts
             showAccounts(Preferred, i18n("Preferred Accounts"));
             break;
 
           case 3:         // payment accounts
             // Check if preferred accounts are shown separately
             if (settings.contains("2")) {
               showAccounts(static_cast<paymentTypeE>(Payment | Preferred),
                            i18n("Payment Accounts"));
             } else {
               showAccounts(Payment, i18n("Payment Accounts"));
             }
             break;
           case 4:         // favorite reports
             showFavoriteReports();
             break;
           case 5:         // forecast
             showForecast();
             break;
           case 6:         // net worth graph over all accounts
             showNetWorthGraph();
             break;
           case 8:         // assets and liabilities
             showAssetsLiabilities();
             break;
           case 9:         // budget
             showBudget();
             break;
           case 10:         // cash flow summary
             showCashFlowSummary();
             break;
 
 
         }
         d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
       }
     }
 
     d->m_html += "<div id=\"returnlink\">";
     d->m_html += link(VIEW_WELCOME, QString()) + i18n("Show KMyMoney welcome page") + linkend();
     d->m_html += "</div>";
     d->m_html += "<div id=\"vieweffect\"></div>";
     d->m_html += footer;
 
     d->m_part->begin();
     d->m_part->write(d->m_html);
     d->m_part->end();
   }
 }
 
 void KHomeView::showNetWorthGraph()
 {
   d->m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("Net Worth Forecast"));
 
   MyMoneyReport reportCfg = MyMoneyReport(
                               MyMoneyReport::eAssetLiability,
-                              MyMoneyReport::eMonths,
+                              MyMoneyReport::Column::Months,
                               MyMoneyTransactionFilter::userDefined, // overridden by the setDateFilter() call below
                               MyMoneyReport::eDetailTotal,
                               i18n("Net Worth Forecast"),
                               i18n("Generated Report"));
 
   reportCfg.setChartByDefault(true);
   reportCfg.setChartGridLines(false);
   reportCfg.setChartDataLabels(false);
   reportCfg.setChartType(MyMoneyReport::eChartLine);
   reportCfg.setIncludingSchedules(false);
   reportCfg.addAccountGroup(MyMoneyAccount::Asset);
   reportCfg.addAccountGroup(MyMoneyAccount::Liability);
   reportCfg.setColumnsAreDays(true);
   reportCfg.setConvertCurrency(true);
   reportCfg.setIncludingForecast(true);
   reportCfg.setDateFilter(QDate::currentDate(), QDate::currentDate().addDays(+ 90));
   reports::PivotTable table(reportCfg);
 
   reports::KReportChartView* chartWidget = new reports::KReportChartView(0);
 
   table.drawChart(*chartWidget);
 
   // Adjust the size
   QSize netWorthGraphSize = KHomeView::size();
   netWorthGraphSize -= QSize(80, 30);
   // consider the computed size valid only if it's smaller on both axes that the applications size
   if (netWorthGraphSize.width() < kmymoney->width() || netWorthGraphSize.height() < kmymoney->height()) {
     d->m_netWorthGraphLastValidSize = netWorthGraphSize;
   }
   chartWidget->resize(d->m_netWorthGraphLastValidSize);
 
   //save the chart to an image
   QString chart = QPixmapToDataUri(QPixmap::grabWidget(chartWidget->coordinatePlane()->parent()));
 
   d->m_html += QString("<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >");
   d->m_html += QString("<tr>");
   d->m_html += QString("<td><center><img src=\"%1\" ALT=\"Networth\" width=\"100%\" ></center></td>").arg(chart);
   d->m_html += QString("</tr>");
   d->m_html += QString("</table></div></div>");
 
   //delete the widget since we no longer need it
   delete chartWidget;
 }
 
 void KHomeView::showPayments()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<MyMoneySchedule> overdues;
   QList<MyMoneySchedule> schedule;
   int i = 0;
 
   //if forecast has not been executed yet, do it.
   if (!d->m_forecast.isForecastDone())
     doForecast();
 
   schedule = file->scheduleList("", MyMoneySchedule::TYPE_ANY,
                                 MyMoneySchedule::OCCUR_ANY,
                                 MyMoneySchedule::STYPE_ANY,
                                 QDate::currentDate(),
                                 QDate::currentDate().addMonths(1));
   overdues = file->scheduleList("", MyMoneySchedule::TYPE_ANY,
                                 MyMoneySchedule::OCCUR_ANY,
                                 MyMoneySchedule::STYPE_ANY,
                                 QDate(), QDate(), true);
 
   if (schedule.empty() && overdues.empty())
     return;
 
   // HACK
   // Remove the finished schedules
   QList<MyMoneySchedule>::Iterator d_it;
   //regular schedules
   d_it = schedule.begin();
   while (d_it != schedule.end()) {
     if ((*d_it).isFinished()) {
       d_it = schedule.erase(d_it);
       continue;
     }
     ++d_it;
   }
   //overdue schedules
   d_it = overdues.begin();
   while (d_it != overdues.end()) {
     if ((*d_it).isFinished()) {
       d_it = overdues.erase(d_it);
       continue;
     }
     ++d_it;
   }
 
   d->m_html += "<div class=\"shadow\"><div class=\"displayblock\">";
   d->m_html += QString("<div class=\"summaryheader\">%1</div>\n").arg(i18n("Payments"));
 
   if (!overdues.isEmpty()) {
     d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
 
     qSort(overdues);
     QList<MyMoneySchedule>::Iterator it;
     QList<MyMoneySchedule>::Iterator it_f;
 
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     d->m_html += QString("<tr class=\"itemtitle warningtitle\" ><td colspan=\"5\">%1</td></tr>\n").arg(showColoredAmount(i18n("Overdue payments"), true));
     d->m_html += "<tr class=\"item warning\">";
     d->m_html += "<td class=\"left\" width=\"10%\">";
     d->m_html += i18n("Date");
     d->m_html += "</td>";
     d->m_html += "<td class=\"left\" width=\"40%\">";
     d->m_html += i18n("Schedule");
     d->m_html += "</td>";
     d->m_html += "<td class=\"left\" width=\"20%\">";
     d->m_html += i18n("Account");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"15%\">";
     d->m_html += i18n("Amount");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"15%\">";
     d->m_html += i18n("Balance after");
     d->m_html += "</td>";
     d->m_html += "</tr>";
 
     for (it = overdues.begin(); it != overdues.end(); ++it) {
       // determine number of overdue payments
       int cnt =
         (*it).transactionsRemainingUntil(QDate::currentDate().addDays(-1));
 
       d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
       showPaymentEntry(*it, cnt);
       d->m_html += "</tr>";
     }
     d->m_html += "</table>";
   }
 
   if (!schedule.isEmpty()) {
     qSort(schedule);
 
     // Extract todays payments if any
     QList<MyMoneySchedule> todays;
     QList<MyMoneySchedule>::Iterator t_it;
     for (t_it = schedule.begin(); t_it != schedule.end();) {
       if ((*t_it).adjustedNextDueDate() == QDate::currentDate()) {
         todays.append(*t_it);
         (*t_it).setNextDueDate((*t_it).nextPayment(QDate::currentDate()));
 
         // if adjustedNextDueDate is still currentDate then remove it from
         // scheduled payments
         if ((*t_it).adjustedNextDueDate() == QDate::currentDate()) {
           t_it = schedule.erase(t_it);
           continue;
         }
       }
       ++t_it;
     }
 
     if (todays.count() > 0) {
       d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
       d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       d->m_html += QString("<tr class=\"itemtitle\"><td class=\"left\" colspan=\"5\">%1</td></tr>\n").arg(i18n("Today's due payments"));
       d->m_html += "<tr class=\"item\">";
       d->m_html += "<td class=\"left\" width=\"10%\">";
       d->m_html += i18n("Date");
       d->m_html += "</td>";
       d->m_html += "<td class=\"left\" width=\"40%\">";
       d->m_html += i18n("Schedule");
       d->m_html += "</td>";
       d->m_html += "<td class=\"left\" width=\"20%\">";
       d->m_html += i18n("Account");
       d->m_html += "</td>";
       d->m_html += "<td class=\"right\" width=\"15%\">";
       d->m_html += i18n("Amount");
       d->m_html += "</td>";
       d->m_html += "<td class=\"right\" width=\"15%\">";
       d->m_html += i18n("Balance after");
       d->m_html += "</td>";
       d->m_html += "</tr>";
 
       for (t_it = todays.begin(); t_it != todays.end(); ++t_it) {
         d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         showPaymentEntry(*t_it);
         d->m_html += "</tr>";
       }
       d->m_html += "</table>";
     }
 
     if (!schedule.isEmpty()) {
       d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
 
       QList<MyMoneySchedule>::Iterator it;
 
       d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
       d->m_html += QString("<tr class=\"itemtitle\"><td class=\"left\" colspan=\"5\">%1</td></tr>\n").arg(i18n("Future payments"));
       d->m_html += "<tr class=\"item\">";
       d->m_html += "<td class=\"left\" width=\"10%\">";
       d->m_html += i18n("Date");
       d->m_html += "</td>";
       d->m_html += "<td class=\"left\" width=\"40%\">";
       d->m_html += i18n("Schedule");
       d->m_html += "</td>";
       d->m_html += "<td class=\"left\" width=\"20%\">";
       d->m_html += i18n("Account");
       d->m_html += "</td>";
       d->m_html += "<td class=\"right\" width=\"15%\">";
       d->m_html += i18n("Amount");
       d->m_html += "</td>";
       d->m_html += "<td class=\"right\" width=\"15%\">";
       d->m_html += i18n("Balance after");
       d->m_html += "</td>";
       d->m_html += "</tr>";
 
       // show all or the first 6 entries
       int cnt;
       cnt = (d->m_showAllSchedules) ? -1 : 6;
       bool needMoreLess = d->m_showAllSchedules;
 
       QDate lastDate = QDate::currentDate().addMonths(1);
       qSort(schedule);
       do {
         it = schedule.begin();
         if (it == schedule.end())
           break;
 
         // if the next due date is invalid (schedule is finished)
         // we remove it from the list
         QDate nextDate = (*it).nextDueDate();
         if (!nextDate.isValid()) {
           schedule.erase(it);
           continue;
         }
 
         if (nextDate > lastDate)
           break;
 
         if (cnt == 0) {
           needMoreLess = true;
           break;
         }
 
         // in case we've shown the current recurrence as overdue,
         // we don't show it here again, but keep the schedule
         // as it might show up later in the list again
         if (!(*it).isOverdue()) {
           if (cnt > 0)
             --cnt;
 
           d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
           showPaymentEntry(*it);
           d->m_html += "</tr>";
 
           // for single occurrence we have reported everything so we
           // better get out of here.
           if ((*it).occurrence() == MyMoneySchedule::OCCUR_ONCE) {
             schedule.erase(it);
             continue;
           }
         }
 
         // if nextPayment returns an invalid date, setNextDueDate will
         // just skip it, resulting in a loop
         // we check the resulting date and erase the schedule if invalid
         if (!((*it).nextPayment((*it).nextDueDate())).isValid()) {
           schedule.erase(it);
           continue;
         }
 
         (*it).setNextDueDate((*it).nextPayment((*it).nextDueDate()));
         qSort(schedule);
       } while (1);
 
       if (needMoreLess) {
         d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
         d->m_html += "<td colspan=\"5\">";
         if (d->m_showAllSchedules) {
           d->m_html += link(VIEW_SCHEDULE,  QString("?mode=%1").arg("reduced")) + i18nc("Less...", "Show fewer schedules on the list") + linkend();
         } else {
           d->m_html += link(VIEW_SCHEDULE,  QString("?mode=%1").arg("full")) + i18nc("More...", "Show more schedules on the list") + linkend();
         }
         d->m_html += "</td>";
         d->m_html += "</tr>";
       }
       d->m_html += "</table>";
     }
   }
   d->m_html += "</div></div>";
 }
 
 void KHomeView::showPaymentEntry(const MyMoneySchedule& sched, int cnt)
 {
   QString tmp;
   MyMoneyFile* file = MyMoneyFile::instance();
 
   try {
     MyMoneyAccount acc = sched.account();
     if (!acc.id().isEmpty()) {
       MyMoneyTransaction t = sched.transaction();
       // only show the entry, if it is still active
       if (!sched.isFinished()) {
         MyMoneySplit sp = t.splitByAccount(acc.id(), true);
 
         QString pathEnter = QPixmapToDataUri(KIconLoader::global()->loadIcon(KMyMoneyGlobalSettings::enterScheduleIcon(), KIconLoader::Small, KIconLoader::SizeSmall));
         QString pathSkip = QPixmapToDataUri(KIconLoader::global()->loadIcon(QString("media-seek-forward"), KIconLoader::Small, KIconLoader::SizeSmall));
 
         //show payment date
         tmp = QString("<td>") +
               KGlobal::locale()->formatDate(sched.adjustedNextDueDate(), KLocale::ShortDate) +
               "</td><td>";
         if (!pathEnter.isEmpty())
           tmp += link(VIEW_SCHEDULE, QString("?id=%1&amp;mode=enter").arg(sched.id()), i18n("Enter schedule")) + QString("<img src=\"%1\" border=\"0\"></a>").arg(pathEnter) + linkend();
         if (!pathSkip.isEmpty())
           tmp += "&nbsp;" + link(VIEW_SCHEDULE, QString("?id=%1&amp;mode=skip").arg(sched.id()), i18n("Skip schedule")) + QString("<img src=\"%1\" border=\"0\"></a>").arg(pathSkip) + linkend();
 
         tmp += QString("&nbsp;");
         tmp += link(VIEW_SCHEDULE, QString("?id=%1&mode=edit").arg(sched.id()), i18n("Edit schedule")) + sched.name() + linkend();
 
         //show quantity of payments overdue if any
         if (cnt > 1)
           tmp += i18np(" (%1 payment)", " (%1 payments)", cnt);
 
         //show account of the main split
         tmp += "</td><td>";
         tmp += QString(file->account(acc.id()).name());
 
         //show amount of the schedule
         tmp += "</td><td align=\"right\">";
 
         const MyMoneySecurity& currency = MyMoneyFile::instance()->currency(acc.currencyId());
         MyMoneyMoney payment = MyMoneyMoney(sp.value(t.commodity(), acc.currencyId()) * cnt);
         QString amount = MyMoneyUtils::formatMoney(payment, acc, currency);
         amount.replace(QChar(' '), "&nbsp;");
         tmp += showColoredAmount(amount, payment.isNegative());
         tmp += "</td>";
         //show balance after payments
         tmp += "<td align=\"right\">";
         QDate paymentDate = QDate(sched.adjustedNextDueDate());
         MyMoneyMoney balanceAfter = forecastPaymentBalance(acc, payment, paymentDate);
         QString balance = MyMoneyUtils::formatMoney(balanceAfter, acc, currency);
         balance.replace(QChar(' '), "&nbsp;");
         tmp += showColoredAmount(balance, balanceAfter.isNegative());
         tmp += "</td>";
 
         // qDebug("paymentEntry = '%s'", tmp.toLatin1());
         d->m_html += tmp;
       }
     }
   } catch (const MyMoneyException &e) {
     qDebug("Unable to display schedule entry: %s", qPrintable(e.what()));
   }
 }
 
 void KHomeView::showAccounts(KHomeView::paymentTypeE type, const QString& header)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
   QList<MyMoneyAccount> accounts;
 
   bool showClosedAccounts = kmymoney->toggleAction("view_show_all_accounts")->isChecked();
 
   // get list of all accounts
   file->accountList(accounts);
   for (QList<MyMoneyAccount>::Iterator it = accounts.begin(); it != accounts.end();) {
     bool removeAccount = false;
     if (!(*it).isClosed() || showClosedAccounts) {
       switch ((*it).accountType()) {
         case MyMoneyAccount::Expense:
         case MyMoneyAccount::Income:
           // never show a category account
           // Note: This might be different in a future version when
           //       the homepage also shows category based information
           removeAccount = true;
           break;
 
           // Asset and Liability accounts are only shown if they
           // have the preferred flag set
         case MyMoneyAccount::Asset:
         case MyMoneyAccount::Liability:
         case MyMoneyAccount::Investment:
           // if preferred accounts are requested, then keep in list
           if ((*it).value("PreferredAccount") != "Yes"
               || (type & Preferred) == 0) {
             removeAccount = true;
           }
           break;
 
           // Check payment accounts. If payment and preferred is selected,
           // then always show them. If only payment is selected, then
           // show only if preferred flag is not set.
         case MyMoneyAccount::Checkings:
         case MyMoneyAccount::Savings:
         case MyMoneyAccount::Cash:
         case MyMoneyAccount::CreditCard:
           switch (type & (Payment | Preferred)) {
             case Payment:
               if ((*it).value("PreferredAccount") == "Yes")
                 removeAccount = true;
               break;
 
             case Preferred:
               if ((*it).value("PreferredAccount") != "Yes")
                 removeAccount = true;
               break;
 
             case Payment | Preferred:
               break;
 
             default:
               removeAccount = true;
               break;
           }
           break;
 
           // filter all accounts that are not used on homepage views
         default:
           removeAccount = true;
           break;
       }
 
     } else if ((*it).isClosed() || (*it).isInvest()) {
       // don't show if closed or a stock account
       removeAccount = true;
     }
 
     if (removeAccount)
       it = accounts.erase(it);
     else
       ++it;
   }
 
   if (!accounts.isEmpty()) {
     // sort the accounts by name
     qStableSort(accounts.begin(), accounts.end(), accountNameLess);
     QString tmp;
     int i = 0;
     tmp = "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + header + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
     d->m_html += tmp;
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     d->m_html += "<tr class=\"item\">";
 
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) {
       QString pathStatusHeader;
       KIconLoader::global()->loadIcon(QString("download"), KIconLoader::Small, KIconLoader::SizeSmall, KIconLoader::DefaultState, QStringList(), &pathStatusHeader);
       d->m_html += QString("<td class=\"center\"><img src=\"%1\" border=\"0\"></td>").arg(pathStatusHeader);
     }
 
     d->m_html += "<td class=\"left\" width=\"35%\">";
     d->m_html += i18n("Account");
     d->m_html += "</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions())
       d->m_html += QString("<td class=\"center\">!M</td>");
 
     if (KMyMoneyGlobalSettings::showCountOfClearedTransactions())
       d->m_html += QString("<td class=\"center\">C</td>");
 
     if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
       d->m_html += QString("<td class=\"center\">!R</td>");
 
     d->m_html += "<td width=\"25%\" class=\"right\">";
     d->m_html += i18n("Current Balance");
     d->m_html += "</td>";
 
     //only show limit info if user chose to do so
     if (KMyMoneyGlobalSettings::showLimitInfo()) {
       d->m_html += "<td width=\"40%\" class=\"right\">";
       d->m_html += i18n("To Minimum Balance / Maximum Credit");
       d->m_html += "</td>";
     }
     d->m_html += "</tr>";
 
     d->m_total = 0;
     QList<MyMoneyAccount>::const_iterator it_m;
     for (it_m = accounts.constBegin(); it_m != accounts.constEnd(); ++it_m) {
       d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
       showAccountEntry(*it_m);
       d->m_html += "</tr>";
     }
     d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
     QString amount = d->m_total.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) d->m_html += "<td></td>";
     d->m_html += QString("<td class=\"right\"><b>%1</b></td>").arg(i18n("Total"));
     if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions()) d->m_html += "<td></td>";
     if (KMyMoneyGlobalSettings::showCountOfClearedTransactions()) d->m_html += "<td></td>";
     if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions()) d->m_html += "<td></td>";
     d->m_html += QString("<td class=\"right\"><b>%1</b></td></tr>").arg(showColoredAmount(amount, d->m_total.isNegative()));
     d->m_html += "</table></div></div>";
   }
 }
 
 void KHomeView::showAccountEntry(const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneySecurity currency = file->currency(acc.currencyId());
   MyMoneyMoney value;
 
   bool showLimit = KMyMoneyGlobalSettings::showLimitInfo();
 
   if (acc.accountType() == MyMoneyAccount::Investment) {
     //investment accounts show the balances of all its subaccounts
     value = investmentBalance(acc);
 
     //investment accounts have no minimum balance
     showAccountEntry(acc, value, MyMoneyMoney(), showLimit);
   } else {
     //get balance for normal accounts
     value = file->balance(acc.id(), QDate::currentDate());
     if (acc.currencyId() != file->baseCurrency().id()) {
       ReportAccount repAcc = ReportAccount(acc.id());
       MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
       MyMoneyMoney baseValue = value * curPrice;
       baseValue = baseValue.convert(file->baseCurrency().smallestAccountFraction());
       d->m_total += baseValue;
     } else {
       d->m_total += value;
     }
     //if credit card or checkings account, show maximum credit
     if (acc.accountType() == MyMoneyAccount::CreditCard ||
         acc.accountType() == MyMoneyAccount::Checkings) {
       QString maximumCredit = acc.value("maxCreditAbsolute");
       if (maximumCredit.isEmpty()) {
         maximumCredit = acc.value("minBalanceAbsolute");
       }
       MyMoneyMoney maxCredit = MyMoneyMoney(maximumCredit);
       showAccountEntry(acc, value, value - maxCredit, showLimit);
     } else {
       //otherwise use minimum balance
       QString minimumBalance = acc.value("minBalanceAbsolute");
       MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
       showAccountEntry(acc, value, value - minBalance, showLimit);
     }
   }
 }
 
 void KHomeView::showAccountEntry(const MyMoneyAccount& acc, const MyMoneyMoney& value, const MyMoneyMoney& valueToMinBal, const bool showMinBal)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QString tmp;
   MyMoneySecurity currency = file->currency(acc.currencyId());
   QString amount;
   QString amountToMinBal;
 
   //format amounts
   amount = MyMoneyUtils::formatMoney(value, acc, currency);
   amount.replace(QChar(' '), "&nbsp;");
   if (showMinBal) {
     amountToMinBal = MyMoneyUtils::formatMoney(valueToMinBal, acc, currency);
     amountToMinBal.replace(QChar(' '), "&nbsp;");
   }
 
   QString cellStatus, cellCounts, pathOK, pathTODO, pathNotOK;
 
   if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) {
     //show account's online-status
     KIconLoader::global()->loadIcon(QString("dialog-ok-apply"), KIconLoader::Small, KIconLoader::SizeSmall, KIconLoader::DefaultState, QStringList(), &pathOK);
     KIconLoader::global()->loadIcon(QString("mail-receive"), KIconLoader::Small, KIconLoader::SizeSmall, KIconLoader::DefaultState, QStringList(), &pathTODO);
     KIconLoader::global()->loadIcon(QString("dialog-cancel"), KIconLoader::Small, KIconLoader::SizeSmall, KIconLoader::DefaultState, QStringList(), &pathNotOK);
 
     if (acc.value("lastImportedTransactionDate").isEmpty() || acc.value("lastStatementBalance").isEmpty())
       cellStatus = '-';
     else if (file->hasMatchingOnlineBalance(acc)) {
       if (file->hasNewerTransaction(acc.id(), QDate::fromString(acc.value("lastImportedTransactionDate"), Qt::ISODate)))
         cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathTODO);
       else
         cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathOK);
     } else
       cellStatus = QString("<img src=\"%1\" border=\"0\">").arg(pathNotOK);
 
     tmp = QString("<td class=\"center\">%1</td>").arg(cellStatus);
   }
 
   tmp += QString("<td>") +
          link(VIEW_LEDGER, QString("?id=%1").arg(acc.id())) + acc.name() + linkend() + "</td>";
 
   int countNotMarked = 0, countCleared = 0, countNotReconciled = 0;
   QString countStr;
 
   if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions() || KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
     countNotMarked = file->countTransactionsWithSpecificReconciliationState(acc.id(), MyMoneyTransactionFilter::notReconciled);
 
   if (KMyMoneyGlobalSettings::showCountOfClearedTransactions() || KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
     countCleared = file->countTransactionsWithSpecificReconciliationState(acc.id(), MyMoneyTransactionFilter::cleared);
 
   if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
     countNotReconciled = countNotMarked + countCleared;
 
   if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions()) {
     if (countNotMarked)
       countStr = QString("%1").arg(countNotMarked);
     else
       countStr = '-';
     tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
   }
 
   if (KMyMoneyGlobalSettings::showCountOfClearedTransactions()) {
     if (countCleared)
       countStr = QString("%1").arg(countCleared);
     else
       countStr = '-';
     tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
   }
 
   if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions()) {
     if (countNotReconciled)
       countStr = QString("%1").arg(countNotReconciled);
     else
       countStr = '-';
     tmp += QString("<td class=\"center\">%1</td>").arg(countStr);
   }
 
   //show account balance
   tmp += QString("<td class=\"right\">%1</td>").arg(showColoredAmount(amount, value.isNegative()));
 
   //show minimum balance column if requested
   if (showMinBal) {
     //if it is an investment, show minimum balance empty
     if (acc.accountType() == MyMoneyAccount::Investment) {
       tmp += QString("<td class=\"right\">&nbsp;</td>");
     } else {
       //show minimum balance entry
       tmp += QString("<td class=\"right\">%1</td>").arg(showColoredAmount(amountToMinBal, valueToMinBal.isNegative()));
     }
   }
   // qDebug("accountEntry = '%s'", tmp.toLatin1());
   d->m_html += tmp;
 }
 
 MyMoneyMoney KHomeView::investmentBalance(const MyMoneyAccount& acc)
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   MyMoneyMoney value;
   value = file->balance(acc.id(), QDate::currentDate());
   QList<QString>::const_iterator it_a;
   for (it_a = acc.accountList().begin(); it_a != acc.accountList().end(); ++it_a) {
     MyMoneyAccount stock = file->account(*it_a);
     if (!stock.isClosed()) {
       try {
         MyMoneyMoney val;
         MyMoneyMoney balance = file->balance(stock.id(), QDate::currentDate());
         MyMoneySecurity security = file->security(stock.currencyId());
         const MyMoneyPrice &price = file->price(stock.currencyId(), security.tradingCurrency());
         val = (balance * price.rate(security.tradingCurrency())).convert(MyMoneyMoney::precToDenom(KMyMoneyGlobalSettings::pricePrecision()));
         // adjust value of security to the currency of the account
         MyMoneySecurity accountCurrency = file->currency(acc.currencyId());
         val = val * file->price(security.tradingCurrency(), accountCurrency.id()).rate(accountCurrency.id());
         val = val.convert(acc.fraction());
         value += val;
       } catch (const MyMoneyException &e) {
         qWarning("%s", qPrintable(QString("cannot convert stock balance of %1 to base currency: %2").arg(stock.name(), e.what())));
       }
     }
   }
   return value;
 }
 
 void KHomeView::showFavoriteReports()
 {
   QList<MyMoneyReport> reports = MyMoneyFile::instance()->reportList();
 
   if (!reports.isEmpty()) {
     bool firstTime = 1;
     int row = 0;
     QList<MyMoneyReport>::const_iterator it_report = reports.constBegin();
     while (it_report != reports.constEnd()) {
       if ((*it_report).isFavorite()) {
         if (firstTime) {
           d->m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("Favorite Reports"));
           d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
           d->m_html += "<tr class=\"item\"><td class=\"left\" width=\"40%\">";
           d->m_html += i18n("Report");
           d->m_html += "</td><td width=\"60%\" class=\"left\">";
           d->m_html += i18n("Comment");
           d->m_html += "</td></tr>";
           firstTime = false;
         }
 
         d->m_html += QString("<tr class=\"row-%1\"><td>%2%3%4</td><td align=\"left\">%5</td></tr>")
                      .arg(row++ & 0x01 ? "even" : "odd")
                      .arg(link(VIEW_REPORTS, QString("?id=%1").arg((*it_report).id())))
                      .arg((*it_report).name())
                      .arg(linkend())
                      .arg((*it_report).comment());
       }
 
       ++it_report;
     }
     if (!firstTime)
       d->m_html += "</table></div></div>";
   }
 }
 
 void KHomeView::showForecast()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
   QList<MyMoneyAccount> accList;
 
   //if forecast has not been executed yet, do it.
   if (!d->m_forecast.isForecastDone())
     doForecast();
 
   accList = d->m_forecast.accountList();
 
   if (accList.count() > 0) {
     // sort the accounts by name
     qStableSort(accList.begin(), accList.end(), accountNameLess);
     int i = 0;
 
     int colspan = 1;
     //get begin day
     int beginDay = QDate::currentDate().daysTo(d->m_forecast.beginForecastDate());
     //if begin day is today skip to next cycle
     if (beginDay == 0)
       beginDay = d->m_forecast.accountsCycle();
 
     // Now output header
     d->m_html += QString("<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">%1</div>\n<div class=\"gap\">&nbsp;</div>\n").arg(i18n("%1 Day Forecast", d->m_forecast.forecastDays()));
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     d->m_html += "<tr class=\"item\"><td class=\"left\" width=\"40%\">";
     d->m_html += i18n("Account");
     d->m_html += "</td>";
     int colWidth = 55 / (d->m_forecast.forecastDays() / d->m_forecast.accountsCycle());
     for (i = 0; (i*d->m_forecast.accountsCycle() + beginDay) <= d->m_forecast.forecastDays(); ++i) {
       d->m_html += QString("<td width=\"%1%\" class=\"right\">").arg(colWidth);
 
       d->m_html += i18ncp("Forecast days", "%1 day", "%1 days", i * d->m_forecast.accountsCycle() + beginDay);
       d->m_html += "</td>";
       colspan++;
     }
     d->m_html += "</tr>";
 
     // Now output entries
     i = 0;
 
     QList<MyMoneyAccount>::ConstIterator it_account;
     for (it_account = accList.constBegin(); it_account != accList.constEnd(); ++it_account) {
       //MyMoneyAccount acc = (*it_n);
 
       d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
       d->m_html += QString("<td width=\"40%\">") +
                    link(VIEW_LEDGER, QString("?id=%1").arg((*it_account).id())) + (*it_account).name() + linkend() + "</td>";
 
       int dropZero = -1; //account dropped below zero
       int dropMinimum = -1; //account dropped below minimum balance
       QString minimumBalance = (*it_account).value("minimumBalance");
       MyMoneyMoney minBalance = MyMoneyMoney(minimumBalance);
       MyMoneySecurity currency;
       MyMoneyMoney forecastBalance;
 
       //change account to deep currency if account is an investment
       if ((*it_account).isInvest()) {
         MyMoneySecurity underSecurity = file->security((*it_account).currencyId());
         currency = file->security(underSecurity.tradingCurrency());
       } else {
         currency = file->security((*it_account).currencyId());
       }
 
       for (int f = beginDay; f <= d->m_forecast.forecastDays(); f += d->m_forecast.accountsCycle()) {
         forecastBalance = d->m_forecast.forecastBalance(*it_account, QDate::currentDate().addDays(f));
         QString amount;
         amount = MyMoneyUtils::formatMoney(forecastBalance, *it_account, currency);
         amount.replace(QChar(' '), "&nbsp;");
         d->m_html += QString("<td width=\"%1%\" align=\"right\">").arg(colWidth);
         d->m_html += QString("%1</td>").arg(showColoredAmount(amount, forecastBalance.isNegative()));
       }
 
       d->m_html += "</tr>";
 
       //Check if the account is going to be below zero or below the minimal balance in the forecast period
 
       //Check if the account is going to be below minimal balance
       dropMinimum = d->m_forecast.daysToMinimumBalance(*it_account);
 
       //Check if the account is going to be below zero in the future
       dropZero = d->m_forecast.daysToZeroBalance(*it_account);
 
 
       // spit out possible warnings
       QString msg;
 
       // if a minimum balance has been specified, an appropriate warning will
       // only be shown, if the drop below 0 is on a different day or not present
 
       if (dropMinimum != -1
           && !minBalance.isZero()
           && (dropMinimum < dropZero
               || dropZero == -1)) {
         switch (dropMinimum) {
           case -1:
             break;
           case 0:
             msg = i18n("The balance of %1 is below the minimum balance %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(minBalance, *it_account, currency));
             msg = showColoredAmount(msg, true);
             break;
           default:
             msg = i18np("The balance of %2 will drop below the minimum balance %3 in %1 day.",
                         "The balance of %2 will drop below the minimum balance %3 in %1 days.",
                         dropMinimum - 1, (*it_account).name(), MyMoneyUtils::formatMoney(minBalance, *it_account, currency));
             msg = showColoredAmount(msg, true);
             break;
         }
 
         if (!msg.isEmpty()) {
           d->m_html += QString("<tr class=\"warning\" style=\"font-weight: normal;\" ><td colspan=%2 align=\"center\" >%1</td></tr>").arg(msg).arg(colspan);
         }
       }
       // a drop below zero is always shown
       msg.clear();
       switch (dropZero) {
         case -1:
           break;
         case 0:
           if ((*it_account).accountGroup() == MyMoneyAccount::Asset) {
             msg = i18n("The balance of %1 is below %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
             msg = showColoredAmount(msg, true);
             break;
           }
           if ((*it_account).accountGroup() == MyMoneyAccount::Liability) {
             msg = i18n("The balance of %1 is above %2 today.", (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
             break;
           }
           break;
         default:
           if ((*it_account).accountGroup() == MyMoneyAccount::Asset) {
             msg = i18np("The balance of %2 will drop below %3 in %1 day.",
                         "The balance of %2 will drop below %3 in %1 days.",
                         dropZero, (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
             msg = showColoredAmount(msg, true);
             break;
           }
           if ((*it_account).accountGroup() == MyMoneyAccount::Liability) {
             msg = i18np("The balance of %2 will raise above %3 in %1 day.",
                         "The balance of %2 will raise above %3 in %1 days.",
                         dropZero, (*it_account).name(), MyMoneyUtils::formatMoney(MyMoneyMoney(), *it_account, currency));
             break;
           }
       }
       if (!msg.isEmpty()) {
         d->m_html += QString("<tr class=\"warning\"><td colspan=%2 align=\"center\" ><b>%1</b></td></tr>").arg(msg).arg(colspan);
       }
     }
     d->m_html += "</table></div></div>";
 
   }
 }
 
 const QString KHomeView::link(const QString& view, const QString& query, const QString& _title) const
 {
   QString titlePart;
   QString title(_title);
   if (!title.isEmpty())
     titlePart = QString(" title=\"%1\"").arg(title.replace(QChar(' '), "&nbsp;"));
 
   return QString("<a href=\"/%1%2\"%3>").arg(view, query, titlePart);
 }
 
 const QString KHomeView::linkend() const
 {
   return "</a>";
 }
 
 void KHomeView::slotOpenUrl(const KUrl &url, const KParts::OpenUrlArguments&, const KParts::BrowserArguments&)
 {
   QString protocol = url.protocol();
   QString view = url.fileName();
   QString id = url.queryItem("id");
   QString mode = url.queryItem("mode");
 
   if (protocol == "http") {
     KToolInvocation::invokeBrowser(url.prettyUrl());
   } else if (protocol == "mailto") {
     KToolInvocation::invokeMailer(url);
   } else {
     KXmlGuiWindow* mw = KMyMoneyUtils::mainWindow();
     Q_CHECK_PTR(mw);
     if (view == VIEW_LEDGER) {
       emit ledgerSelected(id, QString());
 
     } else if (view == VIEW_SCHEDULE) {
       if (mode == "enter") {
         emit scheduleSelected(id);
         QTimer::singleShot(0, mw->actionCollection()->action("schedule_enter"), SLOT(trigger()));
       } else if (mode == "edit") {
         emit scheduleSelected(id);
         QTimer::singleShot(0, mw->actionCollection()->action("schedule_edit"), SLOT(trigger()));
       } else if (mode == "skip") {
         emit scheduleSelected(id);
         QTimer::singleShot(0, mw->actionCollection()->action("schedule_skip"), SLOT(trigger()));
       } else if (mode == "full") {
         d->m_showAllSchedules = true;
         loadView();
 
       } else if (mode == "reduced") {
         d->m_showAllSchedules = false;
         loadView();
       }
 
     } else if (view == VIEW_REPORTS) {
       emit reportSelected(id);
 
     } else if (view == VIEW_WELCOME) {
       if (mode == "whatsnew") {
         d->m_part->begin();
         d->m_part->write(KWelcomePage::whatsNewPage());
         d->m_part->end();
       } else {
         d->m_part->begin();
         d->m_part->write(KWelcomePage::welcomePage());
         d->m_part->end();
       }
 
     } else if (view == "action") {
       QTimer::singleShot(0, mw->actionCollection()->action(id), SLOT(trigger()));
     } else if (view == VIEW_HOME) {
       QList<MyMoneyAccount> list;
       MyMoneyFile::instance()->accountList(list);
       if (list.count() == 0) {
         KMessageBox::information(this, i18n("Before KMyMoney can give you detailed information about your financial status, you need to create at least one account. Until then, KMyMoney shows the welcome page instead."));
       }
       loadView();
 
     } else {
       qDebug("Unknown view '%s' in KHomeView::slotOpenURL()", qPrintable(view));
     }
   }
 }
 
 void KHomeView::showAssetsLiabilities()
 {
   QList<MyMoneyAccount> accounts;
   QList<MyMoneyAccount>::ConstIterator it;
   QList<MyMoneyAccount> assets;
   QList<MyMoneyAccount> liabilities;
   MyMoneyMoney netAssets;
   MyMoneyMoney netLiabilities;
   QString fontStart, fontEnd;
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
   int i = 0;
 
   // get list of all accounts
   file->accountList(accounts);
 
   for (it = accounts.constBegin(); it != accounts.constEnd();) {
     if (!(*it).isClosed()) {
       switch ((*it).accountType()) {
           // group all assets into one list but make sure that investment accounts always show up
         case MyMoneyAccount::Investment:
           assets << *it;
           break;
 
         case MyMoneyAccount::Checkings:
         case MyMoneyAccount::Savings:
         case MyMoneyAccount::Cash:
         case MyMoneyAccount::Asset:
         case MyMoneyAccount::AssetLoan:
           // list account if it's the last in the hierarchy or has transactions in it
           if ((*it).accountList().isEmpty() || (file->transactionCount((*it).id()) > 0)) {
             assets << *it;
           }
           break;
 
           // group the liabilities into the other
         case MyMoneyAccount::CreditCard:
         case MyMoneyAccount::Liability:
         case MyMoneyAccount::Loan:
           // list account if it's the last in the hierarchy or has transactions in it
           if ((*it).accountList().isEmpty() || (file->transactionCount((*it).id()) > 0)) {
             liabilities << *it;
           }
           break;
 
         default:
           break;
       }
     }
     ++it;
   }
 
   //only do it if we have assets or liabilities account
   if (assets.count() > 0 || liabilities.count() > 0) {
     // sort the accounts by name
     qStableSort(assets.begin(), assets.end(), accountNameLess);
     qStableSort(liabilities.begin(), liabilities.end(), accountNameLess);
     QString statusHeader;
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) {
       QString pathStatusHeader;
       KIconLoader::global()->loadIcon(QString("online-banking"), KIconLoader::Small, KIconLoader::SizeSmall, KIconLoader::DefaultState, QStringList(), &pathStatusHeader);
       statusHeader = QString("<img src=\"%1\" border=\"0\">").arg(pathStatusHeader);
     }
 
     //print header
     d->m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Assets and Liabilities Summary") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
 
     //column titles
 
     d->m_html += "<tr class=\"item\">";
 
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) {
       d->m_html += "<td class=\"setcolor\">";
       d->m_html += statusHeader;
       d->m_html += "</td>";
     }
 
     d->m_html += "<td class=\"left\" width=\"30%\">";
     d->m_html += i18n("Asset Accounts");
     d->m_html += "</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions())
       d->m_html += "<td class=\"setcolor\">!M</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfClearedTransactions())
       d->m_html += "<td class=\"setcolor\">C</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
       d->m_html += "<td class=\"setcolor\">!R</td>";
 
     d->m_html += "<td width=\"15%\" class=\"right\">";
     d->m_html += i18n("Current Balance");
     d->m_html += "</td>";
 
     //intermediate row to separate both columns
     d->m_html += "<td width=\"10%\" class=\"setcolor\"></td>";
 
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) {
       d->m_html += "<td class=\"setcolor\">";
       d->m_html += statusHeader;
       d->m_html += "</td>";
     }
 
     d->m_html += "<td class=\"left\" width=\"30%\">";
     d->m_html += i18n("Liability Accounts");
     d->m_html += "</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions())
       d->m_html += "<td class=\"setcolor\">!M</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfClearedTransactions())
       d->m_html += "<td class=\"setcolor\">C</td>";
 
     if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions())
       d->m_html += "<td class=\"setcolor\">!R</td>";
 
     d->m_html += "<td width=\"15%\" class=\"right\">";
     d->m_html += i18n("Current Balance");
     d->m_html += "</td></tr>";
 
     QString placeHolder_Status, placeHolder_Counts;
     if (KMyMoneyGlobalSettings::showBalanceStatusOfOnlineAccounts()) placeHolder_Status = "<td></td>";
     if (KMyMoneyGlobalSettings::showCountOfUnmarkedTransactions()) placeHolder_Counts = "<td></td>";
     if (KMyMoneyGlobalSettings::showCountOfClearedTransactions()) placeHolder_Counts += "<td></td>";
     if (KMyMoneyGlobalSettings::showCountOfNotReconciledTransactions()) placeHolder_Counts += "<td></td>";
 
     //get asset and liability accounts
     QList<MyMoneyAccount>::const_iterator asset_it = assets.constBegin();
     QList<MyMoneyAccount>::const_iterator liabilities_it = liabilities.constBegin();
     for (; asset_it != assets.constEnd() || liabilities_it != liabilities.constEnd();) {
       d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
       //write an asset account if we still have any
       if (asset_it != assets.constEnd()) {
         MyMoneyMoney value;
         //investment accounts consolidate the balance of its subaccounts
         if ((*asset_it).accountType() == MyMoneyAccount::Investment) {
           value = investmentBalance(*asset_it);
         } else {
           value = MyMoneyFile::instance()->balance((*asset_it).id(), QDate::currentDate());
         }
 
         //calculate balance for foreign currency accounts
         if ((*asset_it).currencyId() != file->baseCurrency().id()) {
           ReportAccount repAcc = ReportAccount((*asset_it).id());
           MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
           MyMoneyMoney baseValue = value * curPrice;
           baseValue = baseValue.convert(10000);
           netAssets += baseValue;
         } else {
           netAssets += value;
         }
         //show the account without minimum balance
         showAccountEntry(*asset_it, value, MyMoneyMoney(), false);
         ++asset_it;
       } else {
         //write a white space if we don't
         d->m_html += QString("%1<td></td>%2<td></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
       }
 
       //leave the intermediate column empty
       d->m_html += "<td class=\"setcolor\"></td>";
 
       //write a liability account
       if (liabilities_it != liabilities.constEnd()) {
         MyMoneyMoney value;
         value = MyMoneyFile::instance()->balance((*liabilities_it).id(), QDate::currentDate());
         //calculate balance if foreign currency
         if ((*liabilities_it).currencyId() != file->baseCurrency().id()) {
           ReportAccount repAcc = ReportAccount((*liabilities_it).id());
           MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
           MyMoneyMoney baseValue = value * curPrice;
           baseValue = baseValue.convert(10000);
           netLiabilities += baseValue;
         } else {
           netLiabilities += value;
         }
         //show the account without minimum balance
         showAccountEntry(*liabilities_it, value, MyMoneyMoney(), false);
         ++liabilities_it;
       } else {
         //leave the space empty if we run out of liabilities
         d->m_html += QString("%1<td></td>%2<td></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
       }
       d->m_html += "</tr>";
     }
 
     //calculate net worth
     MyMoneyMoney netWorth = netAssets + netLiabilities;
 
     //format assets, liabilities and net worth
     QString amountAssets = netAssets.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountLiabilities = netLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString amountNetWorth = netWorth.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     amountAssets.replace(QChar(' '), "&nbsp;");
     amountLiabilities.replace(QChar(' '), "&nbsp;");
     amountNetWorth.replace(QChar(' '), "&nbsp;");
 
     d->m_html += QString("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(i++ & 0x01 ? "even" : "odd");
 
     //print total for assets
     d->m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Total Assets")).arg(placeHolder_Counts).arg(showColoredAmount(amountAssets, netAssets.isNegative()));
 
     //leave the intermediate column empty
     d->m_html += "<td class=\"setcolor\"></td>";
 
     //print total liabilities
     d->m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Total Liabilities")).arg(placeHolder_Counts).arg(showColoredAmount(amountLiabilities, netLiabilities.isNegative()));
     d->m_html += "</tr>";
 
     //print net worth
     d->m_html += QString("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(i++ & 0x01 ? "even" : "odd");
 
     d->m_html += QString("%1<td></td><td></td>%2<td class=\"setcolor\"></td>").arg(placeHolder_Status).arg(placeHolder_Counts);
     d->m_html += QString("%1<td class=\"left\">%2</td>%3<td align=\"right\">%4</td>").arg(placeHolder_Status).arg(i18n("Net Worth")).arg(placeHolder_Counts).arg(showColoredAmount(amountNetWorth, netWorth.isNegative()));
 
     d->m_html += "</tr>";
     d->m_html += "</table>";
     d->m_html += "</div></div>";
   }
 }
 
 void KHomeView::showBudget()
 {
   MyMoneyFile* file = MyMoneyFile::instance();
 
   if (file->countBudgets()) {
     int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
     bool isOverrun = false;
     int i = 0;
 
     //config report just like "Monthly Budgeted vs Actual
     MyMoneyReport reportCfg = MyMoneyReport(
                                 MyMoneyReport::eBudgetActual,
-                                MyMoneyReport::eMonths,
+                                MyMoneyReport::Column::Months,
                                 MyMoneyTransactionFilter::currentMonth,
                                 MyMoneyReport::eDetailAll,
                                 i18n("Monthly Budgeted vs. Actual"),
                                 i18n("Generated Report"));
 
     reportCfg.setBudget("Any", true);
 
     reports::PivotTable table(reportCfg);
 
     PivotGrid grid = table.grid();
 
     //div header
     d->m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Budget") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
 
     //display budget summary
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     d->m_html += "<tr class=\"itemtitle\">";
     d->m_html += "<td class=\"left\" colspan=\"3\">";
     d->m_html += i18n("Current Month Summary");
     d->m_html += "</td></tr>";
     d->m_html += "<tr class=\"item\">";
     d->m_html += "<td class=\"right\" width=\"50%\">";
     d->m_html += i18n("Budgeted");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"20%\">";
     d->m_html += i18n("Actual");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"20%\">";
     d->m_html += i18n("Difference");
     d->m_html += "</td></tr>";
 
     d->m_html += QString("<tr class=\"row-odd\">");
 
     MyMoneyMoney totalBudgetValue = grid.m_total[eBudget].m_total;
     MyMoneyMoney totalActualValue = grid.m_total[eActual].m_total;
     MyMoneyMoney totalBudgetDiffValue = grid.m_total[eBudgetDiff].m_total;
 
     QString totalBudgetAmount = totalBudgetValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString totalActualAmount = totalActualValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
     QString totalBudgetDiffAmount = totalBudgetDiffValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
     d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalBudgetAmount, totalBudgetValue.isNegative()));
     d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalActualAmount, totalActualValue.isNegative()));
     d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(totalBudgetDiffAmount, totalBudgetDiffValue.isNegative()));
     d->m_html += "</tr>";
     d->m_html += "</table>";
 
     //budget overrun
     d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
     d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
     d->m_html += "<tr class=\"itemtitle\">";
     d->m_html += "<td class=\"left\" colspan=\"4\">";
     d->m_html += i18n("Budget Overruns");
     d->m_html += "</td></tr>";
     d->m_html += "<tr class=\"item\">";
     d->m_html += "<td class=\"left\" width=\"30%\">";
     d->m_html += i18n("Account");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"20%\">";
     d->m_html += i18n("Budgeted");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"20%\">";
     d->m_html += i18n("Actual");
     d->m_html += "</td>";
     d->m_html += "<td class=\"right\" width=\"20%\">";
     d->m_html += i18n("Difference");
     d->m_html += "</td></tr>";
 
 
     PivotGrid::iterator it_outergroup = grid.begin();
     while (it_outergroup != grid.end()) {
       i = 0;
       PivotOuterGroup::iterator it_innergroup = (*it_outergroup).begin();
       while (it_innergroup != (*it_outergroup).end()) {
         PivotInnerGroup::iterator it_row = (*it_innergroup).begin();
         while (it_row != (*it_innergroup).end()) {
           //column number is 1 because the report includes only current month
           if (it_row.value()[eBudgetDiff][1].isNegative()) {
             //get report account to get the name later
             ReportAccount rowname = it_row.key();
 
             //write the outergroup if it is the first row of outergroup being shown
             if (i == 0) {
               d->m_html += "<tr style=\"font-weight:bold;\">";
               d->m_html += QString("<td class=\"left\" colspan=\"4\">%1</td>").arg(KMyMoneyUtils::accountTypeToString(rowname.accountType()));
               d->m_html += "</tr>";
             }
             d->m_html += QString("<tr class=\"row-%1\">").arg(i++ & 0x01 ? "even" : "odd");
 
             //get values from grid
             MyMoneyMoney actualValue = it_row.value()[eActual][1];
             MyMoneyMoney budgetValue = it_row.value()[eBudget][1];
             MyMoneyMoney budgetDiffValue = it_row.value()[eBudgetDiff][1];
 
             //format amounts
             QString actualAmount = actualValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
             QString budgetAmount = budgetValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
             QString budgetDiffAmount = budgetDiffValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
             //account name
             d->m_html += QString("<td>") + link(VIEW_LEDGER, QString("?id=%1").arg(rowname.id())) + rowname.name() + linkend() + "</td>";
 
             //show amounts
             d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(budgetAmount, budgetValue.isNegative()));
             d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(actualAmount, actualValue.isNegative()));
             d->m_html += QString("<td align=\"right\">%1</td>").arg(showColoredAmount(budgetDiffAmount, budgetDiffValue.isNegative()));
             d->m_html += "</tr>";
 
             //set the flag that there are overruns
             isOverrun = true;
           }
           ++it_row;
         }
         ++it_innergroup;
       }
       ++it_outergroup;
     }
 
     //if no negative differences are found, then inform that
     if (!isOverrun) {
       d->m_html += QString("<tr class=\"row-%1\" style=\"font-weight:bold;\">").arg(i++ & 0x01 ? "even" : "odd");
       d->m_html += QString("<td class=\"center\" colspan=\"4\">%1</td>").arg(i18n("No Budget Categories have been overrun"));
       d->m_html += "</tr>";
     }
     d->m_html += "</table></div></div>";
   }
 }
 
 QString KHomeView::showColoredAmount(const QString& amount, bool isNegative)
 {
   if (isNegative) {
     //if negative, get the settings for negative numbers
     return QString("<font color=\"%1\">%2</font>").arg(KMyMoneyGlobalSettings::listNegativeValueColor().name(), amount);
   }
 
   //if positive, return the same string
   return amount;
 }
 
 void KHomeView::doForecast()
 {
   //clear m_accountList because forecast is about to changed
   d->m_accountList.clear();
 
   //reinitialize the object
   d->m_forecast = KMyMoneyGlobalSettings::forecast();
 
   //If forecastDays lower than accountsCycle, adjust to the first cycle
   if (d->m_forecast.accountsCycle() > d->m_forecast.forecastDays())
     d->m_forecast.setForecastDays(d->m_forecast.accountsCycle());
 
   //Get all accounts of the right type to calculate forecast
   d->m_forecast.doForecast();
 }
 
 MyMoneyMoney KHomeView::forecastPaymentBalance(const MyMoneyAccount& acc, const MyMoneyMoney& payment, QDate& paymentDate)
 {
   //if paymentDate before or equal to currentDate set it to current date plus 1
   //so we get to accumulate forecast balance correctly
   if (paymentDate <= QDate::currentDate())
     paymentDate = QDate::currentDate().addDays(1);
 
   //check if the account is already there
   if (d->m_accountList.find(acc.id()) == d->m_accountList.end()
       || d->m_accountList[acc.id()].find(paymentDate) == d->m_accountList[acc.id()].end()) {
     if (paymentDate == QDate::currentDate()) {
       d->m_accountList[acc.id()][paymentDate] = d->m_forecast.forecastBalance(acc, paymentDate);
     } else {
       d->m_accountList[acc.id()][paymentDate] = d->m_forecast.forecastBalance(acc, paymentDate.addDays(-1));
     }
   }
   d->m_accountList[acc.id()][paymentDate] = d->m_accountList[acc.id()][paymentDate] + payment;
   return d->m_accountList[acc.id()][paymentDate];
 }
 
 void KHomeView::showCashFlowSummary()
 {
   MyMoneyTransactionFilter filter;
   MyMoneyMoney incomeValue;
   MyMoneyMoney expenseValue;
 
   MyMoneyFile* file = MyMoneyFile::instance();
   int prec = MyMoneyMoney::denomToPrec(file->baseCurrency().smallestAccountFraction());
 
   //set start and end of month dates
   QDate startOfMonth = QDate(QDate::currentDate().year(), QDate::currentDate().month(), 1);
   QDate endOfMonth = QDate(QDate::currentDate().year(), QDate::currentDate().month(), QDate::currentDate().daysInMonth());
 
   //Add total income and expenses for this month
   //get transactions for current month
   filter.setDateFilter(startOfMonth, endOfMonth);
   filter.setReportAllSplits(false);
 
   QList<MyMoneyTransaction> transactions = file->transactionList(filter);
   //if no transaction then skip and print total in zero
   if (transactions.size() > 0) {
     QList<MyMoneyTransaction>::const_iterator it_transaction;
 
     //get all transactions for this month
     for (it_transaction = transactions.constBegin(); it_transaction != transactions.constEnd(); ++it_transaction) {
 
       //get the splits for each transaction
       const QList<MyMoneySplit>& splits = (*it_transaction).splits();
       QList<MyMoneySplit>::const_iterator it_split;
       for (it_split = splits.begin(); it_split != splits.end(); ++it_split) {
         if (!(*it_split).shares().isZero()) {
           ReportAccount repSplitAcc = ReportAccount((*it_split).accountId());
 
           //only add if it is an income or expense
           if (repSplitAcc.isIncomeExpense()) {
             MyMoneyMoney value;
 
             //convert to base currency if necessary
             if (repSplitAcc.currencyId() != file->baseCurrency().id()) {
               MyMoneyMoney curPrice = repSplitAcc.baseCurrencyPrice((*it_transaction).postDate());
               value = ((*it_split).shares() * MyMoneyMoney::MINUS_ONE) * curPrice;
               value = value.convert(10000);
             } else {
               value = ((*it_split).shares() * MyMoneyMoney::MINUS_ONE);
             }
 
             //store depending on account type
             if (repSplitAcc.accountType() == MyMoneyAccount::Income) {
               incomeValue += value;
             } else {
               expenseValue += value;
             }
           }
         }
       }
     }
   }
 
   //format income and expenses
   QString amountIncome = incomeValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountExpense = expenseValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   amountIncome.replace(QChar(' '), "&nbsp;");
   amountExpense.replace(QChar(' '), "&nbsp;");
 
   //calculate schedules
 
   //Add all schedules for this month
   MyMoneyMoney scheduledIncome;
   MyMoneyMoney scheduledExpense;
   MyMoneyMoney scheduledLiquidTransfer;
   MyMoneyMoney scheduledOtherTransfer;
 
   //get overdues and schedules until the end of this month
   QList<MyMoneySchedule> schedule = file->scheduleList("", MyMoneySchedule::TYPE_ANY,
                                     MyMoneySchedule::OCCUR_ANY,
                                     MyMoneySchedule::STYPE_ANY,
                                     QDate(),
                                     endOfMonth);
 
   //Remove the finished schedules
   QList<MyMoneySchedule>::Iterator finished_it;
   for (finished_it = schedule.begin(); finished_it != schedule.end();) {
     if ((*finished_it).isFinished()) {
       finished_it = schedule.erase(finished_it);
       continue;
     }
     ++finished_it;
   }
 
   //add income and expenses
   QList<MyMoneySchedule>::Iterator sched_it;
   for (sched_it = schedule.begin(); sched_it != schedule.end();) {
     QDate nextDate = (*sched_it).nextDueDate();
     int cnt = 0;
 
     while (nextDate.isValid() && nextDate <= endOfMonth) {
       ++cnt;
       nextDate = (*sched_it).nextPayment(nextDate);
       // for single occurrence nextDate will not change, so we
       // better get out of here.
       if ((*sched_it).occurrence() == MyMoneySchedule::OCCUR_ONCE)
         break;
     }
 
     MyMoneyAccount acc = (*sched_it).account();
     if (!acc.id().isEmpty()) {
       MyMoneyTransaction transaction = (*sched_it).transaction();
       // only show the entry, if it is still active
 
       MyMoneySplit sp = transaction.splitByAccount(acc.id(), true);
 
       // take care of the autoCalc stuff
       if ((*sched_it).type() == MyMoneySchedule::TYPE_LOANPAYMENT) {
         QDate nextDate = (*sched_it).nextPayment((*sched_it).lastPayment());
 
         //make sure we have all 'starting balances' so that the autocalc works
         QList<MyMoneySplit>::const_iterator it_s;
         QMap<QString, MyMoneyMoney> balanceMap;
 
         for (it_s = transaction.splits().constBegin(); it_s != transaction.splits().constEnd(); ++it_s) {
           MyMoneyAccount acc = file->account((*it_s).accountId());
           // collect all overdues on the first day
           QDate schedDate = nextDate;
           if (QDate::currentDate() >= nextDate)
             schedDate = QDate::currentDate().addDays(1);
 
           balanceMap[acc.id()] += file->balance(acc.id(), QDate::currentDate());
         }
         KMyMoneyUtils::calculateAutoLoan(*sched_it, transaction, balanceMap);
       }
 
       //go through the splits and assign to liquid or other transfers
       const QList<MyMoneySplit> splits = transaction.splits();
       QList<MyMoneySplit>::const_iterator split_it;
       for (split_it = splits.constBegin(); split_it != splits.constEnd(); ++split_it) {
         if ((*split_it).accountId() != acc.id()) {
           ReportAccount repSplitAcc = ReportAccount((*split_it).accountId());
 
           //get the shares and multiply by the quantity of occurrences in the period
           MyMoneyMoney value = (*split_it).shares() * cnt;
 
           //convert to foreign currency if needed
           if (repSplitAcc.currencyId() != file->baseCurrency().id()) {
             MyMoneyMoney curPrice = repSplitAcc.baseCurrencyPrice(QDate::currentDate());
             value = value * curPrice;
             value = value.convert(10000);
           }
 
           if ((repSplitAcc.isLiquidLiability()
                || repSplitAcc.isLiquidAsset())
               && acc.accountGroup() != repSplitAcc.accountGroup()) {
             scheduledLiquidTransfer += value;
           } else if (repSplitAcc.isAssetLiability()
                      && !repSplitAcc.isLiquidLiability()
                      && !repSplitAcc.isLiquidAsset()) {
             scheduledOtherTransfer += value;
           } else if (repSplitAcc.isIncomeExpense()) {
             //income and expenses are stored as negative values
             if (repSplitAcc.accountType() == MyMoneyAccount::Income)
               scheduledIncome -= value;
             if (repSplitAcc.accountType() == MyMoneyAccount::Expense)
               scheduledExpense -= value;
           }
         }
       }
     }
     ++sched_it;
   }
 
   //format the currency strings
   QString amountScheduledIncome = scheduledIncome.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountScheduledExpense = scheduledExpense.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountScheduledLiquidTransfer = scheduledLiquidTransfer.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountScheduledOtherTransfer = scheduledOtherTransfer.formatMoney(file->baseCurrency().tradingSymbol(), prec);
 
   amountScheduledIncome.replace(QChar(' '), "&nbsp;");
   amountScheduledExpense.replace(QChar(' '), "&nbsp;");
   amountScheduledLiquidTransfer.replace(QChar(' '), "&nbsp;");
   amountScheduledOtherTransfer.replace(QChar(' '), "&nbsp;");
 
   //get liquid assets and liabilities
   QList<MyMoneyAccount> accounts;
   QList<MyMoneyAccount>::const_iterator account_it;
   MyMoneyMoney liquidAssets;
   MyMoneyMoney liquidLiabilities;
 
   // get list of all accounts
   file->accountList(accounts);
   for (account_it = accounts.constBegin(); account_it != accounts.constEnd();) {
     if (!(*account_it).isClosed()) {
       switch ((*account_it).accountType()) {
           //group all assets into one list
         case MyMoneyAccount::Checkings:
         case MyMoneyAccount::Savings:
         case MyMoneyAccount::Cash: {
             MyMoneyMoney value = MyMoneyFile::instance()->balance((*account_it).id(), QDate::currentDate());
             //calculate balance for foreign currency accounts
             if ((*account_it).currencyId() != file->baseCurrency().id()) {
               ReportAccount repAcc = ReportAccount((*account_it).id());
               MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
               MyMoneyMoney baseValue = value * curPrice;
               liquidAssets += baseValue;
               liquidAssets = liquidAssets.convert(10000);
             } else {
               liquidAssets += value;
             }
             break;
           }
           //group the liabilities into the other
         case MyMoneyAccount::CreditCard: {
             MyMoneyMoney value;
             value = MyMoneyFile::instance()->balance((*account_it).id(), QDate::currentDate());
             //calculate balance if foreign currency
             if ((*account_it).currencyId() != file->baseCurrency().id()) {
               ReportAccount repAcc = ReportAccount((*account_it).id());
               MyMoneyMoney curPrice = repAcc.baseCurrencyPrice(QDate::currentDate());
               MyMoneyMoney baseValue = value * curPrice;
               liquidLiabilities += baseValue;
               liquidLiabilities = liquidLiabilities.convert(10000);
             } else {
               liquidLiabilities += value;
             }
             break;
           }
         default:
           break;
       }
     }
     ++account_it;
   }
   //calculate net worth
   MyMoneyMoney liquidWorth = liquidAssets + liquidLiabilities;
 
   //format assets, liabilities and net worth
   QString amountLiquidAssets = liquidAssets.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountLiquidLiabilities = liquidLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountLiquidWorth = liquidWorth.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   amountLiquidAssets.replace(QChar(' '), "&nbsp;");
   amountLiquidLiabilities.replace(QChar(' '), "&nbsp;");
   amountLiquidWorth.replace(QChar(' '), "&nbsp;");
 
   //show the summary
   d->m_html += "<div class=\"shadow\"><div class=\"displayblock\"><div class=\"summaryheader\">" + i18n("Cash Flow Summary") + "</div>\n<div class=\"gap\">&nbsp;</div>\n";
 
   //print header
   d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
   //income and expense title
   d->m_html += "<tr class=\"itemtitle\">";
   d->m_html += "<td class=\"left\" colspan=\"4\">";
   d->m_html += i18n("Income and Expenses of Current Month");
   d->m_html += "</td></tr>";
   //column titles
   d->m_html += "<tr class=\"item\">";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Income");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Scheduled Income");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Expenses");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Scheduled Expenses");
   d->m_html += "</td>";
   d->m_html += "</tr>";
 
   //add row with banding
   d->m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
 
   //print current income
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountIncome, incomeValue.isNegative()));
 
   //print the scheduled income
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledIncome, scheduledIncome.isNegative()));
 
   //print current expenses
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpense,  expenseValue.isNegative()));
 
   //print the scheduled expenses
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledExpense,  scheduledExpense.isNegative()));
   d->m_html += "</tr>";
 
   d->m_html += "</table>";
 
   //print header of assets and liabilities
   d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
   d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
   //assets and liabilities title
   d->m_html += "<tr class=\"itemtitle\">";
   d->m_html += "<td class=\"left\" colspan=\"4\">";
   d->m_html += i18n("Liquid Assets and Liabilities");
   d->m_html += "</td></tr>";
   //column titles
   d->m_html += "<tr class=\"item\">";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Liquid Assets");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Transfers to Liquid Liabilities");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Liquid Liabilities");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Other Transfers");
   d->m_html += "</td>";
   d->m_html += "</tr>";
 
   //add row with banding
   d->m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
 
   //print current liquid assets
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountLiquidAssets, liquidAssets.isNegative()));
 
   //print the scheduled transfers
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledLiquidTransfer, scheduledLiquidTransfer.isNegative()));
 
   //print current liabilities
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountLiquidLiabilities,  liquidLiabilities.isNegative()));
 
   //print the scheduled transfers
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountScheduledOtherTransfer, scheduledOtherTransfer.isNegative()));
 
 
   d->m_html += "</tr>";
 
   d->m_html += "</table>";
 
   //final conclusion
   MyMoneyMoney profitValue = incomeValue + expenseValue + scheduledIncome + scheduledExpense;
   MyMoneyMoney expectedAsset = liquidAssets + scheduledIncome + scheduledExpense + scheduledLiquidTransfer + scheduledOtherTransfer;
   MyMoneyMoney expectedLiabilities = liquidLiabilities + scheduledLiquidTransfer;
 
   QString amountExpectedAsset = expectedAsset.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountExpectedLiabilities = expectedLiabilities.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   QString amountProfit = profitValue.formatMoney(file->baseCurrency().tradingSymbol(), prec);
   amountProfit.replace(QChar(' '), "&nbsp;");
   amountExpectedAsset.replace(QChar(' '), "&nbsp;");
   amountExpectedLiabilities.replace(QChar(' '), "&nbsp;");
 
 
 
   //print header of cash flow status
   d->m_html += "<div class=\"gap\">&nbsp;</div>\n";
   d->m_html += "<table width=\"100%\" cellspacing=\"0\" cellpadding=\"2\" class=\"summarytable\" >";
   //income and expense title
   d->m_html += "<tr class=\"itemtitle\">";
   d->m_html += "<td class=\"left\" colspan=\"4\">";
   d->m_html += i18n("Cash Flow Status");
   d->m_html += "</td></tr>";
   //column titles
   d->m_html += "<tr class=\"item\">";
   d->m_html += "<td>&nbsp;</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Expected Liquid Assets");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Expected Liquid Liabilities");
   d->m_html += "</td>";
   d->m_html += "<td width=\"25%\" class=\"center\">";
   d->m_html += i18n("Expected Profit/Loss");
   d->m_html += "</td>";
   d->m_html += "</tr>";
 
   //add row with banding
   d->m_html += QString("<tr class=\"row-even\" style=\"font-weight:bold;\">");
   d->m_html += "<td>&nbsp;</td>";
 
   //print expected assets
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpectedAsset, expectedAsset.isNegative()));
 
   //print expected liabilities
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountExpectedLiabilities, expectedLiabilities.isNegative()));
 
   //print expected profit
   d->m_html += QString("<td align=\"right\">%2</td>").arg(showColoredAmount(amountProfit, profitValue.isNegative()));
 
   d->m_html += "</tr>";
   d->m_html += "</table>";
   d->m_html += "</div></div>";
 }
 
 // Make sure, that these definitions are only used within this file
 // this does not seem to be necessary, but when building RPMs the
 // build option 'final' is used and all CPP files are concatenated.
 // So it could well be, that in another CPP file these definitions
 // are also used.
 #undef VIEW_LEDGER
 #undef VIEW_SCHEDULE
 #undef VIEW_WELCOME
 #undef VIEW_HOME
 #undef VIEW_REPORTS
diff --git a/kmymoney/views/kreportsview.cpp b/kmymoney/views/kreportsview.cpp
index 980cd3397..a1e307ded 100644
--- a/kmymoney/views/kreportsview.cpp
+++ b/kmymoney/views/kreportsview.cpp
@@ -1,1784 +1,1784 @@
 /***************************************************************************
                           kreportsview.cpp  -  description
                              -------------------
     begin                : Sat Mar 27 2004
     copyright            : (C) 2000-2004 by Michael Edwardes
     email                : mte@users.sourceforge.net
                            Javier Campos Morales <javi_c@users.sourceforge.net>
                            Felix Rodriguez <frodriguez@users.sourceforge.net>
                            John C <thetacoturtle@users.sourceforge.net>
                            Thomas Baumgart <ipwizard@users.sourceforge.net>
                            Kevin Tambascio <ktambascio@users.sourceforge.net>
                            Ace Jones <ace.j@hotpop.com>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 #include "kreportsview.h"
 
 // ----------------------------------------------------------------------------
 // QT Includes
 
 #include <QFile>
 #include <QTimer>
 #include <QClipboard>
 #include <QList>
 #include <QVBoxLayout>
 #include <QVariant>
 #include <QCheckBox>
 
 // ----------------------------------------------------------------------------
 // KDE Includes
 
 #include <kstandarddirs.h>
 #include <khtmlview.h>
 #include <kconfig.h>
 #include <kdebug.h>
 #include <kfiledialog.h>
 #include <kmessagebox.h>
 
 // ----------------------------------------------------------------------------
 // Project Includes
 
 #include <mymoneyfile.h>
 #include <mymoneyreport.h>
 #include <kmymoneyglobalsettings.h>
 #include "querytable.h"
 #include "objectinfotable.h"
 #include "kreportconfigurationfilterdlg.h"
 
 using namespace reports;
 
 #define VIEW_LEDGER         "ledger"
 #define VIEW_SCHEDULE       "schedule"
 #define VIEW_WELCOME        "welcome"
 #define VIEW_HOME           "home"
 #define VIEW_REPORTS        "reports"
 
 /**
   * KReportsView::KReportTab Implementation
   */
 
 KReportsView::KReportTab::KReportTab(KTabWidget* parent, const MyMoneyReport& report):
     QWidget(parent),
     m_part(new KHTMLPart(this)),
     m_chartView(new KReportChartView(this)),
     m_control(new kMyMoneyReportControl(this)),
     m_layout(new QVBoxLayout(this)),
     m_report(report),
     m_deleteMe(false),
     m_chartEnabled(false),
     m_showingChart(false),
     m_needReload(true),
     m_table(0)
 {
   m_layout->setSpacing(6);
   m_part->setFontScaleFactor(KMyMoneyGlobalSettings::fontSizePercentage());
 
   //set button icons
   m_control->buttonChart->setIcon(KIcon("office-chart-line"));
   m_control->buttonClose->setIcon(KIcon("document-close"));
   m_control->buttonConfigure->setIcon(KIcon("configure"));
   m_control->buttonCopy->setIcon(KIcon("edit-copy"));
   m_control->buttonDelete->setIcon(KIcon("edit-delete"));
   m_control->buttonExport->setIcon(KIcon("document-export"));
   m_control->buttonNew->setIcon(KIcon("document-new"));
 
   m_chartView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
   m_chartView->hide();
   m_layout->addWidget(m_control);
   m_layout->addWidget(m_part->view());
   m_layout->addWidget(m_chartView);
 
   parent->addTab(this, KIcon("application-vnd.oasis.opendocument.spreadsheet"), report.name());
   parent->setTabEnabled(parent->indexOf(this), true);
 
   // get users character set encoding
   m_encoding = KGlobal::locale()->encoding();
 }
 
 KReportsView::KReportTab::~KReportTab()
 {
   delete m_table;
   //This is to prevent a crash on exit with KDE 4.3.2
   delete m_part;
 }
 
 void KReportsView::KReportTab::print()
 {
   if (m_part && m_part->view())
     m_part->view()->print();
 }
 
 void KReportsView::KReportTab::copyToClipboard()
 {
   QMimeData* pMimeData =  new QMimeData();
   pMimeData->setHtml(m_table->renderHTML(qobject_cast<QWidget*>(this),
                                          m_encoding, m_report.name(), true));
   QApplication::clipboard()->setMimeData(pMimeData);
 }
 
 void KReportsView::KReportTab::saveAs(const QString& filename, bool includeCSS)
 {
   QFile file(filename);
 
   if (file.open(QIODevice::WriteOnly)) {
     if (QFileInfo(filename).suffix().toLower() == "csv") {
       QTextStream(&file) << m_table->renderCSV();
     } else {
       QString table =
         m_table->renderHTML(qobject_cast<QWidget*>(this), m_encoding,
                             m_report.name(), includeCSS);
       QTextStream stream(&file);
       stream << table;
     }
     file.close();
   }
 }
 
 void KReportsView::KReportTab::loadTab()
 {
   m_needReload = true;
   if (isVisible()) {
     m_needReload = false;
     updateReport();
   }
 }
 
 void KReportsView::KReportTab::showEvent(QShowEvent * event)
 {
   if (m_needReload) {
     m_needReload = false;
     updateReport();
   }
   QWidget::showEvent(event);
 }
 
 void KReportsView::KReportTab::updateReport()
 {
   // reload the report from the engine. It might have
   // been changed by the user
 
   try {
     // Don't try to reload default reports from the engine
     if (!m_report.id().isEmpty())
       m_report = MyMoneyFile::instance()->report(m_report.id());
   } catch (const MyMoneyException &) {
   }
 
   delete m_table;
   m_table = 0;
 
   if (m_report.reportType() == MyMoneyReport::ePivotTable) {
     m_table = new PivotTable(m_report);
     m_chartEnabled = true;
   } else if (m_report.reportType() == MyMoneyReport::eQueryTable) {
     m_table = new QueryTable(m_report);
     m_chartEnabled = false;
   } else if (m_report.reportType() == MyMoneyReport::eInfoTable) {
     m_table = new ObjectInfoTable(m_report);
     m_chartEnabled = false;
   }
 
   m_part->begin();
   m_part->write(m_table->renderHTML(qobject_cast<QWidget*>(this),
                                     m_encoding, m_report.name()));
   m_part->end();
 
   m_table->drawChart(*m_chartView);
   m_control->buttonChart->setEnabled(m_chartEnabled);
 
   if (m_report.isChartByDefault() && !m_showingChart)
     toggleChart();
 }
 
 void KReportsView::KReportTab::toggleChart()
 {
   // for now it will just SHOW the chart.  In the future it actually has to toggle it.
 
   if (m_showingChart) {
     m_part->view()->show();
     m_chartView->hide();
 
     m_control->buttonChart->setText(i18n("Chart"));
     m_control->buttonChart->setToolTip(i18n("Show the chart version of this report"));
     m_control->buttonChart->setIcon(KIcon("office-chart-line"));
   } else {
     m_part->view()->hide();
 
     m_chartView->show();
 
     m_control->buttonChart->setText(i18n("Report"));
     m_control->buttonChart->setToolTip(i18n("Show the report version of this chart"));
     m_control->buttonChart->setIcon(KIcon("view-financial-list"));
   }
   m_showingChart = ! m_showingChart;
 }
 
 /**
   * KReportsView Implementation
   */
 
 class KReportsView::Private
 {
 public:
 
   Private() {
     fSavProps = new FileSaveProperties();
   }
 
   ~Private() {
     delete fSavProps;
   }
 
   class FileSaveProperties
   {
   public:
     FileSaveProperties() {
       includeCssCheckBox = 0;
       cbIsChecked = true;
       filter = "*.csv";
       filtCsv = "*.csv|" + i18nc("CSV (Filefilter)", "CSV files");
       filtHtml = "*.html|" + i18nc("HTML (Filefilter)", "HTML files");
     }
 
     /**
      * 'include css' checkbox for file save dialog.
      */
     QCheckBox* includeCssCheckBox;
 
     /**
      * Persistent checked-state of includeCssCheckBox.
      */
     bool cbIsChecked;
 
     /**
      * Current filtername of file save dialog
      * without description, e.g. @c '*.csv'
      */
     QString filter;
 
     /**
      * CSV filtername and description.
      *
      * @see KFileDialog::KFileDialog
      */
     QString filtCsv;
 
     /**
      * HTML filtername and description.
      *
      * @see KFileDialog::KFileDialog
      */
     QString filtHtml;
   };
 
   FileSaveProperties* fSavProps;
 };
 
 KReportsView::KReportsView(QWidget *parent, const char *name) :
     KMyMoneyViewBase(parent, name, i18n("Reports")),
     d(new Private),
     m_needReload(false),
     m_reportListView(0)
 {
   // build reports toc
 
   setColumnsAlreadyAdjusted(false);
 
   m_reportTabWidget = new KTabWidget(this);
   addWidget(m_reportTabWidget);
   m_reportTabWidget->setTabsClosable(true);
 
   m_listTab = new QWidget(m_reportTabWidget);
   m_listTabLayout = new QVBoxLayout(m_listTab);
   m_listTabLayout->setSpacing(6);
 
   m_tocTreeWidget = new QTreeWidget(m_listTab);
 
   // report-group items have only 1 column (name of group),
   // report items have 2 columns (report name and comment)
   m_tocTreeWidget->setColumnCount(2);
 
   // headers
   QStringList headers;
   headers << i18n("Reports") << i18n("Comment");
   m_tocTreeWidget->setHeaderLabels(headers);
 
   m_tocTreeWidget->setAlternatingRowColors(true);
   m_tocTreeWidget->setSortingEnabled(true);
   m_tocTreeWidget->sortByColumn(0, Qt::AscendingOrder);
 
   // for report group items:
   // doubleclick toggles the expand-state,
   // so avoid any further action in case of doubleclick
   // (see slotItemDoubleClicked)
   m_tocTreeWidget->setExpandsOnDoubleClick(false);
 
   m_tocTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu);
 
   m_tocTreeWidget->setSelectionMode(QAbstractItemView::SingleSelection);
 
   m_listTabLayout->addWidget(m_tocTreeWidget);
   m_reportTabWidget->addTab(m_listTab, i18n("Reports"));
 
   connect(m_reportTabWidget, SIGNAL(tabCloseRequested(int)),
           this, SLOT(slotClose(int)));
 
   connect(m_tocTreeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),
           this, SLOT(slotItemDoubleClicked(QTreeWidgetItem*,int)));
 
   connect(m_tocTreeWidget, SIGNAL(customContextMenuRequested(QPoint)),
           this, SLOT(slotListContextMenu(QPoint)));
 
   connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadView()));
 }
 
 KReportsView::~KReportsView()
 {
   delete d;
 }
 
 void KReportsView::showEvent(QShowEvent * event)
 {
   emit aboutToShow();
 
   if (m_needReload) {
     loadView();
     m_needReload = false;
   }
 
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
   if (tab)
     emit reportSelected(tab->report());
   else
     emit reportSelected(MyMoneyReport());
 
   // don't forget base class implementation
   KMyMoneyViewBase::showEvent(event);
 }
 
 void KReportsView::slotLoadView()
 {
   m_needReload = true;
   if (isVisible()) {
     loadView();
     m_needReload = false;
   }
 }
 
 void KReportsView::loadView()
 {
   // remember the id of the current selected item
   QTreeWidgetItem* item = m_tocTreeWidget->currentItem();
   QString selectedItem = (item) ? item->text(0) : QString();
 
   // save expand states of all top-level items
   QMap<QString, bool> expandStates;
   for (int i = 0; i < m_tocTreeWidget->topLevelItemCount(); i++) {
     QTreeWidgetItem* item = m_tocTreeWidget->topLevelItem(i);
 
     if (item) {
       QString itemLabel = item->text(0);
 
       if (item->isExpanded()) {
         expandStates.insert(itemLabel, true);
       } else {
         expandStates.insert(itemLabel, false);
       }
     }
   }
 
   // find the item visible on top
   QTreeWidgetItem* visibleTopItem = m_tocTreeWidget->itemAt(0, 0);
 
   // text of column 0 identifies the item visible on top
   QString visibleTopItemText;
 
   bool visibleTopItemFound = true;
   if (visibleTopItem == NULL) {
     visibleTopItemFound = false;
   } else {
     // this assumes, that all item-texts in column 0 are unique,
     // no matter, whether the item is a report- or a group-item
     visibleTopItemText = visibleTopItem->text(0);
   }
 
   // turn off updates to avoid flickering during reload
   //m_reportListView->setUpdatesEnabled(false);
 
   //
   // Rebuild the list page
   //
   m_tocTreeWidget->clear();
 
   // Default Reports
   QList<ReportGroup> defaultreports;
   defaultReports(defaultreports);
 
   QList<ReportGroup>::const_iterator it_group = defaultreports.constBegin();
 
   // the item to be set as current item
   QTreeWidgetItem* currentItem = 0L;
 
   // group number, this will be used as sort key for reportgroup items
   // we have:
   // 1st some default groups
   // 2nd a chart group
   // 3rd maybe a favorite group
   // 4th maybe an orphan group (for old reports)
   int defaultGroupNo = 1;
   int chartGroupNo = defaultreports.size() + 1;
 
   // group for diagrams
   QString groupName = I18N_NOOP("Charts");
 
   TocItemGroup* chartTocItemGroup =
     new TocItemGroup(m_tocTreeWidget, chartGroupNo,
                      i18n(groupName.toLatin1().data()));
 
   m_allTocItemGroups.insert(groupName, chartTocItemGroup);
 
   while (it_group != defaultreports.constEnd()) {
     QString groupName = (*it_group).name();
 
     TocItemGroup* defaultTocItemGroup =
       new TocItemGroup(m_tocTreeWidget, defaultGroupNo++,
                        i18n(groupName.toLatin1().data()));
 
     m_allTocItemGroups.insert(groupName, defaultTocItemGroup);
 
     if (groupName == selectedItem) {
       currentItem = defaultTocItemGroup;
     }
 
     QList<MyMoneyReport>::const_iterator it_report = (*it_group).begin();
     while (it_report != (*it_group).end()) {
       MyMoneyReport report = *it_report;
       report.setGroup(groupName);
 
       TocItemReport* reportTocItemReport =
         new TocItemReport(defaultTocItemGroup, report);
 
       if (report.name() == selectedItem) {
         currentItem = reportTocItemReport;
       }
 
       // ALSO place it into the Charts list if it's displayed as a chart by default
       if (report.isChartByDefault()) {
         new TocItemReport(chartTocItemGroup, report);
       }
 
       ++it_report;
     }
 
     ++it_group;
   }
 
   // group for custom (favorite) reports
   int favoriteGroupNo = chartGroupNo + 1;
 
   groupName = I18N_NOOP("Favorite Reports");
 
   TocItemGroup* favoriteTocItemGroup =
     new TocItemGroup(m_tocTreeWidget, favoriteGroupNo,
                      i18n(groupName.toLatin1().data()));
 
   m_allTocItemGroups.insert(groupName, favoriteTocItemGroup);
 
   TocItemGroup* orphanTocItemGroup = 0;
 
   QList<MyMoneyReport> customreports = MyMoneyFile::instance()->reportList();
   QList<MyMoneyReport>::const_iterator it_report = customreports.constBegin();
   while (it_report != customreports.constEnd()) {
 
     MyMoneyReport report = *it_report;
 
     QString groupName = (*it_report).group();
 
     // If this report is in a known group, place it there
     // KReportGroupListItem* groupnode = groupitems[(*it_report).group()];
     TocItemGroup* groupNode = m_allTocItemGroups[groupName];
 
     if (groupNode) {
       new TocItemReport(groupNode, report);
     } else {
       // otherwise, place it in the orphanage
       if (!orphanTocItemGroup) {
 
         // group for orphaned reports
         int orphanGroupNo = favoriteGroupNo + 1;
 
         QString groupName = I18N_NOOP("Old Customized Reports");
 
         orphanTocItemGroup =
           new TocItemGroup(m_tocTreeWidget, orphanGroupNo,
                            i18n(groupName.toLatin1().data()));
         m_allTocItemGroups.insert(groupName, orphanTocItemGroup);
       }
       new TocItemReport(orphanTocItemGroup, report);
     }
 
     // ALSO place it into the Favorites list if it's a favorite
     if ((*it_report).isFavorite()) {
       new TocItemReport(favoriteTocItemGroup, report);
     }
 
     // ALSO place it into the Charts list if it's displayed as a chart by default
     if ((*it_report).isChartByDefault()) {
       new TocItemReport(chartTocItemGroup, report);
     }
 
     ++it_report;
   }
 
   //
   // Go through the tabs to set their update flag or delete them if needed
   //
 
   int index = 1;
   while (index < m_reportTabWidget->count()) {
     // TODO: Find some way of detecting the file is closed and kill these tabs!!
     KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(index));
     if (tab->isReadyToDelete() /* || ! reports.count() */) {
       delete tab;
       --index;
     } else {
       tab->loadTab();
     }
     ++index;
   }
 
   if (visibleTopItemFound) {
     // try to find the visibleTopItem that we had at the start of this method
 
     // intentionally not using 'Qt::MatchCaseSensitive' here
     // to avoid 'item not found' if someone corrected a typo only
     QList<QTreeWidgetItem*> visibleTopItemList =
       m_tocTreeWidget->findItems(visibleTopItemText,
                                  Qt::MatchFixedString |
                                  Qt::MatchRecursive);
 
     if (visibleTopItemList.isEmpty()) {
       // the item could not be found, it was deleted or renamed
       visibleTopItemFound = false;
     } else {
       visibleTopItem = visibleTopItemList.at(0);
       if (visibleTopItem == NULL) {
         visibleTopItemFound = false;
       }
     }
   }
 
   // adjust column widths,
   // but only the first time when the view is loaded,
   // maybe the user sets other column widths later,
   // so don't disturb him
   if (columnsAlreadyAdjusted()) {
 
     // restore expand states of all top-level items
     restoreTocExpandState(expandStates);
 
     // restore current item
     m_tocTreeWidget->setCurrentItem(currentItem);
 
     // try to scroll to the item visible on top
     // when this method started
     if (visibleTopItemFound) {
       m_tocTreeWidget->scrollToItem(visibleTopItem);
     } else {
       m_tocTreeWidget->scrollToTop();
     }
     return;
   }
 
   // avoid flickering
   m_tocTreeWidget->setUpdatesEnabled(false);
 
   // expand all top-level items
   m_tocTreeWidget->expandAll();
 
   // resize columns
   m_tocTreeWidget->resizeColumnToContents(0);
   m_tocTreeWidget->resizeColumnToContents(1);
 
   // restore expand states of all top-level items
   restoreTocExpandState(expandStates);
 
   // restore current item
   m_tocTreeWidget->setCurrentItem(currentItem);
 
   // try to scroll to the item visible on top
   // when this method started
   if (visibleTopItemFound) {
     m_tocTreeWidget->scrollToItem(visibleTopItem);
   } else {
     m_tocTreeWidget->scrollToTop();
   }
 
   setColumnsAlreadyAdjusted(true);
 
   m_tocTreeWidget->setUpdatesEnabled(true);
 }
 
 void KReportsView::slotOpenUrl(const KUrl &url, const KParts::OpenUrlArguments&, const KParts::BrowserArguments&)
 {
   QString view = url.fileName();
   QString command = url.queryItem("command");
   QString id = url.queryItem("id");
   QString tid = url.queryItem("tid");
 
   if (view == VIEW_REPORTS) {
 
     if (command.isEmpty()) {
       // slotRefreshView();
     } else if (command == "print")
       slotPrintView();
     else if (command == "copy")
       slotCopyView();
     else if (command == "save")
       slotSaveView();
     else if (command == "configure")
       slotConfigure();
     else if (command == "duplicate")
       slotDuplicate();
     else if (command == "close")
       slotCloseCurrent();
     else if (command == "delete")
       slotDelete();
     else
       qWarning() << i18n("Unknown command '%1' in KReportsView::slotOpenUrl()", qPrintable(command));
 
   } else if (view == VIEW_LEDGER) {
     emit ledgerSelected(id, tid);
   } else {
     qWarning() << i18n("Unknown view '%1' in KReportsView::slotOpenUrl()", qPrintable(view));
   }
 }
 
 void KReportsView::slotPrintView()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
   if (tab)
     tab->print();
 }
 
 void KReportsView::slotCopyView()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
   if (tab)
     tab->copyToClipboard();
 }
 
 void KReportsView::slotSaveView()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
   if (tab) {
     d->fSavProps->includeCssCheckBox = new QCheckBox(i18n("Include Stylesheet"));
     // restore checkbox checked state
     d->fSavProps->includeCssCheckBox->setChecked(d->fSavProps->cbIsChecked);
 
     QString filterList = d->fSavProps->filtCsv + '\n' + d->fSavProps->filtHtml;
     QPointer<KFileDialog> dlg =
       new KFileDialog(KUrl("kfiledialog:///kmymoney-export"), filterList, this,
                       qobject_cast<QWidget*>(d->fSavProps->includeCssCheckBox));
 
     connect(dlg, SIGNAL(filterChanged(QString)),
             this, SLOT(slotSaveFilterChanged(QString)));
 
     dlg->setOperationMode(KFileDialog::Saving);
     dlg->setCaption(i18n("Export as"));
 
     // set current file filter && enable or disable includeCssCheckBox
     KFileFilterCombo* combo = dlg->filterWidget();
     if (d->fSavProps->filter == "*.csv") {
       combo->setCurrentFilter(d->fSavProps->filtCsv);
       d->fSavProps->includeCssCheckBox->setEnabled(false);
     } else {
       combo->setCurrentFilter(d->fSavProps->filtHtml);
       d->fSavProps->includeCssCheckBox->setEnabled(true);
     }
 
     if (dlg->exec() == QDialog::Accepted) {
       KUrl newURL = dlg->selectedUrl();
       if (!newURL.isEmpty()) {
         QString newName = newURL.pathOrUrl();
 
         if (newName.indexOf('.') == -1)
           newName.append(d->fSavProps->filter.remove('*'));
 
         // save checkbox checked state
         d->fSavProps->cbIsChecked = d->fSavProps->includeCssCheckBox->isChecked();
 
         try {
           tab->saveAs(newName, d->fSavProps->includeCssCheckBox->isEnabled()
                       && d->fSavProps->includeCssCheckBox->isChecked());
         } catch (const MyMoneyException &e) {
           KMessageBox::error(this, i18n("Failed to save: %1", e.what()));
         }
       }
     }
     delete d->fSavProps->includeCssCheckBox;
     delete dlg;
   }
 }
 
 void KReportsView::slotSaveFilterChanged(const QString& filter)
 {
   d->fSavProps->filter = filter;
 
   if (filter ==  "*.html") {
     d->fSavProps->includeCssCheckBox->setEnabled(true);
   } else {
     d->fSavProps->includeCssCheckBox->setEnabled(false);
   }
 }
 
 void KReportsView::slotConfigure()
 {
   QString cm = "KReportsView::slotConfigure";
 
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
 
   if (!tab) {
     // nothing to do
     return;
   }
 
   MyMoneyReport report = tab->report();
   if (report.comment() == i18n("Default Report") || report.comment() == i18n("Generated Report")) {
     report.setComment(i18n("Custom Report"));
     report.setName(i18n("%1 (Customized)", report.name()));
   }
 
   QPointer<KReportConfigurationFilterDlg> dlg = new KReportConfigurationFilterDlg(report);
 
   if (dlg->exec()) {
     MyMoneyReport newreport = dlg->getConfig();
 
     // If this report has an ID, then MODIFY it, otherwise ADD it
     MyMoneyFileTransaction ft;
     try {
       if (! newreport.id().isEmpty()) {
         MyMoneyFile::instance()->modifyReport(newreport);
         ft.commit();
         tab->modifyReport(newreport);
 
         m_reportTabWidget->setTabText(m_reportTabWidget->indexOf(tab), newreport.name());
         m_reportTabWidget->setCurrentIndex(m_reportTabWidget->indexOf(tab)) ;
       } else {
         MyMoneyFile::instance()->addReport(newreport);
         ft.commit();
 
         QString reportGroupName = newreport.group();
 
         // find report group
         TocItemGroup* tocItemGroup = m_allTocItemGroups[reportGroupName];
         if (!tocItemGroup) {
           QString error = i18n("Could not find reportgroup \"%1\" for report \"%2\".\nPlease report this error to the developer's list: kmymoney-devel@kde.org", reportGroupName, newreport.name());
 
           // write to messagehandler
           qWarning() << cm << error;
 
           // also inform user
           KMessageBox::error(m_reportTabWidget, error, i18n("Critical Error"));
 
           // cleanup
           delete dlg;
 
           return;
         }
 
         // do not add TocItemReport to TocItemGroup here,
         // this is done in loadView
 
         addReportTab(newreport);
       }
     } catch (const MyMoneyException &e) {
       KMessageBox::error(this, i18n("Failed to configure report: %1", e.what()));
     }
   }
   delete dlg;
 }
 
 void KReportsView::slotDuplicate()
 {
   QString cm = "KReportsView::slotDuplicate";
 
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
 
   if (!tab) {
     // nothing to do
     return;
   }
 
   MyMoneyReport dupe = tab->report();
   dupe.setName(i18n("Copy of %1", dupe.name()));
   if (dupe.comment() == i18n("Default Report"))
     dupe.setComment(i18n("Custom Report"));
   dupe.clearId();
 
   QPointer<KReportConfigurationFilterDlg> dlg = new KReportConfigurationFilterDlg(dupe);
   if (dlg->exec()) {
     MyMoneyReport newReport = dlg->getConfig();
     MyMoneyFileTransaction ft;
     try {
       MyMoneyFile::instance()->addReport(newReport);
       ft.commit();
 
       QString reportGroupName = newReport.group();
 
       // find report group
       TocItemGroup* tocItemGroup = m_allTocItemGroups[reportGroupName];
       if (!tocItemGroup) {
         QString error = i18n("Could not find reportgroup \"%1\" for report \"%2\".\nPlease report this error to the developer's list: kmymoney-devel@kde.org", reportGroupName, newReport.name());
 
         // write to messagehandler
         qWarning() << cm << error;
 
         // also inform user
         KMessageBox::error(m_reportTabWidget, error, i18n("Critical Error"));
 
         // cleanup
         delete dlg;
 
         return;
       }
 
       // do not add TocItemReport to TocItemGroup here,
       // this is done in loadView
 
       addReportTab(newReport);
     } catch (const MyMoneyException &e) {
       QString error = i18n("Cannot add report, reason: \"%1\"", e.what());
 
       // write to messagehandler
       qWarning() << cm << error;
 
       // also inform user
       KMessageBox::error(m_reportTabWidget, error, i18n("Critical Error"));
     }
   }
   delete dlg;
 }
 
 void KReportsView::slotDelete()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
   if (!tab) {
     // nothing to do
     return;
   }
 
   MyMoneyReport report = tab->report();
   if (! report.id().isEmpty()) {
     if (KMessageBox::Continue == deleteReportDialog(report.name())) {
       // close the tab and then remove the report so that it is not
       // generated again during the following loadView() call
       slotClose(m_reportTabWidget->currentIndex());
 
       MyMoneyFileTransaction ft;
       MyMoneyFile::instance()->removeReport(report);
       ft.commit();
     }
   } else {
     KMessageBox::information(this,
                              QString("<qt>") +
                              i18n("<b>%1</b> is a default report, so it cannot be deleted.",
                                   report.name()) + QString("</qt>"), i18n("Delete Report?"));
   }
 }
 
 int KReportsView::deleteReportDialog(const QString &reportName)
 {
   return KMessageBox::warningContinueCancel(this, QString("<qt>") +
          i18n("Are you sure you want to delete report <b>%1</b>?  There is no way to recover it.",
               reportName) + QString("</qt>"), i18n("Delete Report?"));
 }
 
 void KReportsView::slotOpenReport(const QString& id)
 {
   if (id.isEmpty()) {
     // nothing to  do
     return;
   }
 
   KReportTab* page = 0;
 
   // Find the tab which contains the report
   int index = 1;
   while (index < m_reportTabWidget->count()) {
     KReportTab* current = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(index));
 
     if (current->report().id() == id) {
       page = current;
       break;
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     m_reportTabWidget->setCurrentIndex(m_reportTabWidget->indexOf(page));
   else
     addReportTab(MyMoneyFile::instance()->report(id));
 }
 
 void KReportsView::slotOpenReport(const MyMoneyReport& report)
 {
   kDebug(2) << Q_FUNC_INFO << " " << report.name();
   KReportTab* page = 0;
 
   // Find the tab which contains the report indicated by this list item
   int index = 1;
   while (index < m_reportTabWidget->count()) {
     KReportTab* current = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(index));
 
     if (current->report().name() == report.name()) {
       page = current;
       break;
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     m_reportTabWidget->setCurrentIndex(m_reportTabWidget->indexOf(page));
   else
     addReportTab(report);
 
 }
 
 void KReportsView::slotItemDoubleClicked(QTreeWidgetItem* item, int)
 {
   TocItem* tocItem = dynamic_cast<TocItem*>(item);
   if (!tocItem->isReport()) {
     // toggle the expanded-state for reportgroup-items
     item->setExpanded(item->isExpanded() ? false : true);
 
     // nothing else to do for reportgroup-items
     return;
   }
 
   TocItemReport* reportTocItem = dynamic_cast<TocItemReport*>(tocItem);
 
   MyMoneyReport& report = reportTocItem->getReport();
 
   KReportTab* page = 0;
 
   // Find the tab which contains the report indicated by this list item
   int index = 1;
   while (index < m_reportTabWidget->count()) {
     KReportTab* current = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(index));
 
     // If this report has an ID, we'll use the ID to match
     if (! report.id().isEmpty()) {
       if (current->report().id() == report.id()) {
         page = current;
         break;
       }
     }
     // Otherwise, use the name to match.  THIS ASSUMES that no 2 default reports
     // have the same name...but that would be pretty a boneheaded thing to do.
     else {
       if (current->report().name() == report.name()) {
         page = current;
         break;
       }
     }
 
     ++index;
   }
 
   // Show the tab, or create a new one, as needed
   if (page)
     m_reportTabWidget->setCurrentIndex(m_reportTabWidget->indexOf(page));
   else
     addReportTab(report);
 }
 
 void KReportsView::slotToggleChart()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->currentWidget());
 
   if (tab)
     tab->toggleChart();
 }
 
 void KReportsView::slotCloseCurrent()
 {
   slotClose(m_reportTabWidget->currentIndex());
 }
 
 void KReportsView::slotClose(int index)
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(index));
   if (tab) {
     m_reportTabWidget->removeTab(index);
     tab->setReadyToDelete(true);
   }
 }
 
 
 void KReportsView::slotCloseAll()
 {
   KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(1));
   while (tab) {
     m_reportTabWidget->removeTab(m_reportTabWidget->indexOf(tab));
     tab->setReadyToDelete(true);
 
     tab = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(1));
   }
 }
 
 void KReportsView::addReportTab(const MyMoneyReport& report)
 {
   KReportTab* tab = new KReportTab(m_reportTabWidget, report);
 
   connect(tab->control()->buttonChart, SIGNAL(clicked()),
           this, SLOT(slotToggleChart()));
 
   connect(tab->control()->buttonConfigure, SIGNAL(clicked()),
           this, SLOT(slotConfigure()));
 
   connect(tab->control()->buttonNew, SIGNAL(clicked()),
           this, SLOT(slotDuplicate()));
 
   connect(tab->control()->buttonCopy, SIGNAL(clicked()),
           this, SLOT(slotCopyView()));
 
   connect(tab->control()->buttonExport, SIGNAL(clicked()),
           this, SLOT(slotSaveView()));
 
   connect(tab->control()->buttonDelete, SIGNAL(clicked()),
           this, SLOT(slotDelete()));
 
   connect(tab->control()->buttonClose, SIGNAL(clicked()),
           this, SLOT(slotCloseCurrent()));
 
   connect(tab->browserExtenstion(), SIGNAL(openUrlRequest(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)),
           this, SLOT(slotOpenUrl(KUrl,KParts::OpenUrlArguments,KParts::BrowserArguments)));
 
   // if this is a default report, then you can't delete it!
   if (report.id().isEmpty())
     tab->control()->buttonDelete->setEnabled(false);
 
   m_reportTabWidget->setCurrentIndex(m_reportTabWidget->indexOf(tab));
 }
 
 void KReportsView::slotListContextMenu(const QPoint & p)
 {
   QTreeWidgetItem *item = m_tocTreeWidget->itemAt(p);
 
   if (!item) {
     return;
   }
 
   TocItem* tocItem = dynamic_cast<TocItem*>(item);
 
   if (!tocItem->isReport()) {
     // currently there is no context menu for reportgroup items
     return;
   }
 
   KMenu* contextmenu = new KMenu(this);
 
   contextmenu->addAction(i18nc("To open a new report", "&Open"),
                          this, SLOT(slotOpenFromList()));
 
   contextmenu->addAction(i18nc("Configure a report", "&Configure"),
                          this, SLOT(slotConfigureFromList()));
 
   contextmenu->addAction(i18n("&New report"),
                          this, SLOT(slotNewFromList()));
 
   // Only add this option if it's a custom report. Default reports cannot be deleted
   TocItemReport* reportTocItem = dynamic_cast<TocItemReport*>(tocItem);
   MyMoneyReport& report = reportTocItem->getReport();
   if (! report.id().isEmpty()) {
     contextmenu->addAction(i18n("&Delete"),
                            this, SLOT(slotDeleteFromList()));
   }
 
   contextmenu->popup(m_tocTreeWidget->mapToGlobal(p));
 }
 
 void KReportsView::slotOpenFromList()
 {
   TocItem* tocItem = dynamic_cast<TocItem*>(m_tocTreeWidget->currentItem());
 
   if (tocItem)
     slotItemDoubleClicked(tocItem, 0);
 }
 
 void KReportsView::slotConfigureFromList()
 {
   TocItem* tocItem = dynamic_cast<TocItem*>(m_tocTreeWidget->currentItem());
 
   if (tocItem) {
     slotItemDoubleClicked(tocItem, 0);
     slotConfigure();
   }
 }
 
 void KReportsView::slotNewFromList()
 {
   TocItem* tocItem = dynamic_cast<TocItem*>(m_tocTreeWidget->currentItem());
 
   if (tocItem) {
     slotItemDoubleClicked(tocItem, 0);
     slotDuplicate();
   }
 }
 
 void KReportsView::slotDeleteFromList()
 {
   TocItem* tocItem = dynamic_cast<TocItem*>(m_tocTreeWidget->currentItem());
 
   if (tocItem) {
     TocItemReport* reportTocItem = dynamic_cast<TocItemReport*>(tocItem);
 
     MyMoneyReport& report = reportTocItem->getReport();
 
     // If this report does not have an ID, it's a default report and cannot be deleted
     if (! report.id().isEmpty() &&
         KMessageBox::Continue == deleteReportDialog(report.name())) {
       // check if report's tab is open; start from 1 because 0 is toc tab
       for (int i = 1; i < m_reportTabWidget->count(); ++i) {
         KReportTab* tab = dynamic_cast<KReportTab*>(m_reportTabWidget->widget(i));
         if (tab->report().id() == report.id()) {
           slotClose(i); // if open, close it, so no crash when switching to it
           break;
         }
       }
       MyMoneyFileTransaction ft;
       MyMoneyFile::instance()->removeReport(report);
       ft.commit();
     }
   }
 }
 
 void KReportsView::defaultReports(QList<ReportGroup>& groups)
 {
   {
     ReportGroup list("Income and Expenses", i18n("Income and Expenses"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentMonth,
                      MyMoneyReport::eDetailAll,
                      i18n("Income and Expenses This Month"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Income and Expenses This Year"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eYears,
+                     MyMoneyReport::Column::Years,
                      MyMoneyTransactionFilter::allDates,
                      MyMoneyReport::eDetailAll,
                      i18n("Income and Expenses By Year"),
                      i18n("Default Report")
                    ));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last12Months,
                      MyMoneyReport::eDetailTop,
                      i18n("Income and Expenses Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setChartDataLabels(false);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailGroup,
                      i18n("Income and Expenses Pie Chart"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartType(MyMoneyReport::eChartPie);
     list.back().setShowingRowTotals(false);
 
     groups.push_back(list);
   }
   {
     ReportGroup list("Net Worth", i18n("Net Worth"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailTop,
                      i18n("Net Worth By Month"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::today,
                      MyMoneyReport::eDetailTop,
                      i18n("Net Worth Today"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eYears,
+                     MyMoneyReport::Column::Years,
                      MyMoneyTransactionFilter::allDates,
                      MyMoneyReport::eDetailTop,
                      i18n("Net Worth By Year"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::next7Days,
                      MyMoneyReport::eDetailTop,
                      i18n("7-day Cash Flow Forecast"),
                      i18n("Default Report")
                    ));
     list.back().setIncludingSchedules(true);
     list.back().setColumnsAreDays(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last12Months,
                      MyMoneyReport::eDetailTotal,
                      i18n("Net Worth Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eInstitution,
                      MyMoneyReport::eQCnone,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailTop,
                      i18n("Account Balances by Institution"),
                      i18n("Default Report")
                    ));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountType,
                      MyMoneyReport::eQCnone,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailTop,
                      i18n("Account Balances by Type"),
                      i18n("Default Report")
                    ));
 
     groups.push_back(list);
   }
   {
     ReportGroup list("Transactions", i18n("Transactions"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccount,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCtag | MyMoneyReport::eQCbalance,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Account"),
                      i18n("Default Report")
                    ));
     //list.back().setConvertCurrency(false);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eCategory,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount | MyMoneyReport::eQCtag,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Category"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::ePayee,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCcategory | MyMoneyReport::eQCtag,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Payee"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eTag,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCcategory,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Tag"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eMonth,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCtag,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Month"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eWeek,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCtag,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Week"),
                      i18n("Default Report")
                    ));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccount,
                      MyMoneyReport::eQCloan,
                      MyMoneyTransactionFilter::allDates,
                      MyMoneyReport::eDetailAll,
                      i18n("Loan Transactions"),
                      i18n("Default Report")
                    ));
     list.back().setLoansOnly(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountReconcile,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCcategory | MyMoneyReport::eQCbalance,
                      MyMoneyTransactionFilter::last3Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Transactions by Reconciliation Status"),
                      i18n("Default Report")
                    ));
     groups.push_back(list);
   }
   {
     ReportGroup list("CashFlow", i18n("Cash Flow"));
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eCashFlow,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Cash Flow Transactions This Month"),
                      i18n("Default Report")
                    ));
     groups.push_back(list);
   }
   {
     ReportGroup list("Investments", i18n("Investments"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eTopAccount,
                      MyMoneyReport::eQCaction | MyMoneyReport::eQCshares | MyMoneyReport::eQCprice,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Transactions"),
                      i18n("Default Report")
                    ));
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountByTopAccount,
                      MyMoneyReport::eQCshares | MyMoneyReport::eQCprice,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Holdings by Account"),
                      i18n("Default Report")
                    ));
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eEquityType,
                      MyMoneyReport::eQCshares | MyMoneyReport::eQCprice,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Holdings by Type"),
                      i18n("Default Report")
                    ));
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountByTopAccount,
                      MyMoneyReport::eQCperformance,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Performance by Account"),
                      i18n("Default Report")
                    ));
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eEquityType,
                      MyMoneyReport::eQCperformance,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Performance by Type"),
                      i18n("Default Report")
                    ));
     list.back().setInvestmentsOnly(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::today,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Holdings Pie"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartPie);
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last12Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Worth Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setColumnsAreDays(true);
     list.back().setInvestmentsOnly(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last12Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Price Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setColumnsAreDays(true);
     list.back().setInvestmentsOnly(true);
     list.back().setIncludingBudgetActuals(false);
     list.back().setIncludingPrice(true);
     list.back().setConvertCurrency(true);
     list.back().setChartDataLabels(false);
     list.back().setSkipZero(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last12Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Moving Average Price Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setColumnsAreDays(true);
     list.back().setInvestmentsOnly(true);
     list.back().setIncludingBudgetActuals(false);
     list.back().setIncludingAveragePrice(true);
     list.back().setMovingAverageDays(10);
     list.back().setConvertCurrency(true);
     list.back().setChartDataLabels(false);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last30Days,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Moving Average"),
                      i18n("Default Report")
                    ));
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setColumnsAreDays(true);
     list.back().setInvestmentsOnly(true);
     list.back().setIncludingBudgetActuals(false);
     list.back().setIncludingMovingAverage(true);
     list.back().setMovingAverageDays(10);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::last30Days,
                      MyMoneyReport::eDetailAll,
                      i18n("Investment Moving Average vs Actual"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     list.back().setColumnsAreDays(true);
     list.back().setInvestmentsOnly(true);
     list.back().setIncludingBudgetActuals(true);
     list.back().setIncludingMovingAverage(true);
     list.back().setMovingAverageDays(10);
     groups.push_back(list);
   }
   {
     ReportGroup list("Taxes", i18n("Taxes"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eCategory,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Tax Transactions by Category"),
                      i18n("Default Report")
                    ));
     list.back().setTax(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::ePayee,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCcategory | MyMoneyReport::eQCaccount,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Tax Transactions by Payee"),
                      i18n("Default Report")
                    ));
     list.back().setTax(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eCategory,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCpayee | MyMoneyReport::eQCaccount,
                      MyMoneyTransactionFilter::lastFiscalYear,
                      MyMoneyReport::eDetailAll,
                      i18n("Tax Transactions by Category Last Fiscal Year"),
                      i18n("Default Report")
                    ));
     list.back().setTax(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::ePayee,
                      MyMoneyReport::eQCnumber | MyMoneyReport::eQCcategory | MyMoneyReport::eQCaccount,
                      MyMoneyTransactionFilter::lastFiscalYear,
                      MyMoneyReport::eDetailAll,
                      i18n("Tax Transactions by Payee Last Fiscal Year"),
                      i18n("Default Report")
                    ));
     list.back().setTax(true);
     groups.push_back(list);
   }
   {
     ReportGroup list("Budgeting", i18n("Budgeting"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudgetActual,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::yearToDate,
                      MyMoneyReport::eDetailAll,
                      i18n("Budgeted vs. Actual This Year"),
                      i18n("Default Report")
                    ));
     list.back().setShowingRowTotals(true);
     list.back().setBudget("Any", true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudgetActual,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::yearToMonth,
                      MyMoneyReport::eDetailAll,
                      i18n("Budgeted vs. Actual This Year (YTM)"),
                      i18n("Default Report")
                    ));
     list.back().setShowingRowTotals(true);
     list.back().setBudget("Any", true);
     // in case we're in January, we show the last year
     if (QDate::currentDate().month() == 1) {
       list.back().setDateFilter(MyMoneyTransactionFilter::lastYear);
     }
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudgetActual,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentMonth,
                      MyMoneyReport::eDetailAll,
                      i18n("Monthly Budgeted vs. Actual"),
                      i18n("Default Report")
                    ));
     list.back().setBudget("Any", true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudgetActual,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentYear,
                      MyMoneyReport::eDetailAll,
                      i18n("Yearly Budgeted vs. Actual"),
                      i18n("Default Report")
                    ));
     list.back().setBudget("Any", true);
     list.back().setShowingRowTotals(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudget,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentMonth,
                      MyMoneyReport::eDetailAll,
                      i18n("Monthly Budget"),
                      i18n("Default Report")
                    ));
     list.back().setBudget("Any", false);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudget,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentYear,
                      MyMoneyReport::eDetailAll,
                      i18n("Yearly Budget"),
                      i18n("Default Report")
                    ));
     list.back().setBudget("Any", false);
     list.back().setShowingRowTotals(true);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eBudgetActual,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentYear,
                      MyMoneyReport::eDetailGroup,
                      i18n("Yearly Budgeted vs Actual Graph"),
                      i18n("Default Report")
                    ));
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setBudget("Any", true);
     list.back().setChartType(MyMoneyReport::eChartLine);
 
     groups.push_back(list);
   }
   {
     ReportGroup list("Forecast", i18n("Forecast"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::next12Months,
                      MyMoneyReport::eDetailTop,
                      i18n("Forecast By Month"),
                      i18n("Default Report")
                    ));
     list.back().setIncludingForecast(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::nextQuarter,
                      MyMoneyReport::eDetailTop,
                      i18n("Forecast Next Quarter"),
                      i18n("Default Report")
                    ));
     list.back().setColumnsAreDays(true);
     list.back().setIncludingForecast(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eExpenseIncome,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::currentYear,
                      MyMoneyReport::eDetailTop,
                      i18n("Income and Expenses Forecast This Year"),
                      i18n("Default Report")
                    ));
     list.back().setIncludingForecast(true);
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAssetLiability,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::next3Months,
                      MyMoneyReport::eDetailTotal,
                      i18n("Net Worth Forecast Graph"),
                      i18n("Default Report")
                    ));
     list.back().setColumnsAreDays(true);
     list.back().setIncludingForecast(true);
     list.back().setChartByDefault(true);
     list.back().setChartGridLines(false);
     list.back().setChartType(MyMoneyReport::eChartLine);
     groups.push_back(list);
   }
   {
     ReportGroup list("Information", i18n("General Information"));
 
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eSchedule,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::next12Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Schedule Information"),
                      i18n("Default Report")
                    ));
     list.back().setDetailLevel(MyMoneyReport::eDetailAll);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eSchedule,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::next12Months,
                      MyMoneyReport::eDetailAll,
                      i18n("Schedule Summary Information"),
                      i18n("Default Report")
                    ));
     list.back().setDetailLevel(MyMoneyReport::eDetailTop);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountInfo,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::today,
                      MyMoneyReport::eDetailAll,
                      i18n("Account Information"),
                      i18n("Default Report")
                    ));
     list.back().setConvertCurrency(false);
     list.push_back(MyMoneyReport(
                      MyMoneyReport::eAccountLoanInfo,
-                     MyMoneyReport::eMonths,
+                     MyMoneyReport::Column::Months,
                      MyMoneyTransactionFilter::today,
                      MyMoneyReport::eDetailAll,
                      i18n("Loan Information"),
                      i18n("Default Report")
                    ));
     list.back().setConvertCurrency(false);
     groups.push_back(list);
   }
 }
 
 bool KReportsView::columnsAlreadyAdjusted()
 {
   return m_columnsAlreadyAdjusted;
 }
 
 void KReportsView::setColumnsAlreadyAdjusted(bool adjusted)
 {
   m_columnsAlreadyAdjusted = adjusted;
 }
 
 void KReportsView::restoreTocExpandState(QMap<QString, bool>& expandStates)
 {
   for (int i = 0; i < m_tocTreeWidget->topLevelItemCount(); i++) {
     QTreeWidgetItem* item = m_tocTreeWidget->topLevelItem(i);
 
     if (item) {
       QString itemLabel = item->text(0);
 
       if (expandStates.contains(itemLabel)) {
         item->setExpanded(expandStates[itemLabel]);
       } else {
         item->setExpanded(false);
       }
     }
   }
 }
 
 // Make sure, that these definitions are only used within this file
 // this does not seem to be necessary, but when building RPMs the
 // build option 'final' is used and all CPP files are concatenated.
 // So it could well be, that in another CPP file these definitions
 // are also used.
 #undef VIEW_LEDGER
 #undef VIEW_SCHEDULE
 #undef VIEW_WELCOME
 #undef VIEW_HOME
 #undef VIEW_REPORTS