Added kmymoney

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

1 files changed, 1372 insertions, 0 deletions

diff --git a/kmymoney2/mymoney/mymoneyscheduled.cpp b/kmymoney2/mymoney/mymoneyscheduled.cpp
new file mode 100644
index 0000000..88b4c7b
--- /dev/null
+++ b/kmymoney2/mymoney/mymoneyscheduled.cpp
@@ -0,0 +1,1372 @@
+/***************************************************************************
+                          mymoneyscheduled.cpp
+                             -------------------
+    copyright            : (C) 2000-2002 by Michael Edwardes
+                           (C) 2007 by Thomas Baumgart
+    email                : mte@users.sourceforge.net
+                           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.                                   *
+ *                                                                         *
+ ***************************************************************************/
+// ----------------------------------------------------------------------------
+// QT Includes
+
+// ----------------------------------------------------------------------------
+// KDE Includes
+
+#include <klocale.h>
+
+// ----------------------------------------------------------------------------
+// Project Includes
+
+#include "mymoneyscheduled.h"
+#include "mymoneyexception.h"
+#include "mymoneyfile.h"
+
+MyMoneySchedule::MyMoneySchedule() :
+  MyMoneyObject()
+{
+  // Set up the default values
+  m_occurence = OCCUR_ANY;
+  m_occurenceMultiplier = 1;
+  m_type = TYPE_ANY;
+  m_paymentType = STYPE_ANY;
+  m_fixed = false;
+  m_autoEnter = false;
+  m_startDate = QDate();
+  m_endDate = QDate();
+  m_lastPayment = QDate();
+  m_weekendOption = MoveNothing;
+}
+
+MyMoneySchedule::MyMoneySchedule(const QString& name, typeE type,
+                                 occurenceE occurence, int occurenceMultiplier,
+                                 paymentTypeE paymentType,
+                                 const QDate& /* startDate */,
+                                 const QDate& endDate,
+                                 bool fixed, bool autoEnter) :
+  MyMoneyObject()
+{
+  // Set up the default values
+  m_name = name;
+  m_occurence = occurence;
+  m_occurenceMultiplier = occurenceMultiplier;
+  simpleToCompoundOccurence(m_occurenceMultiplier,m_occurence);
+  m_type = type;
+  m_paymentType = paymentType;
+  m_fixed = fixed;
+  m_autoEnter = autoEnter;
+  m_startDate = QDate();
+  m_endDate = endDate;
+  m_lastPayment = QDate();
+  m_weekendOption = MoveNothing;
+}
+
+MyMoneySchedule::MyMoneySchedule(const QDomElement& node) :
+  MyMoneyObject(node)
+{
+  if("SCHEDULED_TX" != node.tagName())
+    throw new MYMONEYEXCEPTION("Node was not SCHEDULED_TX");
+
+  m_name = node.attribute("name");
+  m_startDate = stringToDate(node.attribute("startDate"));
+  m_endDate = stringToDate(node.attribute("endDate"));
+  m_lastPayment = stringToDate(node.attribute("lastPayment"));
+
+  m_type = static_cast<MyMoneySchedule::typeE>(node.attribute("type").toInt());
+  m_paymentType = static_cast<MyMoneySchedule::paymentTypeE>(node.attribute("paymentType").toInt());
+  m_occurence = static_cast<MyMoneySchedule::occurenceE>(node.attribute("occurence").toInt());
+  m_occurenceMultiplier = node.attribute("occurenceMultiplier", "1").toInt();
+  // Convert to compound occurence
+  simpleToCompoundOccurence(m_occurenceMultiplier,m_occurence);
+  m_autoEnter = static_cast<bool>(node.attribute("autoEnter").toInt());
+  m_fixed = static_cast<bool>(node.attribute("fixed").toInt());
+  m_weekendOption = static_cast<MyMoneySchedule::weekendOptionE>(node.attribute("weekendOption").toInt());
+
+  // read in the associated transaction
+  QDomNodeList nodeList = node.elementsByTagName("TRANSACTION");
+  if(nodeList.count() == 0)
+    throw new MYMONEYEXCEPTION("SCHEDULED_TX has no TRANSACTION node");
+
+  setTransaction(MyMoneyTransaction(nodeList.item(0).toElement(), false), true);
+
+  // some old versions did not remove the entry date and post date fields
+  // in the schedule. So if this is the case, we deal with a very old transaction
+  // and can't use the post date field as next due date. Hence, we wipe it out here
+  if(m_transaction.entryDate().isValid()) {
+    m_transaction.setPostDate(QDate());
+    m_transaction.setEntryDate(QDate());
+  }
+
+  // readin the recorded payments
+  nodeList = node.elementsByTagName("PAYMENTS");
+  if(nodeList.count() > 0) {
+    nodeList = nodeList.item(0).toElement().elementsByTagName("PAYMENT");
+    for(unsigned int i = 0; i < nodeList.count(); ++i) {
+      m_recordedPayments << stringToDate(nodeList.item(i).toElement().attribute("date"));
+    }
+  }
+
+  // if the next due date is not set (comes from old version)
+  // then set it up the old way
+  if(!nextDueDate().isValid() && !m_lastPayment.isValid()) {
+    m_transaction.setPostDate(m_startDate);
+    // clear it, because the schedule has never been used
+    m_startDate = QDate();
+  }
+
+  // There are reports that lastPayment and nextDueDate are identical or
+  // that nextDueDate is older than lastPayment. This could
+  // be caused by older versions of the application. In this case, we just
+  // clear out the nextDueDate and let it calculate from the lastPayment.
+  if(nextDueDate().isValid() && nextDueDate() <= m_lastPayment) {
+    m_transaction.setPostDate(QDate());
+  }
+
+  if(!nextDueDate().isValid()) {
+    m_transaction.setPostDate(m_startDate);
+    m_transaction.setPostDate(nextPayment(m_lastPayment.addDays(1)));
+  }
+}
+
+MyMoneySchedule::MyMoneySchedule(const QString& id, const MyMoneySchedule& right) :
+  MyMoneyObject(id)
+{
+  *this = right;
+  setId(id);
+}
+
+MyMoneySchedule::occurenceE MyMoneySchedule::occurence(void) const
+{
+  MyMoneySchedule::occurenceE occ = m_occurence;
+  int mult = m_occurenceMultiplier;
+  compoundToSimpleOccurence(mult, occ);
+  return occ;
+}
+
+void MyMoneySchedule::setStartDate(const QDate& date)
+{
+  m_startDate = date;
+}
+
+void MyMoneySchedule::setPaymentType(paymentTypeE type)
+{
+  m_paymentType = type;
+}
+
+void MyMoneySchedule::setFixed(bool fixed)
+{
+  m_fixed = fixed;
+}
+
+void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction)
+{
+  setTransaction(transaction, false);
+}
+
+void MyMoneySchedule::setTransaction(const MyMoneyTransaction& transaction, bool noDateCheck)
+{
+  MyMoneyTransaction t = transaction;
+  if(!noDateCheck) {
+    // don't allow a transaction that has no due date
+    // if we get something like that, then we use the
+    // the current next due date. If that is also invalid
+    // we can't help it.
+    if(!t.postDate().isValid()) {
+      t.setPostDate(m_transaction.postDate());
+    }
+
+    if(!t.postDate().isValid())
+      return;
+  }
+
+  // make sure to clear out some unused information in scheduled transactions
+  // we need to do this for the case that the transaction passed as argument
+  // is a matched or imported transaction.
+  QValueList<MyMoneySplit> splits = t.splits();
+  if(splits.count() > 0) {
+    QValueList<MyMoneySplit>::const_iterator it_s;
+    for(it_s = splits.begin(); it_s != splits.end(); ++it_s) {
+      MyMoneySplit s = *it_s;
+      // clear out the bankID
+      if(!(*it_s).bankID().isEmpty()) {
+        s.setBankID(QString());
+        t.modifySplit(s);
+      }
+
+      // only clear payees from second split onwards
+      if(it_s == splits.begin())
+        continue;
+
+      if(!(*it_s).payeeId().isEmpty()) {
+        // but only if the split references an income/expense category
+        MyMoneyFile* file = MyMoneyFile::instance();
+        // some unit tests don't have a storage attached, so we
+        // simply skip the test
+        // Don't check for accounts with an id of 'Phony-ID' which is used
+        // internally for non-existing accounts (during creation of accounts)
+        if(file->storageAttached() && s.accountId() != QString("Phony-ID")) {
+          MyMoneyAccount acc = file->account(s.accountId());
+          if(acc.isIncomeExpense()) {
+            s.setPayeeId(QString());
+            t.modifySplit(s);
+          }
+        }
+      }
+    }
+  }
+
+  m_transaction = t;
+  // make sure that the transaction does not have an id so that we can enter
+  // it into the engine
+  m_transaction.clearId();
+}
+
+void MyMoneySchedule::setEndDate(const QDate& date)
+{
+  m_endDate = date;
+}
+
+void MyMoneySchedule::setAutoEnter(bool autoenter)
+{
+  m_autoEnter = autoenter;
+}
+
+const QDate& MyMoneySchedule::startDate(void) const
+{
+  if(m_startDate.isValid())
+    return m_startDate;
+  return nextDueDate();
+}
+
+const QDate& MyMoneySchedule::nextDueDate(void) const
+{
+  return m_transaction.postDate();
+}
+
+QDate MyMoneySchedule::adjustedNextDueDate(void) const
+{
+  if(isFinished())
+    return QDate();
+
+  return adjustedDate(nextDueDate(), weekendOption());
+}
+
+QDate MyMoneySchedule::adjustedDate(QDate date, weekendOptionE option) const
+{
+  if (option == MyMoneySchedule::MoveNothing)
+    return date;
+
+  int step = 1;
+  if (option == MyMoneySchedule::MoveFriday)
+    step = -1;
+
+  while (date.dayOfWeek() > 5)
+    date = date.addDays(step);
+
+  return date;
+}
+
+void MyMoneySchedule::setNextDueDate(const QDate& date)
+{
+  if(date.isValid()) {
+    m_transaction.setPostDate(date);
+    m_startDate = date;
+  }
+}
+
+void MyMoneySchedule::setLastPayment(const QDate& date)
+{
+  // Delete all payments older than date
+  QValueList<QDate>::Iterator it;
+  QValueList<QDate> delList;
+
+  for (it=m_recordedPayments.begin(); it!=m_recordedPayments.end(); ++it)
+  {
+    if (*it < date || !date.isValid())
+      delList.append(*it);
+  }
+
+  for (it=delList.begin(); it!=delList.end(); ++it)
+  {
+    m_recordedPayments.remove(*it);
+  }
+
+  m_lastPayment = date;
+  if(!m_startDate.isValid())
+    m_startDate = date;
+}
+
+void MyMoneySchedule::setName(const QString& nm)
+{
+  m_name = nm;
+}
+
+void MyMoneySchedule::setOccurence(occurenceE occ)
+{
+  MyMoneySchedule::occurenceE occ2 = occ;
+  int mult = 1;
+  simpleToCompoundOccurence(mult, occ2);
+  setOccurencePeriod( occ2 );
+  setOccurenceMultiplier( mult );
+}
+
+void MyMoneySchedule::setOccurencePeriod(occurenceE occ)
+{
+  m_occurence = occ;
+}
+
+void MyMoneySchedule::setOccurenceMultiplier(int occmultiplier)
+{
+  m_occurenceMultiplier = occmultiplier < 1 ? 1 : occmultiplier;
+}
+
+void MyMoneySchedule::setType(typeE type)
+{
+  m_type = type;
+}
+
+void MyMoneySchedule::validate(bool id_check) const
+{
+  /* Check the supplied instance is valid...
+   *
+   * To be valid it must not have the id set and have the following fields set:
+   *
+   * m_occurence
+   * m_type
+   * m_startDate
+   * m_paymentType
+   * m_transaction
+   *   the transaction must contain at least one split (two is better ;-)  )
+   */
+  if (id_check && !m_id.isEmpty())
+    throw new MYMONEYEXCEPTION("ID for schedule not empty when required");
+
+  if(m_occurence == OCCUR_ANY)
+    throw new MYMONEYEXCEPTION("Invalid occurence type for schedule");
+
+  if(m_type == TYPE_ANY)
+    throw new MYMONEYEXCEPTION("Invalid type for schedule");
+
+  if(!nextDueDate().isValid())
+    throw new MYMONEYEXCEPTION("Invalid next due date for schedule");
+
+  if(m_paymentType == STYPE_ANY)
+    throw new MYMONEYEXCEPTION("Invalid payment type for schedule");
+
+  if(m_transaction.splitCount() == 0)
+    throw new MYMONEYEXCEPTION("Scheduled transaction does not contain splits");
+
+  // Check the payment types
+  switch (m_type)
+  {
+    case TYPE_BILL:
+      if (m_paymentType == STYPE_DIRECTDEPOSIT || m_paymentType == STYPE_MANUALDEPOSIT)
+        throw new MYMONEYEXCEPTION("Invalid payment type for bills");
+      break;
+
+    case TYPE_DEPOSIT:
+      if (m_paymentType == STYPE_DIRECTDEBIT || m_paymentType == STYPE_WRITECHEQUE)
+        throw new MYMONEYEXCEPTION("Invalid payment type for deposits");
+      break;
+
+    case TYPE_ANY:
+      throw new MYMONEYEXCEPTION("Invalid type ANY");
+      break;
+
+    case TYPE_TRANSFER:
+//        if (m_paymentType == STYPE_DIRECTDEPOSIT || m_paymentType == STYPE_MANUALDEPOSIT)
+//          return false;
+      break;
+
+    case TYPE_LOANPAYMENT:
+      break;
+  }
+}
+
+QDate MyMoneySchedule::adjustedNextPayment(const QDate& refDate) const
+{
+  QDate date(nextPayment(refDate));
+  return date.isValid() ? adjustedDate(date, weekendOption()) : date;
+}
+
+QDate MyMoneySchedule::nextPayment(const QDate& refDate) const
+{
+  // if the enddate is valid and it is before the reference date,
+  // then there will be no more payments.
+  if(m_endDate.isValid() && m_endDate < refDate) {
+    return QDate();
+  }
+
+  QDate paymentDate(nextDueDate());
+
+  if(refDate >= paymentDate) {
+    switch (m_occurence)
+    {
+      case OCCUR_ONCE:
+        // if the lastPayment is already set, then there will be no more payments
+        // otherwise, the start date is the payment date
+        if(m_lastPayment.isValid())
+          return QDate();
+        // if the only payment should have been prior to the reference date,
+        // then don't show it
+        if(paymentDate < refDate)
+          return QDate();
+        break;
+
+      case OCCUR_DAILY:
+        paymentDate = refDate.addDays(m_occurenceMultiplier);
+        break;
+
+      case OCCUR_WEEKLY:
+        {
+          int step = 7*m_occurenceMultiplier;
+          do {
+            paymentDate = paymentDate.addDays(step);
+          }
+          while (paymentDate <= refDate);
+        }
+        break;
+
+      case OCCUR_EVERYHALFMONTH:
+        do
+        {
+           paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier);
+        }
+        while (paymentDate <= refDate);
+        break;
+
+      case OCCUR_MONTHLY:
+        do {
+          paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
+          fixDate(paymentDate);
+        }
+        while (paymentDate <= refDate);
+        break;
+
+      case OCCUR_YEARLY:
+        do {
+          paymentDate = paymentDate.addYears(m_occurenceMultiplier);
+          fixDate(paymentDate);
+        }
+        while (paymentDate <= refDate);
+        break;
+
+      case OCCUR_ANY:
+      default:
+        paymentDate = QDate();
+        break;
+    }
+  }
+  if(paymentDate.isValid()) {
+    if(m_endDate.isValid() && paymentDate > m_endDate)
+      paymentDate = QDate();
+  }
+
+  if (paymentDate.isValid() && m_recordedPayments.contains(paymentDate))
+    paymentDate = nextPayment(paymentDate);
+
+  return paymentDate;
+}
+
+QValueList<QDate> MyMoneySchedule::paymentDates(const QDate& _startDate, const QDate& _endDate) const
+{
+  QDate paymentDate(nextDueDate());
+  QValueList<QDate> theDates;
+
+  QDate endDate(_endDate);
+  if ( willEnd() && m_endDate < endDate )
+    endDate = m_endDate;
+
+  weekendOptionE option(weekendOption());
+  QDate start_date(adjustedDate(startDate(), option));
+  // if the period specified by the parameters and the period
+  // defined for this schedule don't overlap, then the list remains empty
+  if ((willEnd() && m_endDate < _startDate)
+  || start_date > endDate)
+    return theDates;
+
+  QDate date(adjustedDate(paymentDate, option));
+
+  switch (m_occurence)
+  {
+    case OCCUR_ONCE:
+      if (start_date >= _startDate && start_date <= endDate)
+        theDates.append(start_date);
+      break;
+
+    case OCCUR_DAILY:
+      while (date.isValid() && (date <= endDate))
+      {
+        if (date >= _startDate)
+          theDates.append(date);
+        paymentDate = paymentDate.addDays(m_occurenceMultiplier);
+        date = adjustedDate(paymentDate, option);
+      }
+      break;
+
+    case OCCUR_WEEKLY:
+      {
+        int step = 7*m_occurenceMultiplier;
+        while (date.isValid() && (date <= endDate))
+        {
+          if (date >= _startDate)
+            theDates.append(date);
+          paymentDate = paymentDate.addDays(step);
+          date = adjustedDate(paymentDate, option);
+        }
+      }
+      break;
+
+    case OCCUR_EVERYHALFMONTH:
+      while (date.isValid() && (date <= endDate))
+      {
+        if (date >= _startDate)
+          theDates.append(date);
+        paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier);
+        date = adjustedDate(paymentDate, option);
+      }
+      break;
+
+    case OCCUR_MONTHLY:
+      while (date.isValid() && (date <= endDate))
+      {
+        if (date >= _startDate)
+          theDates.append(date);
+        paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
+        fixDate(paymentDate);
+        date = adjustedDate(paymentDate, option);
+      }
+      break;
+
+    case OCCUR_YEARLY:
+      while (date.isValid() && (date <= endDate))
+      {
+        if (date >= _startDate)
+          theDates.append(date);
+        paymentDate = paymentDate.addYears(m_occurenceMultiplier);
+        fixDate(paymentDate);
+        date = adjustedDate(paymentDate, option);
+      }
+      break;
+
+    case OCCUR_ANY:
+    default:
+      break;
+  }
+
+  return theDates;
+}
+
+bool MyMoneySchedule::operator <(const MyMoneySchedule& right) const
+{
+  return adjustedNextDueDate() < right.adjustedNextDueDate();
+}
+
+bool MyMoneySchedule::operator ==(const MyMoneySchedule& right) const
+{
+  if (  MyMoneyObject::operator==(right) &&
+        m_occurence == right.m_occurence &&
+        m_occurenceMultiplier == right.m_occurenceMultiplier &&
+        m_type == right.m_type &&
+        m_startDate == right.m_startDate &&
+        m_paymentType == right.m_paymentType &&
+        m_fixed == right.m_fixed &&
+        m_transaction == right.m_transaction &&
+        m_endDate == right.m_endDate &&
+        m_autoEnter == right.m_autoEnter &&
+        m_lastPayment == right.m_lastPayment &&
+        ((m_name.length() == 0 && right.m_name.length() == 0) || (m_name == right.m_name)))
+    return true;
+  return false;
+}
+
+int MyMoneySchedule::transactionsRemaining(void) const
+{
+  int counter=0;
+
+  if (m_endDate.isValid())
+  {
+    QValueList<QDate> dates = paymentDates(m_lastPayment, m_endDate);
+    // Dont include the last payment so -1
+    counter = dates.count();
+  }
+  return counter;
+}
+
+MyMoneyAccount MyMoneySchedule::account(int cnt) const
+{
+  QValueList<MyMoneySplit> splits = m_transaction.splits();
+  QValueList<MyMoneySplit>::ConstIterator it;
+  MyMoneyFile* file = MyMoneyFile::instance();
+  MyMoneyAccount acc;
+
+  // search the first asset or liability account
+  for(it = splits.begin(); it != splits.end() && (acc.id().isEmpty() || cnt); ++it) {
+    try {
+      acc = file->account((*it).accountId());
+      if(acc.isAssetLiability())
+          --cnt;
+
+      if(!cnt)
+        return acc;
+    } catch(MyMoneyException *e) {
+      qWarning("Schedule '%s' references unknown account '%s'", id().data(),   (*it).accountId().data());
+      delete e;
+      return MyMoneyAccount();
+    }
+  }
+
+  return MyMoneyAccount();
+}
+
+QDate MyMoneySchedule::dateAfter(int transactions) const
+{
+  int counter=1;
+  QDate paymentDate(startDate());
+
+  if (transactions<=0)
+    return paymentDate;
+
+  switch (m_occurence)
+  {
+    case OCCUR_ONCE:
+      break;
+
+    case OCCUR_DAILY:
+      while (counter++ < transactions)
+        paymentDate = paymentDate.addDays(m_occurenceMultiplier);
+      break;
+
+    case OCCUR_WEEKLY:
+      {
+        int step = 7 * m_occurenceMultiplier;
+        while (counter++ < transactions)
+          paymentDate = paymentDate.addDays(step);
+      }
+      break;
+
+    case OCCUR_EVERYHALFMONTH:
+      paymentDate = addHalfMonths(paymentDate,m_occurenceMultiplier*(transactions-1));
+      break;
+
+    case OCCUR_MONTHLY:
+      while (counter++ < transactions)
+        paymentDate = paymentDate.addMonths(m_occurenceMultiplier);
+      break;
+
+    case OCCUR_YEARLY:
+      while (counter++ < transactions)
+        paymentDate = paymentDate.addYears(m_occurenceMultiplier);
+      break;
+
+    case OCCUR_ANY:
+    default:
+      break;
+  }
+
+  return paymentDate;
+}
+
+bool MyMoneySchedule::isOverdue() const
+{
+  if (isFinished())
+    return false;
+
+  if(adjustedNextDueDate() >= QDate::currentDate())
+    return false;
+
+  return true;
+}
+
+bool MyMoneySchedule::isFinished() const
+{
+  if(!m_lastPayment.isValid())
+    return false;
+
+  if (m_endDate.isValid()) {
+    if(m_lastPayment >= m_endDate
+    || !nextDueDate().isValid()
+    || nextDueDate() > m_endDate)
+      return true;
+  }
+
+  // Check to see if its a once off payment
+  if (m_occurence == MyMoneySchedule::OCCUR_ONCE)
+    return true;
+
+  return false;
+}
+
+bool MyMoneySchedule::hasRecordedPayment(const QDate& date) const
+{
+  // m_lastPayment should always be > recordedPayments()
+  if (m_lastPayment.isValid() && m_lastPayment >= date)
+    return true;
+
+  if (m_recordedPayments.contains(date))
+    return true;
+
+  return false;
+}
+
+void MyMoneySchedule::recordPayment(const QDate& date)
+{
+  m_recordedPayments.append(date);
+}
+
+void MyMoneySchedule::setWeekendOption(const weekendOptionE option)
+{
+  // make sure only valid values are used. Invalid defaults to MoveNothing.
+  switch(option) {
+    case MoveFriday:
+    case MoveMonday:
+      m_weekendOption = option;
+      break;
+
+    default:
+      m_weekendOption = MoveNothing;
+      break;
+  }
+}
+
+void MyMoneySchedule::fixDate(QDate& date) const
+{
+  QDate fixDate(m_startDate);
+  if(fixDate.isValid()
+  && date.day() != fixDate.day()
+  && QDate::isValid(date.year(), date.month(), fixDate.day())) {
+    date.setYMD(date.year(), date.month(), fixDate.day());
+  }
+}
+
+void MyMoneySchedule::writeXML(QDomDocument& document, QDomElement& parent) const
+{
+  QDomElement el = document.createElement("SCHEDULED_TX");
+
+  writeBaseXML(document, el);
+
+  el.setAttribute("name", m_name);
+  el.setAttribute("type", m_type);
+  el.setAttribute("occurence", m_occurence);
+  el.setAttribute("occurenceMultiplier", m_occurenceMultiplier);
+  el.setAttribute("paymentType", m_paymentType);
+  el.setAttribute("startDate", dateToString(m_startDate));
+  el.setAttribute("endDate", dateToString(m_endDate));
+  el.setAttribute("fixed", m_fixed);
+  el.setAttribute("autoEnter", m_autoEnter);
+  el.setAttribute("lastPayment", dateToString(m_lastPayment));
+  el.setAttribute("weekendOption", m_weekendOption);
+
+  //store the payment history for this scheduled task.
+  QValueList<QDate> payments = recordedPayments();
+  QValueList<QDate>::ConstIterator it;
+  QDomElement paymentsElement = document.createElement("PAYMENTS");
+  for (it=payments.begin(); it!=payments.end(); ++it) {
+    QDomElement paymentEntry = document.createElement("PAYMENT");
+    paymentEntry.setAttribute("date", dateToString(*it));
+    paymentsElement.appendChild(paymentEntry);
+  }
+  el.appendChild(paymentsElement);
+
+  //store the transaction data for this task.
+  m_transaction.writeXML(document, el);
+
+  parent.appendChild(el);
+}
+
+bool MyMoneySchedule::hasReferenceTo(const QString& id) const
+{
+  return m_transaction.hasReferenceTo(id);
+}
+
+QString MyMoneySchedule::occurenceToString() const
+{
+  return occurenceToString( occurenceMultiplier(), occurencePeriod() );
+}
+
+QString MyMoneySchedule::occurenceToString(occurenceE occurence)
+{
+  QString occurenceString = I18N_NOOP("Any");
+
+  if(occurence == MyMoneySchedule::OCCUR_ONCE)
+    occurenceString = I18N_NOOP("Once");
+  else if(occurence == MyMoneySchedule::OCCUR_DAILY)
+    occurenceString = I18N_NOOP("Daily");
+  else if(occurence == MyMoneySchedule::OCCUR_WEEKLY)
+    occurenceString = I18N_NOOP("Weekly");
+  else if(occurence == MyMoneySchedule::OCCUR_FORTNIGHTLY)
+    occurenceString = I18N_NOOP("Fortnightly");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERWEEK)
+    occurenceString = I18N_NOOP("Every other week");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
+    occurenceString = I18N_NOOP("Every half month");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEWEEKS)
+    occurenceString = I18N_NOOP("Every three weeks");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURWEEKS)
+    occurenceString = I18N_NOOP("Every four weeks");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS)
+    occurenceString = I18N_NOOP("Every thirty days");
+  else if(occurence == MyMoneySchedule::OCCUR_MONTHLY)
+    occurenceString = I18N_NOOP("Monthly");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS)
+    occurenceString = I18N_NOOP("Every eight weeks");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERMONTH)
+    occurenceString = I18N_NOOP("Every two months");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEMONTHS)
+    occurenceString = I18N_NOOP("Every three months");
+  else if(occurence == MyMoneySchedule::OCCUR_QUARTERLY)
+    occurenceString = I18N_NOOP("Quarterly");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURMONTHS)
+    occurenceString = I18N_NOOP("Every four months");
+  else if(occurence == MyMoneySchedule::OCCUR_TWICEYEARLY)
+    occurenceString = I18N_NOOP("Twice yearly");
+  else if(occurence == MyMoneySchedule::OCCUR_YEARLY)
+    occurenceString = I18N_NOOP("Yearly");
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERYEAR)
+    occurenceString = I18N_NOOP("Every other year");
+  return occurenceString;
+}
+
+QString MyMoneySchedule::occurenceToString(int mult, occurenceE type)
+{
+  QString occurenceString = I18N_NOOP("Any");
+
+  if (type == MyMoneySchedule::OCCUR_ONCE)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Once"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("%1 times").arg(mult));
+    }
+  else if(type == MyMoneySchedule::OCCUR_DAILY)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Daily"); break;
+      case 30: occurenceString = I18N_NOOP("Every thirty days"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("Every %1 days").arg(mult));
+    }
+  else if(type == MyMoneySchedule::OCCUR_WEEKLY)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Weekly"); break;
+      case 2: occurenceString = I18N_NOOP("Every other week"); break;
+      case 3: occurenceString = I18N_NOOP("Every three weeks"); break;
+      case 4: occurenceString = I18N_NOOP("Every four weeks"); break;
+      case 8: occurenceString = I18N_NOOP("Every eight weeks"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("Every %1 weeks").arg(mult));
+    }
+  else if(type == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Every half month"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("Every %1 half months").arg(mult));
+    }
+  else if(type == MyMoneySchedule::OCCUR_MONTHLY)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Monthly"); break;
+      case 2: occurenceString = I18N_NOOP("Every two months"); break;
+      case 3: occurenceString = I18N_NOOP("Every three months"); break;
+      case 4: occurenceString = I18N_NOOP("Every four months"); break;
+      case 6: occurenceString = I18N_NOOP("Twice yearly"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("Every %1 months").arg(mult));
+    }
+  else if(type == MyMoneySchedule::OCCUR_YEARLY)
+    switch (mult)
+    {
+      case 1: occurenceString = I18N_NOOP("Yearly"); break;
+      case 2: occurenceString = I18N_NOOP("Every other year"); break;
+      default: occurenceString = I18N_NOOP(static_cast<QString>("Every %1 years").arg(mult));
+    }
+  return occurenceString;
+}
+
+QString MyMoneySchedule::occurencePeriodToString(MyMoneySchedule::occurenceE type)
+{
+  QString occurenceString = I18N_NOOP("Any");
+
+  if(type == MyMoneySchedule::OCCUR_ONCE)
+    occurenceString = I18N_NOOP("Once");
+  else if(type == MyMoneySchedule::OCCUR_DAILY)
+    occurenceString = I18N_NOOP("Day");
+  else if(type == MyMoneySchedule::OCCUR_WEEKLY)
+    occurenceString = I18N_NOOP("Week");
+  else if(type == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
+    occurenceString = I18N_NOOP("Half-month");
+  else if(type == MyMoneySchedule::OCCUR_MONTHLY)
+    occurenceString = I18N_NOOP("Month");
+  else if(type == MyMoneySchedule::OCCUR_YEARLY)
+    occurenceString = I18N_NOOP("Year");
+  return occurenceString;
+}
+
+QString MyMoneySchedule::scheduleTypeToString(MyMoneySchedule::typeE type)
+{
+  QString text;
+
+  switch (type) {
+    case MyMoneySchedule::TYPE_BILL:
+      text = I18N_NOOP("Bill");
+      break;
+    case MyMoneySchedule::TYPE_DEPOSIT:
+      text = I18N_NOOP("Deposit");
+      break;
+    case MyMoneySchedule::TYPE_TRANSFER:
+      text = I18N_NOOP("Transfer");
+      break;
+    case MyMoneySchedule::TYPE_LOANPAYMENT:
+      text = I18N_NOOP("Loan payment");
+      break;
+    case MyMoneySchedule::TYPE_ANY:
+    default:
+      text = I18N_NOOP("Unknown");
+  }
+  return text;
+}
+
+
+QString MyMoneySchedule::paymentMethodToString(MyMoneySchedule::paymentTypeE paymentType)
+{
+  QString text;
+
+  switch (paymentType) {
+    case MyMoneySchedule::STYPE_DIRECTDEBIT:
+      text = I18N_NOOP("Direct debit");
+      break;
+    case MyMoneySchedule::STYPE_DIRECTDEPOSIT:
+      text = I18N_NOOP("Direct deposit");
+      break;
+    case MyMoneySchedule::STYPE_MANUALDEPOSIT:
+      text = I18N_NOOP("Manual deposit");
+      break;
+    case MyMoneySchedule::STYPE_OTHER:
+      text = I18N_NOOP("Other");
+      break;
+    case MyMoneySchedule::STYPE_WRITECHEQUE:
+      text = I18N_NOOP("Write check");
+      break;
+    case MyMoneySchedule::STYPE_STANDINGORDER:
+      text = I18N_NOOP("Standing order");
+      break;
+    case MyMoneySchedule::STYPE_BANKTRANSFER:
+      text = I18N_NOOP("Bank transfer");
+      break;
+    case MyMoneySchedule::STYPE_ANY:
+      text = I18N_NOOP("Any (Error)");
+      break;
+  }
+  return text;
+}
+
+QString MyMoneySchedule::weekendOptionToString(MyMoneySchedule::weekendOptionE weekendOption)
+{
+  QString text;
+
+  switch (weekendOption) {
+    case MyMoneySchedule::MoveFriday:
+      text = I18N_NOOP("Change the date to the previous Friday");
+      break;
+    case MyMoneySchedule::MoveMonday:
+      text = I18N_NOOP("Change the date to the next Monday");
+      break;
+    case MyMoneySchedule::MoveNothing:
+      text = I18N_NOOP("Do Nothing");
+      break;
+  }
+  return text;
+}
+
+// until we don't have the means to store the value
+// of the variation, we default to 10% in case this
+// scheduled transaction is marked 'not fixed'.
+//
+// ipwizard 2009-04-18
+
+int MyMoneySchedule::variation(void) const
+{
+  int rc = 0;
+  if(!isFixed()) {
+    rc = 10;
+#if 0
+    QString var = value("kmm-variation");
+    if(!var.isEmpty())
+      rc = var.toInt();
+#endif
+  }
+  return rc;
+}
+
+void MyMoneySchedule::setVariation(int var)
+{
+#if 0
+  deletePair("kmm-variation");
+  if(var != 0)
+    setValue("kmm-variation", QString("%1").arg(var));
+#endif
+}
+
+int MyMoneySchedule::eventsPerYear(MyMoneySchedule::occurenceE occurence)
+{
+  int rc = 0;
+
+  switch(occurence) {
+    case MyMoneySchedule::OCCUR_DAILY:
+      rc = 365;
+      break;
+    case MyMoneySchedule::OCCUR_WEEKLY:
+      rc = 52;
+      break;
+    case MyMoneySchedule::OCCUR_FORTNIGHTLY:
+      rc = 26;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYOTHERWEEK:
+      rc = 26;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYHALFMONTH:
+      rc = 24;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYTHREEWEEKS:
+      rc = 17;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYFOURWEEKS:
+      rc = 13;
+      break;
+    case MyMoneySchedule::OCCUR_MONTHLY:
+    case MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS:
+      rc = 12;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS:
+      rc = 6;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYOTHERMONTH:
+      rc = 6;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYTHREEMONTHS:
+    case MyMoneySchedule::OCCUR_QUARTERLY:
+      rc = 4;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYFOURMONTHS:
+      rc = 3;
+      break;
+    case MyMoneySchedule::OCCUR_TWICEYEARLY:
+      rc = 2;
+      break;
+    case MyMoneySchedule::OCCUR_YEARLY:
+      rc = 1;
+      break;
+    default:
+      qWarning("Occurence not supported by financial calculator");
+  }
+
+  return rc;
+}
+
+int MyMoneySchedule::daysBetweenEvents(MyMoneySchedule::occurenceE occurence)
+{
+  int rc = 0;
+
+  switch(occurence) {
+    case MyMoneySchedule::OCCUR_DAILY:
+      rc = 1;
+      break;
+    case MyMoneySchedule::OCCUR_WEEKLY:
+      rc = 7;
+      break;
+    case MyMoneySchedule::OCCUR_FORTNIGHTLY:
+      rc = 14;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYOTHERWEEK:
+      rc = 14;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYHALFMONTH:
+      rc = 15;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYTHREEWEEKS:
+      rc = 21;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYFOURWEEKS:
+      rc = 28;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS:
+      rc = 30;
+      break;
+    case MyMoneySchedule::OCCUR_MONTHLY:
+      rc = 30;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS:
+      rc = 56;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYOTHERMONTH:
+      rc = 60;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYTHREEMONTHS:
+    case MyMoneySchedule::OCCUR_QUARTERLY:
+      rc = 90;
+      break;
+    case MyMoneySchedule::OCCUR_EVERYFOURMONTHS:
+      rc = 120;
+      break;
+    case MyMoneySchedule::OCCUR_TWICEYEARLY:
+      rc = 180;
+      break;
+    case MyMoneySchedule::OCCUR_YEARLY:
+      rc = 360;
+      break;
+    default:
+      qWarning("Occurence not supported by financial calculator");
+  }
+
+ return rc;
+}
+
+QDate MyMoneySchedule::addHalfMonths( QDate date, int mult ) const
+{
+  QDate newdate = date;
+  int d, dm;
+  if ( mult > 0 )
+  {
+    d = newdate.day();
+    if ( d <= 12 )
+    {
+      if ( mult % 2 == 0 )
+        newdate = newdate.addMonths(mult>>1);
+      else
+        newdate = newdate.addMonths(mult>>1).addDays(15);
+    }
+    else
+      for ( int i = 0; i < mult; i++ )
+      {
+        if ( d <= 13 )
+          newdate = newdate.addDays(15);
+        else
+        {
+          dm = newdate.daysInMonth();
+          if ( d == 14 )
+            newdate = newdate.addDays(( dm < 30 ) ? dm - d : 15);
+          else if ( d == 15 )
+            newdate = newdate.addDays(dm - d);
+          else if ( d == dm )
+            newdate = newdate.addDays(15 - d).addMonths(1);
+          else
+            newdate = newdate.addDays(-15).addMonths(1);
+        }
+        d = newdate.day();
+      }
+  }
+  else if ( mult < 0 ) // Go backwards
+    for ( int i = 0; i > mult; i-- )
+    {
+      d = newdate.day();
+      dm = newdate.daysInMonth();
+      if ( d > 15 )
+      {
+        dm = newdate.daysInMonth();
+        newdate = newdate.addDays( (d == dm) ? 15 - dm : -15);
+      }
+      else if ( d <= 13 )
+        newdate = newdate.addMonths(-1).addDays(15);
+      else if ( d == 15 )
+        newdate = newdate.addDays(-15);
+      else // 14
+      {
+        newdate = newdate.addMonths(-1);
+        dm = newdate.daysInMonth();
+        newdate = newdate.addDays(( dm < 30 ) ? dm - d : 15 );
+      }
+    }
+  return newdate;
+}
+
+MyMoneySchedule::occurenceE MyMoneySchedule::stringToOccurence(const QString& text)
+{
+  MyMoneySchedule::occurenceE occurence = MyMoneySchedule::OCCUR_ANY;
+  QString tmp = text.lower();
+
+  if(tmp == i18n("Once").lower())
+    occurence = MyMoneySchedule::OCCUR_ONCE;
+  else if(tmp == i18n("Daily").lower())
+    occurence = MyMoneySchedule::OCCUR_DAILY;
+  else if(tmp == i18n("Weekly").lower())
+    occurence = MyMoneySchedule::OCCUR_WEEKLY;
+  else if(tmp == i18n("Fortnightly").lower())
+    occurence = MyMoneySchedule::OCCUR_FORTNIGHTLY;
+  else if(tmp == i18n("Every other week").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYOTHERWEEK;
+  else if(tmp == i18n("Every half month").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYHALFMONTH;
+  else if(tmp == i18n("Every three weeks").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYTHREEWEEKS;
+  else if(tmp == i18n("Every four weeks").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYFOURWEEKS;
+  else if(tmp == i18n("Every thirty days").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS;
+  else if(tmp == i18n("Monthly").lower())
+    occurence = MyMoneySchedule::OCCUR_MONTHLY;
+  else if(tmp == i18n("Every eight weeks").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS;
+  else if(tmp == i18n("Every two months").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYOTHERMONTH;
+  else if(tmp == i18n("Every three months").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYTHREEMONTHS;
+  else if(tmp == i18n("Quarterly").lower())
+    occurence = MyMoneySchedule::OCCUR_QUARTERLY;
+  else if(tmp == i18n("Every four months").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYFOURMONTHS;
+  else if(tmp == i18n("Twice yearly").lower())
+    occurence = MyMoneySchedule::OCCUR_TWICEYEARLY;
+  else if(tmp == i18n("Yearly").lower())
+    occurence = MyMoneySchedule::OCCUR_YEARLY;
+  else if(tmp == i18n("Every other year").lower())
+    occurence = MyMoneySchedule::OCCUR_EVERYOTHERYEAR;
+
+  return occurence;
+}
+
+/**
+  * Helper method to convert simple occurence to compound occurence + multiplier
+  *
+  * @param multiplier Returned by reference.  Adjusted multiplier
+  * @param occurence Returned by reference.  Occurence type
+  */
+void MyMoneySchedule::simpleToCompoundOccurence(int& multiplier,occurenceE& occurence)
+{
+  occurenceE newOcc = occurence;
+  int newMulti = 1;
+  if (occurence == MyMoneySchedule::OCCUR_ONCE ||
+      occurence == MyMoneySchedule::OCCUR_DAILY ||
+      occurence == MyMoneySchedule::OCCUR_WEEKLY ||
+      occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH ||
+      occurence == MyMoneySchedule::OCCUR_MONTHLY ||
+      occurence == MyMoneySchedule::OCCUR_YEARLY )
+  { // Already a base occurence and multiplier
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_FORTNIGHTLY ||
+          occurence == MyMoneySchedule::OCCUR_EVERYOTHERWEEK)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_WEEKLY;
+    newMulti  = 2;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEWEEKS)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_WEEKLY;
+    newMulti  = 3;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURWEEKS)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_WEEKLY;
+    newMulti  = 4;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_DAILY;
+    newMulti  = 30;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_WEEKLY;
+    newMulti  = 8;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERMONTH)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_MONTHLY;
+    newMulti  = 2;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYTHREEMONTHS ||
+          occurence == MyMoneySchedule::OCCUR_QUARTERLY )
+  {
+    newOcc    = MyMoneySchedule::OCCUR_MONTHLY;
+    newMulti  = 3;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYFOURMONTHS)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_MONTHLY;
+    newMulti  = 4;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_TWICEYEARLY)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_MONTHLY;
+    newMulti  = 6;
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYOTHERYEAR)
+  {
+    newOcc    = MyMoneySchedule::OCCUR_YEARLY;
+    newMulti  = 2;
+  }
+  else  // Unknown
+  {
+    newOcc    = MyMoneySchedule::OCCUR_ANY;
+    newMulti  = 1;
+  }
+  if (newOcc != occurence)
+  {
+    occurence   = newOcc;
+    multiplier  = newMulti == 1 ? multiplier : newMulti * multiplier;
+  }
+}
+
+/**
+  * Helper method to convert compound occurence + multiplier to simple occurence
+  *
+  * @param multiplier Returned by reference.  Adjusted multiplier
+  * @param occurence Returned by reference.  Occurence type
+  */
+void MyMoneySchedule::compoundToSimpleOccurence(int& multiplier,occurenceE& occurence)
+{
+  occurenceE newOcc = occurence;
+  if(occurence == MyMoneySchedule::OCCUR_ONCE)
+  { // Nothing to do
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_DAILY)
+  {
+    switch (multiplier)
+    {
+      case 1: break;
+      case 30: newOcc = MyMoneySchedule::OCCUR_EVERYTHIRTYDAYS; break;
+    }
+  }
+  else if(newOcc == MyMoneySchedule::OCCUR_WEEKLY)
+  {
+    switch (multiplier)
+    {
+      case 1: break;
+      case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERWEEK; break;
+      case 3: newOcc = MyMoneySchedule::OCCUR_EVERYTHREEWEEKS; break;
+      case 4: newOcc = MyMoneySchedule::OCCUR_EVERYFOURWEEKS; break;
+      case 8: newOcc = MyMoneySchedule::OCCUR_EVERYEIGHTWEEKS; break;
+    }
+  }
+  else if(occurence == MyMoneySchedule::OCCUR_MONTHLY)
+    switch (multiplier)
+    {
+      case 1: break;
+      case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERMONTH; break;
+      case 3: newOcc = MyMoneySchedule::OCCUR_EVERYTHREEMONTHS; break;
+      case 4: newOcc = MyMoneySchedule::OCCUR_EVERYFOURMONTHS; break;
+      case 6: newOcc = MyMoneySchedule::OCCUR_TWICEYEARLY; break;
+    }
+  else if(occurence == MyMoneySchedule::OCCUR_EVERYHALFMONTH)
+    switch (multiplier)
+    {
+      case 1: break;
+    }
+  else if(occurence == MyMoneySchedule::OCCUR_YEARLY)
+  {
+    switch (multiplier)
+    {
+      case 1: break;
+      case 2: newOcc = MyMoneySchedule::OCCUR_EVERYOTHERYEAR; break;
+    }
+  }
+  if (occurence != newOcc ) // Changed to derived type
+  {
+    occurence = newOcc;
+    multiplier = 1;
+  }
+}