diff options
Diffstat (limited to 'kmymoney2/widgets/register.cpp')
| -rw-r--r-- | kmymoney2/widgets/register.cpp | 2438 |
1 files changed, 2438 insertions, 0 deletions
diff --git a/kmymoney2/widgets/register.cpp b/kmymoney2/widgets/register.cpp new file mode 100644 index 0000000..974ae23 --- /dev/null +++ b/kmymoney2/widgets/register.cpp @@ -0,0 +1,2438 @@ +/*************************************************************************** + register.cpp - description + ------------------- + begin : Fri Mar 10 2006 + copyright : (C) 2006 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 <typeinfo> + +// ---------------------------------------------------------------------------- +// QT Includes + +#include <qstring.h> +#include <qtimer.h> +#include <qapplication.h> +#include <qeventloop.h> +#include <qtooltip.h> +#include <qimage.h> + +// ---------------------------------------------------------------------------- +// KDE Includes + +#include <klocale.h> +#include <kglobal.h> +#include <kdebug.h> +#include <kurldrag.h> + +// ---------------------------------------------------------------------------- +// Project Includes + +#include <kmymoney/kmymoneydateinput.h> +#include <kmymoney/kmymoneyedit.h> +#include <kmymoney/kmymoneycategory.h> +#include <kmymoney/register.h> +#include <kmymoney/transactionform.h> +#include <kmymoney/stdtransactiondownloaded.h> +#include <kmymoney/stdtransactionmatched.h> +#include "scheduledtransaction.h" +#include "../kmymoneyglobalsettings.h" + +const int LinesPerMemo = 3; + +static QString sortOrderText[] = { + I18N_NOOP("Unknown"), + I18N_NOOP("Post date"), + I18N_NOOP("Date entered"), + I18N_NOOP("Payee"), + I18N_NOOP("Amount"), + I18N_NOOP("Number"), + I18N_NOOP("Entry order"), + I18N_NOOP("Type"), + I18N_NOOP("Category"), + I18N_NOOP("Reconcile state"), + I18N_NOOP("Security") + // add new values above this comment line + }; + +using namespace KMyMoneyRegister; + +static unsigned char fancymarker_bg_image[] = { +/* 200x49 */ + 0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A, + 0x00,0x00,0x00,0x0D,0x49,0x48,0x44,0x52, + 0x00,0x00,0x00,0xC8,0x00,0x00,0x00,0x31, + 0x08,0x06,0x00,0x00,0x00,0x9F,0xC5,0xE6, + 0x4F,0x00,0x00,0x00,0x06,0x62,0x4B,0x47, + 0x44,0x00,0xFF,0x00,0xFF,0x00,0xFF,0xA0, + 0xBD,0xA7,0x93,0x00,0x00,0x00,0x09,0x70, + 0x48,0x59,0x73,0x00,0x00,0x0B,0x13,0x00, + 0x00,0x0B,0x13,0x01,0x00,0x9A,0x9C,0x18, + 0x00,0x00,0x00,0x86,0x49,0x44,0x41,0x54, + 0x78,0xDA,0xED,0xDD,0x31,0x0A,0x84,0x40, + 0x10,0x44,0xD1,0x1A,0x19,0x10,0xCF,0xE6, + 0xFD,0x4F,0xB2,0x88,0x08,0x22,0x9B,0x18, + 0x4E,0x1B,0x2C,0x1B,0x18,0xBC,0x07,0x7D, + 0x81,0x82,0x1F,0x77,0x4B,0xB2,0x06,0x18, + 0xEA,0x49,0x3E,0x66,0x00,0x81,0x80,0x40, + 0xE0,0xDF,0x81,0x6C,0x66,0x80,0x3A,0x90, + 0xDD,0x0C,0x50,0x07,0x72,0x98,0x01,0xEA, + 0x40,0x4E,0x33,0x40,0x1D,0xC8,0x65,0x06, + 0x18,0x6B,0xF7,0x01,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, + 0x00,0x00,0x00,0x00,0x00,0xF0,0x16,0x3E, + 0x4C,0xC1,0x83,0x9E,0x64,0x32,0x03,0x08, + 0x04,0x7E,0x0A,0xA4,0x9B,0x01,0xEA,0x40, + 0x66,0x33,0x40,0x1D,0xC8,0x62,0x06,0x18, + 0xFB,0x02,0x05,0x87,0x08,0x55,0xFE,0xDE, + 0xA2,0x9D,0x00,0x00,0x00,0x00,0x49,0x45, + 0x4E,0x44,0xAE,0x42,0x60,0x82 +}; + +QPixmap* GroupMarker::m_bg = 0; +int GroupMarker::m_bgRefCnt = 0; + +void ItemPtrVector::sort(void) +{ + if(count() > 0) { + // get rid of 0 pointers in the list + KMyMoneyRegister::ItemPtrVector::iterator it_l; + RegisterItem *item; + for(it_l = begin(); it_l != end(); ++it_l) { + if(*it_l == 0) { + item = last(); + *it_l = item; + pop_back(); + --it_l; + } + } + + std::sort(begin(), end(), item_cmp); + } +} + +bool ItemPtrVector::item_cmp(RegisterItem* i1, RegisterItem* i2) +{ + const QValueList<TransactionSortField>& sortOrder = i1->parent()->sortOrder(); + QValueList<TransactionSortField>::const_iterator it; + int rc = 0; + bool ok1, ok2; + Q_ULLONG n1, n2; + + MyMoneyMoney tmp; + + for(it = sortOrder.begin(); it != sortOrder.end(); ++it) { + TransactionSortField sortField = static_cast<TransactionSortField>(abs(*it)); + switch(sortField) { + case PostDateSort: + rc = i2->sortPostDate().daysTo(i1->sortPostDate()); + if(rc == 0) { + rc = i1->sortSamePostDate() - i2->sortSamePostDate(); + } + break; + + case EntryDateSort: + rc = i2->sortEntryDate().daysTo(i1->sortEntryDate()); + break; + + case PayeeSort: + rc = QString::localeAwareCompare(i1->sortPayee(), i2->sortPayee()); + break; + + case ValueSort: + tmp = i1->sortValue() - i2->sortValue(); + if(tmp.isZero()) + rc = 0; + else if(tmp.isNegative()) + rc = -1; + else + rc = 1; + break; + + case NoSort: + // convert both values to numbers + n1 = i1->sortNumber().toULongLong(&ok1); + n2 = i2->sortNumber().toULongLong(&ok2); + // the following four cases exist: + // a) both are converted correct + // compare them directly + // b) n1 is numeric, n2 is not + // numbers come first, so return -1 + // c) n1 is not numeric, n2 is + // numbers come first, so return 1 + // d) both are non numbers + // compare using localeAwareCompare + if(ok1 && ok2) { // case a) + rc = (n1 > n2) ? 1 : ((n1 == n2 ) ? 0 : -1); + } else if(ok1 && !ok2) { + rc = -1; + } else if(!ok1 && ok2) { + rc = 1; + } else + rc = QString::localeAwareCompare(i1->sortNumber(), i2->sortNumber()); + break; + + case EntryOrderSort: + rc = qstrcmp(i1->sortEntryOrder(), i2->sortEntryOrder()); + break; + + case TypeSort: + rc = i1->sortType() - i2->sortType(); + break; + + case CategorySort: + rc = QString::localeAwareCompare(i1->sortCategory(), i2->sortCategory()); + break; + + case ReconcileStateSort: + rc = static_cast<int>(i1->sortReconcileState()) - static_cast<int>(i2->sortReconcileState()); + break; + + case SecuritySort: + rc = QString::localeAwareCompare(i1->sortSecurity(), i2->sortSecurity()); + break; + + default: + qDebug("Invalid sort key %d", *it); + break; + } + + // the items differ for this sort key so we can return a result + if(rc != 0) + return (*it < 0) ? rc >= 0 : rc < 0; + } + + if(rc == 0) { + rc = qstrcmp(i1->sortEntryOrder(), i2->sortEntryOrder()); + } + + return rc < 0; +} + +GroupMarker::GroupMarker(Register *parent, const QString& txt) : + RegisterItem(parent), + m_txt(txt), + m_drawCounter(parent->drawCounter()-1), // make sure we get painted the first time around + m_showDate(false) +{ + int h; + if(m_parent) { + h = m_parent->rowHeightHint(); + } else { + QFontMetrics fm( KMyMoneyGlobalSettings::listCellFont() ); + h = fm.lineSpacing()+6; + } + + if(m_bg && (m_bg->height() != h)) { + delete m_bg; + m_bg = 0; + } + + // convert the backgroud once + if(m_bg == 0) { + m_bg = new QPixmap; + m_bg->loadFromData(fancymarker_bg_image, sizeof(fancymarker_bg_image)); + + // for now, we can't simply resize the m_bg member as Qt does not support + // alpha resizing. So we take the (slow) detour through a QImage object + // which is ok, since we do this only once. + // m_bg->resize(m_bg->width(), h); + QImage img(m_bg->convertToImage()); + img = img.smoothScale(img.width(), h); + m_bg->convertFromImage(img); + } + + ++m_bgRefCnt; +} + +GroupMarker::~GroupMarker() +{ + --m_bgRefCnt; + if(!m_bgRefCnt) { + delete m_bg; + m_bg = 0; + } +} + +void GroupMarker::paintRegisterCell(QPainter* painter, int row, int /* col */, const QRect& _r, bool /*selected*/, const QColorGroup& _cg) +{ + // avoid painting the marker twice for the same update round + unsigned int drawCounter = m_parent->drawCounter(); + if(m_drawCounter == drawCounter) { + return; + } + m_drawCounter = drawCounter; + + QRect r(_r); + painter->save(); + painter->translate(-r.x(), -r.y()); + + // the group marker always uses all cols + r.setX(m_parent->columnPos(0)); + r.setWidth(m_parent->visibleWidth()); + painter->translate(r.x(), r.y()); + + QRect cellRect; + cellRect.setX(0); + cellRect.setY(0); + cellRect.setWidth(m_parent->visibleWidth()); + cellRect.setHeight(m_parent->rowHeight(row + m_startRow)); + + // clear out cell rectangle + QColorGroup cg(_cg); + setupColors(cg); + + QBrush backgroundBrush(cg.base()); + painter->fillRect(cellRect, backgroundBrush); + painter->setPen(KMyMoneyGlobalSettings::listGridColor()); + painter->drawLine(cellRect.x(), cellRect.height()-1, cellRect.width(), cellRect.height()-1); + + // now write the text + painter->setPen(cg.text()); + QFont font = painter->font(); + font.setBold(true); + painter->setFont(font); + + painter->drawText(cellRect, Qt::AlignVCenter | Qt::AlignCenter, m_txt); + + cellRect.setHeight(m_bg->height()); + int curWidth = m_bg->width(); + + // if the background image is too small (not wide enough) we need to increase its width. + if(curWidth < cellRect.width()) { + QPixmap* newPic = new QPixmap(cellRect.width(), cellRect.height()); + int x = 0; + while(x < cellRect.width()) { + copyBlt(newPic, x, 0, m_bg, 0, 0, curWidth, m_bg->height()); + x += curWidth; + } + delete m_bg; + m_bg = newPic; + } + + // now it's time to draw the background + painter->drawPixmap(cellRect, *m_bg); + + // translate back + painter->translate(-r.x(), -r.y()); + + // in case we need to show the date, we just paint it in col 1 + if(m_showDate) { + r.setX(m_parent->columnPos(1)); + r.setWidth(m_parent->columnWidth(1)); + painter->translate(r.x(), r.y()); + + cellRect.setX(0); + cellRect.setY(0); + cellRect.setWidth(m_parent->columnWidth(1)); + cellRect.setHeight(m_parent->rowHeight(row + m_startRow)); + + font.setBold(false); + painter->setFont(font); + painter->drawText(cellRect, Qt::AlignVCenter | Qt::AlignCenter, KGlobal::locale()->formatDate(sortPostDate(), true)); + } + + painter->restore(); +} + +void GroupMarker::setupColors(QColorGroup& cg) +{ + cg.setColor(QColorGroup::Base, KMyMoneyGlobalSettings::groupMarkerColor()); +} + +int GroupMarker::rowHeightHint(void) const +{ + if(!m_visible) + return 0; + + return m_bg->height(); +} + +StatementGroupMarker::StatementGroupMarker(Register* parent, CashFlowDirection dir, const QDate& date, const QString& txt) : + FancyDateGroupMarker(parent, date, txt), + m_dir(dir) +{ + m_showDate = true; +} + +FancyDateGroupMarker::FancyDateGroupMarker(Register* parent, const QDate& date, const QString& txt) : + GroupMarker(parent, txt), + m_date(date) +{ +} + +FiscalYearGroupMarker::FiscalYearGroupMarker(Register* parent, const QDate& date, const QString& txt) : + FancyDateGroupMarker(parent, date, txt) +{ +} + +void FiscalYearGroupMarker::setupColors(QColorGroup& cg) +{ + cg.setColor(QColorGroup::Base, KMyMoneyGlobalSettings::groupMarkerColor()); +} + + +SimpleDateGroupMarker::SimpleDateGroupMarker(Register* parent, const QDate& date, const QString& txt) : + FancyDateGroupMarker(parent, date, txt) +{ +} + +int SimpleDateGroupMarker::rowHeightHint(void) const +{ + if(!m_visible) + return 0; + + return RegisterItem::rowHeightHint() / 2; +} + +void SimpleDateGroupMarker::paintRegisterCell(QPainter* painter, int row, int /*col*/, const QRect& _r, bool /*selected*/, const QColorGroup& _cg) +{ + QRect r(_r); + painter->save(); + painter->translate(-r.x(), -r.y()); + + // the group marker always uses all cols + r.setX(m_parent->columnPos(0)); + r.setWidth(m_parent->visibleWidth()); + painter->translate(r.x(), r.y()); + + QRect cellRect; + cellRect.setX(0); + cellRect.setY(0); + cellRect.setWidth(m_parent->visibleWidth()); + cellRect.setHeight(m_parent->rowHeight(row + m_startRow)); + + // clear out cell rectangle + QColorGroup cg(_cg); + if(m_alternate) + cg.setColor(QColorGroup::Base, KMyMoneyGlobalSettings::listColor()); + else + cg.setColor(QColorGroup::Base, KMyMoneyGlobalSettings::listBGColor()); + QBrush backgroundBrush(cg.base()); + // backgroundBrush.setStyle(Qt::DiagCrossPattern); + backgroundBrush.setStyle(Qt::Dense5Pattern); + backgroundBrush.setColor(KMyMoneyGlobalSettings::listGridColor()); + painter->eraseRect(cellRect); + painter->fillRect(cellRect, backgroundBrush); + painter->setPen(KMyMoneyGlobalSettings::listGridColor()); + painter->drawLine(cellRect.x(), cellRect.height()-1, cellRect.width(), cellRect.height()-1); + + painter->restore(); +} + +TypeGroupMarker::TypeGroupMarker(Register* parent, CashFlowDirection dir, MyMoneyAccount::accountTypeE accType) : + GroupMarker(parent), + m_dir(dir) +{ + switch(dir) { + case Deposit: + m_txt = i18n("Deposits onto account", "Deposits"); + if(accType == MyMoneyAccount::CreditCard) { + m_txt = i18n("Payments towards credit card", "Payments"); + } + break; + case Payment: + m_txt = i18n("Payments made from account", "Payments"); + if(accType == MyMoneyAccount::CreditCard) { + m_txt = i18n("Payments made with credit card", "Charges"); + } + break; + default: + qDebug("Unknown CashFlowDirection %d for TypeGroupMarker constructor", dir); + break; + } +} + +PayeeGroupMarker::PayeeGroupMarker(Register* parent, const QString& name) : + GroupMarker(parent, name) +{ +} + +CategoryGroupMarker::CategoryGroupMarker(Register* parent, const QString& category) : + GroupMarker(parent, category) +{ +} + +ReconcileGroupMarker::ReconcileGroupMarker(Register* parent, MyMoneySplit::reconcileFlagE state) : + GroupMarker(parent), + m_state(state) +{ + switch(state) { + case MyMoneySplit::NotReconciled: + m_txt = i18n("Reconcile state 'Not reconciled'", "Not reconciled"); + break; + case MyMoneySplit::Cleared: + m_txt = i18n("Reconcile state 'Cleared'", "Cleared"); + break; + case MyMoneySplit::Reconciled: + m_txt = i18n("Reconcile state 'Reconciled'", "Reconciled"); + break; + case MyMoneySplit::Frozen: + m_txt = i18n("Reconcile state 'Frozen'", "Frozen"); + break; + default: + m_txt = i18n("Unknown"); + break; + } +} + +class RegisterToolTip : public QToolTip +{ +public: + RegisterToolTip(QWidget* parent, Register* reg); + void maybeTip(const QPoint& pos); + virtual ~RegisterToolTip() {} + +private: + Register* m_register; +}; + +RegisterToolTip::RegisterToolTip(QWidget* parent, Register * reg) : + QToolTip(parent), + m_register(reg) +{ +} + +void RegisterToolTip::maybeTip(const QPoint& pos) +{ + // if we update the register, there's no need to show tooltips + if(!m_register->isUpdatesEnabled()) + return; + + QPoint cpos = m_register->viewportToContents(pos); + // qDebug("RegisterToolTip::mayBeTip(%d,%d)", cpos.x(), cpos.y()); + int row = m_register->rowAt(cpos.y()); + int col = m_register->columnAt(cpos.x()); + RegisterItem* item = m_register->itemAtRow(row); + if(!item) + return; + + QPoint relPos(cpos.x() - m_register->columnPos(0), cpos.y() - m_register->rowPos(item->startRow())); + row = row - item->startRow(); + + // qDebug("row = %d, col = %d", row, col); + // qDebug("relpos = %d,%d", relPos.x(), relPos.y()); + QString msg; + QRect rect; + if(!item->maybeTip(cpos, row, col, rect, msg)) + return; + + QPoint tl(rect.topLeft()); + QPoint br(rect.bottomRight()); + QRect r = QRect(m_register->contentsToViewport(tl), m_register->contentsToViewport(br)); + tip(r, msg); + return; +} + +Register::Register(QWidget *parent, const char *name ) : + TransactionEditorContainer(parent, name), + m_selectAnchor(0), + m_focusItem(0), + m_firstItem(0), + m_lastItem(0), + m_firstErronous(0), + m_lastErronous(0), + m_markErronousTransactions(0), + m_rowHeightHint(0), + m_ledgerLensForced(false), + m_selectionMode(Multi), + m_listsDirty(false), + m_ignoreNextButtonRelease(false), + m_needInitialColumnResize(false), + m_buttonState(Qt::ButtonState(0)), + m_drawCounter(0) +{ + m_tooltip = new RegisterToolTip(viewport(), this); + + setNumCols(MaxColumns); + setCurrentCell(0, 1); + // we do our own sorting + setSorting(false); + + // keep the following list in sync with KMyMoneyRegister::Column in transaction.h + horizontalHeader()->setLabel(NumberColumn, i18n("No.")); + horizontalHeader()->setLabel(DateColumn, i18n("Date")); + horizontalHeader()->setLabel(AccountColumn, i18n("Account")); + horizontalHeader()->setLabel(SecurityColumn, i18n("Security")); + horizontalHeader()->setLabel(DetailColumn, i18n("Details")); + horizontalHeader()->setLabel(ReconcileFlagColumn, i18n("C")); + horizontalHeader()->setLabel(PaymentColumn, i18n("Payment")); + horizontalHeader()->setLabel(DepositColumn, i18n("Deposit")); + horizontalHeader()->setLabel(QuantityColumn, i18n("Quantity")); + horizontalHeader()->setLabel(PriceColumn, i18n("Price")); + horizontalHeader()->setLabel(ValueColumn, i18n("Value")); + horizontalHeader()->setLabel(BalanceColumn, i18n("Balance")); + + setLeftMargin(0); + verticalHeader()->hide(); + + for(int i = 0; i < numCols(); ++i) + setColumnStretchable(i, false); + + horizontalHeader()->setResizeEnabled(false); + horizontalHeader()->setMovingEnabled(false); + horizontalHeader()->setClickEnabled(false); + + horizontalHeader()->installEventFilter(this); + + // never show horizontal scroll bars + setHScrollBarMode(QScrollView::AlwaysOff); + + connect(this, SIGNAL(clicked(int, int, int, const QPoint&)), this, SLOT(selectItem(int, int, int, const QPoint&))); + connect(this, SIGNAL(doubleClicked(int, int, int, const QPoint&)), this, SLOT(slotDoubleClicked(int, int, int, const QPoint&))); + + // double clicking the header turns on auto column sizing + connect(horizontalHeader(), SIGNAL(sectionSizeChanged(int)), this, SLOT(slotAutoColumnSizing(int))); + + //DND + setAcceptDrops(true); +} + +// DND +Transaction* Register::dropTransaction(QPoint cPos) const +{ + Transaction* t = 0; + cPos -= QPoint( verticalHeader()->width(), horizontalHeader()->height() ); + if(cPos.y() >= 0) { + cPos += QPoint(contentsX(), contentsY()); + int row = rowAt(cPos.y()); + t = dynamic_cast<Transaction*>(itemAtRow(row)); + } + return t; +} + +void Register::dragMoveEvent(QDragMoveEvent* event) +{ + if ( KURLDrag::canDecode(event) ) { + event->ignore(); + Transaction* t = dropTransaction(event->pos()); + if(t && !t->isScheduled()) { + event->accept(); + } + } +} + +void Register::dropEvent(QDropEvent* event) +{ + qDebug("Register::dropEvent"); + if ( KURLDrag::canDecode(event) ) { + event->ignore(); + Transaction* t = dropTransaction(event->pos()); + if(t && !t->isScheduled()) { + qDebug("Drop was ok"); + KURL::List urls; + KURLDrag::decode(event, urls); + qDebug("List is '%s'", urls.toStringList().join(";").data()); + event->accept(); + } + } +} +// DND end + + +Register::~Register() +{ + clear(); + delete m_tooltip; + m_tooltip = 0; +} + +void Register::slotAutoColumnSizing(int section) +{ + Q_UNUSED(section) +#if 0 + // this is some trial code to make the col sizes adjustable + // there are some drawbacks though: what when we have a register + // but no account? (ipwizard 2007-11-06) + if(isUpdatesEnabled()) { + int w = visibleWidth(); + QString size; + for(int i=0; i < numCols(); ++i) { + if(i) + size += ","; + if(i == DetailColumn) { + size += "0"; + continue; + } + size += QString("%1").arg((columnWidth(i) * 100) / w); + } + qDebug("size = %s", size.data()); + m_account.setValue("kmm-ledger-column-width", size); + } +#endif +} + +bool Register::eventFilter(QObject* o, QEvent* e) +{ + if(o == horizontalHeader() && e->type() == QEvent::MouseButtonPress) { + QMouseEvent *me = dynamic_cast<QMouseEvent*>(e); + if(me->button() == Qt::RightButton) { + emit headerClicked(); + } + // eat up left mouse button press for now + return true; + + } else if(o == horizontalHeader() && e->type() == QEvent::Paint) { + // always show the header in bold (to suppress cell selection) + QFont f(horizontalHeader()->font()); + f.setBold(true); + horizontalHeader()->setFont(f); + + } else if(o == this && e->type() == QEvent::KeyPress) { + QKeyEvent* ke = dynamic_cast<QKeyEvent*>(e); + if(ke->key() == Qt::Key_Menu) { + emit openContextMenu(); + return true; + } + } + + return QTable::eventFilter(o, e); +} + +void Register::setupRegister(const MyMoneyAccount& account, const QValueList<Column>& cols) +{ + m_account = account; + bool enabled = isUpdatesEnabled(); + setUpdatesEnabled(false); + + for(int i = 0; i < MaxColumns; ++i) + hideColumn(i); + + m_needInitialColumnResize = true; + + m_lastCol = static_cast<Column>(0); + QValueList<Column>::const_iterator it_c; + for(it_c = cols.begin(); it_c != cols.end(); ++it_c) { + if((*it_c) > MaxColumns) + continue; + showColumn(*it_c); + if(*it_c > m_lastCol) + m_lastCol = *it_c; + } + + setUpdatesEnabled(enabled); +} + +void Register::setupRegister(const MyMoneyAccount& account, bool showAccountColumn) +{ + m_account = account; + bool enabled = isUpdatesEnabled(); + setUpdatesEnabled(false); + + for(int i = 0; i < MaxColumns; ++i) + hideColumn(i); + + horizontalHeader()->setLabel(PaymentColumn, i18n("Payment made from account", "Payment")); + horizontalHeader()->setLabel(DepositColumn, i18n("Deposit into account", "Deposit")); + + if(account.id().isEmpty()) { + setUpdatesEnabled(enabled); + return; + } + + m_needInitialColumnResize = true; + + // turn on standard columns + showColumn(DateColumn); + showColumn(DetailColumn); + showColumn(ReconcileFlagColumn); + + // balance + switch(account.accountType()) { + case MyMoneyAccount::Stock: + break; + default: + showColumn(BalanceColumn); + break; + } + + // Number column + switch(account.accountType()) { + case MyMoneyAccount::Savings: + case MyMoneyAccount::Cash: + case MyMoneyAccount::Loan: + case MyMoneyAccount::AssetLoan: + case MyMoneyAccount::Asset: + case MyMoneyAccount::Liability: + case MyMoneyAccount::Equity: + if(KMyMoneyGlobalSettings::alwaysShowNrField()) + showColumn(NumberColumn); + break; + + case MyMoneyAccount::Checkings: + case MyMoneyAccount::CreditCard: + showColumn(NumberColumn); + break; + + default: + hideColumn(NumberColumn); + break; + } + + switch(account.accountType()) { + case MyMoneyAccount::Income: + case MyMoneyAccount::Expense: + showAccountColumn = true; + break; + default: + break; + } + + if(showAccountColumn) + showColumn(AccountColumn); + + // Security, activity, payment, deposit, amount, price and value column + switch(account.accountType()) { + default: + showColumn(PaymentColumn); + showColumn(DepositColumn); + break; + + case MyMoneyAccount::Investment: + showColumn(SecurityColumn); + showColumn(QuantityColumn); + showColumn(PriceColumn); + showColumn(ValueColumn); + break; + } + + // headings + switch(account.accountType()) { + case MyMoneyAccount::CreditCard: + horizontalHeader()->setLabel(PaymentColumn, i18n("Payment made with credit card", "Charge")); + horizontalHeader()->setLabel(DepositColumn, i18n("Payment towards credit card", "Payment")); + break; + case MyMoneyAccount::Asset: + case MyMoneyAccount::AssetLoan: + horizontalHeader()->setLabel(PaymentColumn, i18n("Decrease of asset/liability value", "Decrease")); + horizontalHeader()->setLabel(DepositColumn, i18n("Increase of asset/liability value", "Increase")); + break; + case MyMoneyAccount::Liability: + case MyMoneyAccount::Loan: + horizontalHeader()->setLabel(PaymentColumn, i18n("Increase of asset/liability value", "Increase")); + horizontalHeader()->setLabel(DepositColumn, i18n("Decrease of asset/liability value", "Decrease")); + break; + case MyMoneyAccount::Income: + case MyMoneyAccount::Expense: + horizontalHeader()->setLabel(PaymentColumn, i18n("Income")); + horizontalHeader()->setLabel(DepositColumn, i18n("Expense")); + break; + + default: + break; + } + + switch(account.accountType()) { + default: + m_lastCol = BalanceColumn; + break; + } + + setUpdatesEnabled(enabled); +} + +bool Register::focusNextPrevChild(bool next) +{ + return QFrame::focusNextPrevChild(next); +} + +void Register::setSortOrder(const QString& order) +{ + QStringList orderList = QStringList::split(",", order); + QStringList::const_iterator it; + m_sortOrder.clear(); + for(it = orderList.begin(); it != orderList.end(); ++it) { + m_sortOrder << static_cast<TransactionSortField>((*it).toInt()); + } +} + +void Register::sortItems(void) +{ + if(m_items.count() == 0) + return; + + // sort the array of pointers to the transactions + m_items.sort(); + + // update the next/prev item chains + RegisterItem* prev = 0; + RegisterItem* item; + m_firstItem = m_lastItem = 0; + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + item = m_items[i]; + if(!item) + continue; + + if(!m_firstItem) + m_firstItem = item; + m_lastItem = item; + if(prev) + prev->setNextItem(item); + item->setPrevItem(prev); + item->setNextItem(0); + prev = item; + } + + // update the balance visibility settings + item = m_lastItem; + bool showBalance = true; + while(item) { + Transaction* t = dynamic_cast<Transaction*>(item); + if(t) { + t->setShowBalance(showBalance); + if(!t->isVisible()) { + showBalance = false; + } + } + item = item->prevItem(); + } + + // force update of the item index (row to item array) + m_listsDirty = true; +} + +TransactionSortField Register::primarySortKey(void) const +{ + if(!m_sortOrder.isEmpty()) + return static_cast<KMyMoneyRegister::TransactionSortField>(abs(m_sortOrder.first())); + return UnknownSort; +} + + +void Register::clear(void) +{ + m_firstErronous = m_lastErronous = 0; + m_ensureVisibleItem = 0; + + RegisterItem* p; + while((p = firstItem()) != 0) { + delete p; + } + m_items.clear(); + + m_firstItem = m_lastItem = 0; + + m_listsDirty = true; + m_selectAnchor = 0; + m_focusItem = 0; + +#ifndef KMM_DESIGNER + // recalculate row height hint + QFontMetrics fm( KMyMoneyGlobalSettings::listCellFont() ); + m_rowHeightHint = fm.lineSpacing()+6; +#endif + + m_needInitialColumnResize = true; +} + +void Register::insertItemAfter(RegisterItem*p, RegisterItem* prev) +{ + RegisterItem* next = 0; + if(!prev) + prev = lastItem(); + + if(prev) { + next = prev->nextItem(); + prev->setNextItem(p); + } + if(next) + next->setPrevItem(p); + + p->setPrevItem(prev); + p->setNextItem(next); + + if(!m_firstItem) + m_firstItem = p; + if(!m_lastItem) + m_lastItem = p; + + if(prev == m_lastItem) + m_lastItem = p; + + m_listsDirty = true; +} + +void Register::addItem(RegisterItem* p) +{ + RegisterItem* q = lastItem(); + if(q) + q->setNextItem(p); + p->setPrevItem(q); + p->setNextItem(0); + + m_items.append(p); + + if(!m_firstItem) + m_firstItem = p; + m_lastItem = p; + m_listsDirty = true; +} + +void Register::removeItem(RegisterItem* p) +{ + // remove item from list + if(p->prevItem()) + p->prevItem()->setNextItem(p->nextItem()); + if(p->nextItem()) + p->nextItem()->setPrevItem(p->prevItem()); + + // update first and last pointer if required + if(p == m_firstItem) + m_firstItem = p->nextItem(); + if(p == m_lastItem) + m_lastItem = p->prevItem(); + + // make sure we don't do it twice + p->setNextItem(0); + p->setPrevItem(0); + + // remove it from the m_items array + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + RegisterItem* item = m_items[i]; + if(!item) + continue; + if(item == p) { + m_items[i] = 0; + break; + } + } + m_listsDirty = true; +} + +RegisterItem* Register::firstItem(void) const +{ + return m_firstItem; +} + +RegisterItem* Register::lastItem(void) const +{ + return m_lastItem; +} + +void Register::setupItemIndex(int rowCount) +{ + // setup index array + m_itemIndex.clear(); + m_itemIndex.reserve(rowCount); + + // fill index array + rowCount = 0; + RegisterItem* prev = 0; + m_firstItem = m_lastItem = 0; + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + RegisterItem* item = m_items[i]; + if(!item) + continue; + if(!m_firstItem) + m_firstItem = item; + m_lastItem = item; + if(prev) + prev->setNextItem(item); + item->setPrevItem(prev); + item->setNextItem(0); + prev = item; + for(int j = item->numRowsRegister(); j; --j) { + m_itemIndex.push_back(item); + } + } +} + +void Register::drawContents( QPainter *p, int cx, int cy, int cw, int ch ) +{ + // the QTable::drawContents() method does not honor the block update flag + // so we take care of it here + if ( testWState(WState_Visible|WState_BlockUpdates) != WState_Visible ) + return; + + if(m_listsDirty) { + updateRegister(KMyMoneyGlobalSettings::ledgerLens() | !KMyMoneyGlobalSettings::transactionForm()); + } + + ++m_drawCounter; + QTable::drawContents(p, cx, cy, cw, ch); +} + +void Register::updateAlternate(void) const +{ + bool alternate = false; + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + RegisterItem* item = m_items[i]; + if(!item) + continue; + if(item->isVisible()) { + item->setAlternate(alternate); + alternate ^= true; + } + } +} + +void Register::suppressAdjacentMarkers(void) +{ + bool lastWasGroupMarker = false; + KMyMoneyRegister::RegisterItem* p = lastItem(); + KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(p); + if(t && t->transaction().id().isEmpty()) { + lastWasGroupMarker = true; + p = p->prevItem(); + } + while(p) { + KMyMoneyRegister::GroupMarker* m = dynamic_cast<KMyMoneyRegister::GroupMarker*>(p); + if(m) { + // make adjacent group marker invisible except those that show statement information + if(lastWasGroupMarker && (dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(m) == 0)) { + m->setVisible(false); + } + lastWasGroupMarker = true; + } else if(p->isVisible()) + lastWasGroupMarker = false; + p = p->prevItem(); + } +} + +void Register::updateRegister(bool forceUpdateRowHeight) +{ + ::timetrace("Update register"); + if(m_listsDirty || forceUpdateRowHeight) { + // don't get in here recursively + m_listsDirty = false; + + int rowCount = 0; + // determine the number of rows we need to display all items + // while going through the list, check for erronous transactions + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + RegisterItem* item = m_items[i]; + if(!item) + continue; + item->setStartRow(rowCount); + item->setNeedResize(); + rowCount += item->numRowsRegister(); + + if(item->isErronous()) { + if(!m_firstErronous) + m_firstErronous = item; + m_lastErronous = item; + } + } + + updateAlternate(); + + // create item index + setupItemIndex(rowCount); + + bool needUpdateHeaders = (numRows() != rowCount) | forceUpdateRowHeight; + + // setup QTable. Make sure to suppress screen updates for now + bool updatesEnabled = isUpdatesEnabled(); + setUpdatesEnabled(false); + setNumRows(rowCount); + + // if we need to update the headers, we do it now for all rows + // again we make sure to suppress screen updates + if(needUpdateHeaders) { + // int height = rowHeightHint(); + + verticalHeader()->setUpdatesEnabled(false); + + for(int i = 0; i < rowCount; ++i) { + RegisterItem* item = itemAtRow(i); + if(item->isVisible()) { + showRow(i); + } else { + hideRow(i); + } + verticalHeader()->resizeSection(i, item->rowHeightHint()); + } + verticalHeader()->setUpdatesEnabled(true); + } + + // add or remove scrollbars as required + updateScrollBars(); + + setUpdatesEnabled(updatesEnabled); + + // force resizeing of the columns if necessary + if(m_needInitialColumnResize) { + QTimer::singleShot(0, this, SLOT(resize())); + m_needInitialColumnResize = false; + } else { + updateContents(); + + // if the number of rows changed, we might need to resize the register + // to make sure we reflect the current visibility of the scrollbars. + if(needUpdateHeaders) + QTimer::singleShot(0, this, SLOT(resize())); + } + } + ::timetrace("Done updateing register"); +} + +int Register::rowHeightHint(void) const +{ + if(!m_rowHeightHint) { + qDebug("Register::rowHeightHint(): m_rowHeightHint is zero!!"); + } + return m_rowHeightHint; +} + +void Register::paintCell(QPainter* painter, int row, int col, const QRect& r, bool selected, const QColorGroup& cg) +{ + // determine the item that we need to paint in the row and call it's paintRegisterCell() method + if((row < 0) || ((unsigned)row > m_itemIndex.size())) { + qDebug("Register::paintCell: row %d out of bounds %d", row, (int)m_itemIndex.size()); + return; + } + + // qDebug("paintCell(%d,%d)", row, col); + RegisterItem* const item = m_itemIndex[row]; + item->paintRegisterCell(painter, row - item->startRow(), col, r, selected, cg); +} + +void Register::focusInEvent(QFocusEvent* ev) +{ + QTable::focusInEvent(ev); + if(m_focusItem) { + m_focusItem->setFocus(true, false); + repaintItems(m_focusItem); + } +} + +void Register::focusOutEvent(QFocusEvent* ev) +{ + if(m_focusItem) { + m_focusItem->setFocus(false, false); + repaintItems(m_focusItem); + } + QTable::focusOutEvent(ev); +} + +void Register::resize(void) +{ + resize(DetailColumn); +} + +void Register::resize(int col) +{ + bool enabled = isUpdatesEnabled(); + setUpdatesEnabled(false); + + // resize the register + int w = visibleWidth(); + + // TODO I was playing a bit with manual ledger resizing but could not get + // a good solution. I just leave the code around, so that maybe others + // pick it up again. So far, it's not clear to me where to store the + // size of the sections: + // + // a) with the account (as it is done now) + // b) with the application for the specific account type + // c) ???? + // + // Ideas are welcome (ipwizard: 2007-07-19) + // Note: currently there's no way to switch back to automatic + // column sizing once the manual sizing option has been saved +#if 0 + if(m_account.value("kmm-ledger-column-width").isEmpty()) { +#endif + + // check which space we need + if(columnWidth(NumberColumn)) + adjustColumn(NumberColumn); + if(columnWidth(AccountColumn)) + adjustColumn(AccountColumn); + if(columnWidth(PaymentColumn)) + adjustColumn(PaymentColumn); + if(columnWidth(DepositColumn)) + adjustColumn(DepositColumn); + if(columnWidth(BalanceColumn)) + adjustColumn(BalanceColumn); + if(columnWidth(PriceColumn)) + adjustColumn(PriceColumn); + if(columnWidth(ValueColumn)) + adjustColumn(ValueColumn); + + // make amount columns all the same size + // only extend the entry columns to make sure they fit + // the widget + int dwidth = 0; + int ewidth = 0; + if(ewidth < columnWidth(PaymentColumn)) + ewidth = columnWidth(PaymentColumn); + if(ewidth < columnWidth(DepositColumn)) + ewidth = columnWidth(DepositColumn); + if(dwidth < columnWidth(BalanceColumn)) + dwidth = columnWidth(BalanceColumn); + if(ewidth < columnWidth(PriceColumn)) + ewidth = columnWidth(PriceColumn); + if(dwidth < columnWidth(ValueColumn)) + dwidth = columnWidth(ValueColumn); + + int swidth = columnWidth(SecurityColumn); + if(swidth > 0) { + adjustColumn(SecurityColumn); + swidth = columnWidth(SecurityColumn); + } + +#ifndef KMM_DESIGNER + // Resize the date and money fields to either + // a) the size required by the input widget if no transaction form is shown + // b) the adjusted value for the input widget if the transaction form is visible + if(!KMyMoneyGlobalSettings::transactionForm()) { + kMyMoneyDateInput* dateField = new kMyMoneyDateInput; + kMyMoneyEdit* valField = new kMyMoneyEdit; + + dateField->setFont(KMyMoneyGlobalSettings::listCellFont()); + setColumnWidth(DateColumn, dateField->minimumSizeHint().width()); + valField->setMinimumWidth(ewidth); + ewidth = valField->minimumSizeHint().width(); + + if(swidth > 0) { + swidth = columnWidth(SecurityColumn) + 40; + } + delete valField; + delete dateField; + } else { + adjustColumn(DateColumn); + } +#endif + + if(columnWidth(PaymentColumn)) + setColumnWidth(PaymentColumn, ewidth); + if(columnWidth(DepositColumn)) + setColumnWidth(DepositColumn, ewidth); + if(columnWidth(BalanceColumn)) + setColumnWidth(BalanceColumn, dwidth); + if(columnWidth(PriceColumn)) + setColumnWidth(PriceColumn, ewidth); + if(columnWidth(ValueColumn)) + setColumnWidth(ValueColumn, dwidth); + + if(columnWidth(ReconcileFlagColumn)) + setColumnWidth(ReconcileFlagColumn, 20); + + if(swidth > 0) + setColumnWidth(SecurityColumn, swidth); +#if 0 + // see comment above + } else { + QStringList colSizes = QStringList::split(",", m_account.value("kmm-ledger-column-width"), true); + for(int i; i < colSizes.count(); ++i) { + int colWidth = colSizes[i].toInt(); + if(colWidth == 0) + continue; + setColumnWidth(i, w * colWidth / 100); + } + } +#endif + + for(int i = 0; i < numCols(); ++i) { + if(i == col) + continue; + + w -= columnWidth(i); + } + setColumnWidth(col, w); + + setUpdatesEnabled(enabled); + updateContents(); +} + + +void Register::adjustColumn(int col) +{ +#ifdef KMM_DESIGNER + Q_UNUSED(col) +#else + QString msg = "%1 adjusting column %2"; + ::timetrace((msg.arg("Start").arg(col)).data()); + QHeader *topHeader = horizontalHeader(); + QFontMetrics cellFontMetrics(KMyMoneyGlobalSettings::listCellFont()); + + int w = topHeader->fontMetrics().width( topHeader->label( col ) ) + 10; + if ( topHeader->iconSet( col ) ) + w += topHeader->iconSet( col )->pixmap().width(); + w = QMAX( w, 20 ); + + int maxWidth = 0; + switch(col) { + case NumberColumn: + maxWidth = cellFontMetrics.width("0123456789"); + break; + default: + break; + } + + // check for date column + if(col == DateColumn) { + QString txt = KGlobal::locale()->formatDate(QDate(6999,12,29), true); + int nw = cellFontMetrics.width(txt+" "); + w = QMAX( w, nw ); + } else { + + // scan through the transactions + for(unsigned i = 0; i < m_items.size(); ++i) { + RegisterItem* const item = m_items[i]; + if(!item) + continue; + Transaction* t = dynamic_cast<Transaction*>(item); + if(t) { + int nw = t->registerColWidth(col, cellFontMetrics); + w = QMAX( w, nw ); + if(maxWidth) { + if(w > maxWidth) { + w = maxWidth; + break; + } + } + } + } + } + + setColumnWidth( col, w ); +#endif +} + +void Register::repaintItems(RegisterItem* first, RegisterItem* last) +{ + if(first == 0 && last == 0) { + first = firstItem(); + last = lastItem(); + } + + if(first == 0) + return; + + if(last == 0) + last = first; + + // qDebug("repaintItems from row %d to row %d", first->startRow(), last->startRow()+last->numRowsRegister()-1); + + // the following code is based on code I found in + // QTable::cellGeometry() and QTable::updateCell() (ipwizard) + QRect cg(0, + rowPos(first->startRow()), + visibleWidth(), + rowPos(last->startRow()+last->numRowsRegister()-1) - rowPos(first->startRow()) + rowHeight(last->startRow()+last->numRowsRegister()-1)); + + QRect r(contentsToViewport(QPoint (cg.x() - 2, cg.y() - 2 )), QSize(cg.width() + 4, cg.height() + 4 )); + + QRect tmp = m_lastRepaintRect | r; + if(abs(tmp.height()) > 3000) { + // make sure that the previously triggered repaint has been done before we + // trigger the next. Not having this used to cause some trouble when changing + // the focus within a 2000 item ledger from the last to the first item. + QApplication::eventLoop()->processEvents(QEventLoop::ExcludeUserInput, 10); + } + m_lastRepaintRect = r; + QApplication::postEvent( viewport(), new QPaintEvent( r, FALSE ) ); + +} + +void Register::clearSelection(void) +{ + unselectItems(); +} + +void Register::doSelectItems(int from, int to, bool selected) +{ + int start, end; + // make sure start is smaller than end + if(from <= to) { + start = from; + end = to; + } else { + start = to; + end = from; + } + // make sure we stay in bounds + if(start < 0) + start = 0; + if((end <= -1) || ((unsigned)end > (m_items.size()-1))) + end = m_items.size()-1; + + RegisterItem* firstItem; + RegisterItem* lastItem; + firstItem = lastItem = 0; + for(int i = start; i <= end; ++i) { + RegisterItem* const item = m_items[i]; + if(item) { + if(selected != item->isSelected()) { + if(!firstItem) + firstItem = item; + item->setSelected(selected); + lastItem = item; + } + } + } + + // anything changed? + if(firstItem || lastItem) + repaintItems(firstItem, lastItem); +} + +RegisterItem* Register::itemAtRow(int row) const +{ + if(row >= 0 && (unsigned)row < m_itemIndex.size()) { + return m_itemIndex[row]; + } + return 0; +} + +int Register::rowToIndex(int row) const +{ + for(unsigned i = 0; i < m_items.size(); ++i) { + RegisterItem* const item = m_items[i]; + if(!item) + continue; + if(row >= item->startRow() && row < (item->startRow() + item->numRowsRegister())) + return i; + } + return -1; +} + +void Register::selectedTransactions(SelectedTransactions& list) const +{ + if(m_focusItem && m_focusItem->isSelected() && m_focusItem->isVisible()) { + Transaction* t = dynamic_cast<Transaction*>(m_focusItem); + if(t) { + QString id; + if(t->isScheduled()) + id = t->transaction().id(); + SelectedTransaction s(t->transaction(), t->split(), id); + list << s; + } + } + + for(unsigned i = 0; i < m_items.size(); ++i) { + RegisterItem* const item = m_items[i]; + // make sure, we don't include the focus item twice + if(item == m_focusItem) + continue; + if(item && item->isSelected() && item->isVisible()) { + Transaction* t = dynamic_cast<Transaction*>(item); + if(t) { + QString id; + if(t->isScheduled()) + id = t->transaction().id(); + SelectedTransaction s(t->transaction(), t->split(), id); + list << s; + } + } + } +} + +QValueList<RegisterItem*> Register::selectedItems(void) const +{ + QValueList<RegisterItem*> list; + + RegisterItem* item = m_firstItem; + while(item) { + if(item && item->isSelected() && item->isVisible()) { + list << item; + } + item = item->nextItem(); + } + return list; +} + +int Register::selectedItemsCount(void) const +{ + int cnt = 0; + RegisterItem* item = m_firstItem; + while(item) { + if(item->isSelected() && item->isVisible()) + ++cnt; + item = item->nextItem(); + } + return cnt; +} + +void Register::contentsMouseReleaseEvent( QMouseEvent *e ) +{ + if(m_ignoreNextButtonRelease) { + m_ignoreNextButtonRelease = false; + return; + } + + m_buttonState = e->state(); + QTable::contentsMouseReleaseEvent(e); +} + +void Register::selectItem(int row, int col, int button, const QPoint& /* mousePos */) +{ + if(row >= 0 && (unsigned)row < m_itemIndex.size()) { + RegisterItem* item = m_itemIndex[row]; + + // don't support selecting when the item has an editor + // or the item itself is not selectable + if(item->hasEditorOpen() || !item->isSelectable()) + return; + + QString id = item->id(); + selectItem(item); + // selectItem() might have changed the pointers, so we + // need to reconstruct it here + item = itemById(id); + Transaction* t = dynamic_cast<Transaction*>(item); + if(t) { + if(!id.isEmpty()) { + switch(button & Qt::MouseButtonMask) { + case Qt::RightButton: + emit openContextMenu(); + break; + + case Qt::LeftButton: + if(t && col == ReconcileFlagColumn && selectedItemsCount() == 1 && !t->isScheduled()) + emit reconcileStateColumnClicked(t); + break; + + default: + break; + } + } else { + emit emptyItemSelected(); + } + } + } +} + +void Register::setAnchorItem(RegisterItem* anchorItem) +{ + m_selectAnchor = anchorItem; +} + +bool Register::setFocusItem(RegisterItem* focusItem) +{ + if(focusItem && focusItem->canHaveFocus()) { + if(m_focusItem) { + m_focusItem->setFocus(false); + // issue a repaint here only if we move the focus + if(m_focusItem != focusItem) + repaintItems(m_focusItem); + } + Transaction* item = dynamic_cast<Transaction*>(focusItem); + if(m_focusItem != focusItem && item) { + emit focusChanged(item); + } + + m_focusItem = focusItem; + m_focusItem->setFocus(true); + if(m_listsDirty) + updateRegister(KMyMoneyGlobalSettings::ledgerLens() | !KMyMoneyGlobalSettings::transactionForm()); + ensureItemVisible(m_focusItem); + repaintItems(m_focusItem); + return true; + } else + return false; +} + +bool Register::setFocusToTop(void) +{ + RegisterItem* rgItem=m_firstItem; + while (rgItem) { + if (setFocusItem(rgItem)) + return true; + rgItem=rgItem->nextItem(); + } + return false; +} + +void Register::selectItem(RegisterItem* item, bool dontChangeSelections) +{ + if(!item) + return; + + // kdDebug(2) << "Register::selectItem(" << item << "): type is " << typeid(*item).name() << endl; + + Qt::ButtonState buttonState = m_buttonState; + m_buttonState = Qt::NoButton; + + if(m_selectionMode == NoSelection) + return; + + if(item->isSelectable()) { + QString id = item->id(); + QValueList<RegisterItem*> itemList = selectedItems(); + bool okToSelect = true; + int cnt = itemList.count(); + bool sameEntryType = true; + if(cnt > 0) { + if(typeid(*itemList.begin()) != typeid(item)) + sameEntryType = false; + } + + if(buttonState & Qt::LeftButton) { + if(!(buttonState & (Qt::ShiftButton | Qt::ControlButton))) { + if((cnt != 1) || ((cnt == 1) && !item->isSelected())) { + emit aboutToSelectItem(item, okToSelect); + if(okToSelect) { + // pointer 'item' might have changed. reconstruct it. + item = itemById(id); + unselectItems(); + item->setSelected(true); + setFocusItem(item); + } + } + if(okToSelect) + m_selectAnchor = item; + } + + if(m_selectionMode == Multi) { + switch(buttonState & (Qt::ShiftButton | Qt::ControlButton)) { + case Qt::ControlButton: + okToSelect = sameEntryType; + if(typeid(*item) == typeid(StdTransactionScheduled)) + okToSelect = false; + // toggle selection state of current item + emit aboutToSelectItem(item, okToSelect); + if(okToSelect) { + // pointer 'item' might have changed. reconstruct it. + item = itemById(id); + item->setSelected(!item->isSelected()); + setFocusItem(item); + } + break; + + case Qt::ShiftButton: + okToSelect = sameEntryType; + if(typeid(*item) == typeid(StdTransactionScheduled)) + okToSelect = false; + emit aboutToSelectItem(item, okToSelect); + if(okToSelect) { + // pointer 'item' might have changed. reconstruct it. + item = itemById(id); + unselectItems(); + selectItems(rowToIndex(m_selectAnchor->startRow()), rowToIndex(item->startRow())); + setFocusItem(item); + } + break; + } + } + } else if(buttonState & Qt::RightButton) { + // if the right button is pressed then only change the + // selection if none of the Shift/Ctrl button is pressed and + // one of the following conditions is true: + // + // a) single transaction is selected + // b) multiple transactions are selected and the one to be selected is not + if(!(buttonState & (Qt::ShiftButton | Qt::ControlButton))) { + if((cnt > 0) && (!item->isSelected())) { + okToSelect = sameEntryType; + emit aboutToSelectItem(item, okToSelect); + if(okToSelect) { + // pointer 'item' might have changed. reconstruct it. + item = itemById(id); + unselectItems(); + item->setSelected(true); + setFocusItem(item); + } + } + if(okToSelect) + m_selectAnchor = item; + } + } else { + // we get here when called by application logic + emit aboutToSelectItem(item, okToSelect); + if(okToSelect) { + // pointer 'item' might have changed. reconstruct it. + item = itemById(id); + if(!dontChangeSelections) + unselectItems(); + item->setSelected(true); + setFocusItem(item); + m_selectAnchor = item; + } + } + if(okToSelect) { + SelectedTransactions list(this); + emit selectionChanged(list); + } + } +} + +void Register::ensureItemVisible(RegisterItem* item) +{ + if(!item) + return; + + m_ensureVisibleItem = item; + QTimer::singleShot(0, this, SLOT(slotEnsureItemVisible())); +} + +void Register::slotDoubleClicked(int row, int, int, const QPoint&) +{ + if(row >= 0 && (unsigned)row < m_itemIndex.size()) { + RegisterItem* p = m_itemIndex[row]; + if(p->isSelectable()) { + m_ignoreNextButtonRelease = true; + // double click to start editing only works if the focus + // item is among the selected ones + if(!focusItem()) { + setFocusItem(p); + if(m_selectionMode != NoSelection) + p->setSelected(true); + } + + if(m_focusItem->isSelected()) { + // don't emit the signal right away but wait until + // we come back to the Qt main loop + QTimer::singleShot(0, this, SIGNAL(editTransaction())); + } + } + } +} + +void Register::slotEnsureItemVisible(void) +{ + // if clear() has been called since the timer was + // started, we just ignore the call + if(!m_ensureVisibleItem) + return; + + // make sure to catch latest changes + bool enabled = isUpdatesEnabled(); + setUpdatesEnabled(false); + updateRegister(); + setUpdatesEnabled(enabled); + + RegisterItem* item = m_ensureVisibleItem; + RegisterItem* prev = item->prevItem(); + while(prev && !prev->isVisible()) + prev = prev->prevItem(); + RegisterItem* next = item->nextItem(); + while(next && !next->isVisible()) + next = next->nextItem(); + + int rowPrev, rowNext; + rowPrev = item->startRow(); + rowNext = item->startRow() + item->numRowsRegister() - 1; + + if(prev) + rowPrev = prev->startRow(); + if(next) + rowNext = next->startRow() + next->numRowsRegister() - 1; + + if(rowPrev < 0) + rowPrev = 0; + if(rowNext >= numRows()) + rowNext = numRows()-1; + + int wt = contentsY(); // window top + int wh = visibleHeight(); // window height + int lt = rowPos(rowPrev); // top of line above lens + int lb = rowPos(rowNext)+rowHeight(rowNext); // bottom of line below lens + + // only update widget, if the transaction is not fully visible + if(lt < wt || lb >= (wt + wh)) { + if(rowPrev >= 0) { + ensureCellVisible(rowPrev, 0); + } + + ensureCellVisible(item->startRow(), 0); + + if(rowNext < numRows()) { + ensureCellVisible(rowNext, 0); + } + } +} + +TransactionSortField KMyMoneyRegister::textToSortOrder(const QString& text) +{ + for(int idx = 1; idx < static_cast<int>(MaxSortFields); ++idx) { + if(text == i18n(sortOrderText[idx])) { + return static_cast<TransactionSortField>(idx); + } + } + return UnknownSort; +} + +const QString KMyMoneyRegister::sortOrderToText(TransactionSortField idx) +{ + if(idx < PostDateSort || idx >= MaxSortFields) + idx = UnknownSort; + return i18n(sortOrderText[idx]); +} + +QString Register::text(int /*row*/, int /*col*/) const +{ + return QString("a"); +} + +QWidget* Register::cellWidget(int row, int col) const +{ + // separeted here in two if()s, because this method is called for each + // event from QTable::eventFilter and in the most cases it is -1, -1 + if(row < 0 || col < 0) + return 0; + + if(row > numRows() - 1 || col > numCols() - 1) { + if(numRows() && numCols()) + qWarning("Register::cellWidget(%d,%d) out of bounds (%d,%d)", row, col, numRows(), numCols()); + return 0; + } + + if(!m_cellWidgets.count()) + return 0; + + QWidget* w = 0; + QPair<int, int> idx = qMakePair(row, col); + QMap<QPair<int, int>, QWidget*>::const_iterator it_w; + + it_w = m_cellWidgets.find(idx); + if(it_w != m_cellWidgets.end()) + w = *it_w; + return w; +} + +void Register::insertWidget(int row, int col, QWidget* w) +{ + if(row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1) { + qWarning("Register::insertWidget(%d,%d) out of bounds", row, col); + return; + } + + QPair<int, int> idx = qMakePair(row, col); + m_cellWidgets[idx] = w; +} + +void Register::clearCellWidget(int row, int col) +{ + if(row < 0 || col < 0 || row > numRows() - 1 || col > numCols() - 1) { + qWarning("Register::clearCellWidget(%d,%d) out of bounds", row, col); + return; + } + + QPair<int, int> idx = qMakePair(row, col); + QMap<QPair<int, int>, QWidget*>::iterator it_w; + + it_w = m_cellWidgets.find(idx); + if(it_w != m_cellWidgets.end()) { + (*it_w)->deleteLater(); + m_cellWidgets.remove(it_w); + } +} + +QWidget* Register::createEditor(int /*row*/, int /*col*/, bool /*initFromCell*/) const +{ + return 0; +} + +void Register::setCellContentFromEditor(int /*row*/, int /*col*/) +{ +} + +void Register::endEdit(int /*row*/, int /*col*/, bool /*accept*/, bool /*replace*/) +{ +} + +void Register::arrangeEditWidgets(QMap<QString, QWidget*>& editWidgets, KMyMoneyRegister::Transaction* t) +{ + t->arrangeWidgetsInRegister(editWidgets); + ensureItemVisible(t); + // updateContents(); +} + +void Register::tabOrder(QWidgetList& tabOrderWidgets, KMyMoneyRegister::Transaction* t) const +{ + t->tabOrderInRegister(tabOrderWidgets); +} + +void Register::removeEditWidgets(QMap<QString, QWidget*>& editWidgets) +{ + // remove pointers from map + QMap<QString, QWidget*>::iterator it; + for(it = editWidgets.begin(); it != editWidgets.end(); ) { + if((*it)->parentWidget() == this) { + editWidgets.remove(it); + it = editWidgets.begin(); + } else + ++it; + } + + // now delete the widgets + KMyMoneyRegister::Transaction* t = dynamic_cast<KMyMoneyRegister::Transaction*>(focusItem()); + for(int row = t->startRow(); row < t->startRow() + t->numRowsRegister(true); ++row) { + for(int col = 0; col < numCols(); ++col) { + if(cellWidget(row, col)) + clearCellWidget(row, col); + } + // make sure to reduce the possibly size to what it was before editing started + setRowHeight(row, t->rowHeightHint()); + } +} + +void Register::slotToggleErronousTransactions(void) +{ + // toggle switch + m_markErronousTransactions ^= 1; + + // check if anything needs to be redrawn + KMyMoneyRegister::RegisterItem* p = m_firstErronous; + while(p && p->prevItem() != m_lastErronous) { + if(p->isErronous()) + repaintItems(p); + p = p->nextItem(); + } + + // restart timer + QTimer::singleShot(500, this, SLOT(slotToggleErronousTransactions())); +} + +RegisterItem* Register::itemById(const QString& id) const +{ + if(id.isEmpty()) + return m_lastItem; + + for(QValueVector<RegisterItem*>::size_type i = 0; i < m_items.size(); ++i) { + RegisterItem* item = m_items[i]; + if(!item) + continue; + if(item->id() == id) + return item; + } + return 0; +} + +void Register::handleItemChange(RegisterItem* old, bool shift, bool control) +{ + if(m_selectionMode == Multi) { + if(shift) { + selectRange(m_selectAnchor ? m_selectAnchor : old, + m_focusItem, false, true, (m_selectAnchor && !control) ? true : false); + } else if(!control) { + selectItem(m_focusItem, false); + } + } +} + +void Register::selectRange(RegisterItem* from, RegisterItem* to, bool invert, bool includeFirst, bool clearSel) +{ + if(!from || !to) + return; + if(from == to && !includeFirst) + return; + bool swap = false; + if(to == from->prevItem()) + swap = true; + + RegisterItem* item; + if(!swap && from != to && from != to->prevItem()) { + bool found = false; + for(item = from; item; item = item->nextItem()) { + if(item == to) { + found = true; + break; + } + } + if(!found) + swap = true; + } + + if(swap) { + item = from; + from = to; + to = item; + if(!includeFirst) + to = to->prevItem(); + + } else if(!includeFirst) { + from = from->nextItem(); + } + + bool changed = false; + if(clearSel) { + for(item = firstItem(); item; item = item->nextItem()) { + if(item->isSelected() && item->isVisible()) { + item->setSelected(false); + changed = true; + } + } + } + + for(item = from; item; item = item->nextItem()) { + if(item->isSelectable()) { + if(!invert) { + if(!item->isSelected() && item->isVisible()) { + item->setSelected(true); + changed = true; + } + } else { + bool sel = !item->isSelected(); + if((item->isSelected() != sel) && (sel || !sel)) { + if(item->isVisible()) { + item->setSelected(sel); + changed = true; + } + } + } + } + if(item == to) + break; + } +} + +void Register::scrollPage(int key, ButtonState state) +{ + RegisterItem* oldFocusItem = m_focusItem; + + // make sure we have a focus item + if(!m_focusItem) + setFocusItem(m_firstItem); + if(!m_focusItem && m_firstItem) + setFocusItem(m_firstItem->nextItem()); + if(!m_focusItem) + return; + + RegisterItem* item = m_focusItem; + int height = 0; + + switch(key) { + case Qt::Key_PageUp: + while(height < visibleHeight() && item->prevItem()) { + do { + item = item->prevItem(); + if(item->isVisible()) + height += item->rowHeightHint(); + } while((!item->isSelectable() || !item->isVisible()) && item->prevItem()); + } + break; + case Qt::Key_PageDown: + while(height < visibleHeight() && item->nextItem()) { + do { + if(item->isVisible()) + height += item->rowHeightHint(); + item = item->nextItem(); + } while((!item->isSelectable() || !item->isVisible()) && item->nextItem()); + } + break; + + case Qt::Key_Up: + if(item->prevItem()) { + do { + item = item->prevItem(); + } while((!item->isSelectable() || !item->isVisible()) && item->prevItem()); + } + break; + + case Qt::Key_Down: + if(item->nextItem()) { + do { + item = item->nextItem(); + } while((!item->isSelectable() || !item->isVisible()) && item->nextItem()); + } + break; + + case Qt::Key_Home: + item = m_firstItem; + while((!item->isSelectable() || !item->isVisible()) && item->nextItem()) + item = item->nextItem(); + break; + + case Qt::Key_End: + item = m_lastItem; + while((!item->isSelectable() || !item->isVisible()) && item->prevItem()) + item = item->prevItem(); + break; + } + + // make sure to avoid selecting a possible empty transaction at the end + Transaction* t = dynamic_cast<Transaction*>(item); + if(t && t->transaction().id().isEmpty()) { + if(t->prevItem()) { + item = t->prevItem(); + } + } + + if(!(state & ShiftButton) || !m_selectAnchor) + m_selectAnchor = item; + + setFocusItem(item); + + if(item->isSelectable()) { + handleItemChange(oldFocusItem, state & Qt::ShiftButton, state & Qt::ControlButton); + // tell the world about the changes in selection + SelectedTransactions list(this); + emit selectionChanged(list); + } + + if(m_focusItem && !m_focusItem->isSelected() && m_selectionMode == Single) + selectItem(item); +} + +void Register::keyPressEvent(QKeyEvent* ev) +{ + switch(ev->key()) { + case Qt::Key_Space: + if(m_selectionMode != NoSelection) { + // get the state out of the event ... + m_buttonState = ev->state(); + // ... and pretend that we have pressed the left mouse button ;) + m_buttonState = static_cast<Qt::ButtonState>(m_buttonState | Qt::LeftButton); + selectItem(m_focusItem); + } + break; + + case Qt::Key_PageUp: + case Qt::Key_PageDown: + case Qt::Key_Home: + case Qt::Key_End: + case Qt::Key_Down: + case Qt::Key_Up: + scrollPage(ev->key(), ev->state()); + break; + + default: + QTable::keyPressEvent(ev); + break; + } +} + +Transaction* Register::transactionFactory(Register *parent, const MyMoneyTransaction& transaction, const MyMoneySplit& split, int uniqueId) +{ + Transaction* t = 0; + MyMoneySplit s = split; + + if(parent->account() == MyMoneyAccount()) { + t = new KMyMoneyRegister::StdTransaction(parent, transaction, s, uniqueId); + return t; + } + + switch(parent->account().accountType()) { + case MyMoneyAccount::Checkings: + case MyMoneyAccount::Savings: + case MyMoneyAccount::Cash: + case MyMoneyAccount::CreditCard: + case MyMoneyAccount::Loan: + case MyMoneyAccount::Asset: + case MyMoneyAccount::Liability: + case MyMoneyAccount::Currency: + case MyMoneyAccount::Income: + case MyMoneyAccount::Expense: + case MyMoneyAccount::AssetLoan: + case MyMoneyAccount::Equity: + if(s.accountId().isEmpty()) + s.setAccountId(parent->account().id()); + if(s.isMatched()) + t = new KMyMoneyRegister::StdTransactionMatched(parent, transaction, s, uniqueId); + else if(transaction.isImported()) + t = new KMyMoneyRegister::StdTransactionDownloaded(parent, transaction, s, uniqueId); + else + t = new KMyMoneyRegister::StdTransaction(parent, transaction, s, uniqueId); + break; + + case MyMoneyAccount::Investment: + if(s.isMatched()) + t = new KMyMoneyRegister::InvestTransaction/* Matched */(parent, transaction, s, uniqueId); + else if(transaction.isImported()) + t = new KMyMoneyRegister::InvestTransactionDownloaded(parent, transaction, s, uniqueId); + else + t = new KMyMoneyRegister::InvestTransaction(parent, transaction, s, uniqueId); + break; + + case MyMoneyAccount::CertificateDep: + case MyMoneyAccount::MoneyMarket: + case MyMoneyAccount::Stock: + default: + qDebug("Register::transactionFactory: invalid accountTypeE %d", parent->account().accountType()); + break; + } + return t; +} + +void Register::addGroupMarkers(void) +{ + QMap<QString, int> list; + QMap<QString, int>::const_iterator it; + KMyMoneyRegister::RegisterItem* p = firstItem(); + KMyMoneyRegister::Transaction* t; + QString name; + QDate today; + QDate yesterday, thisWeek, lastWeek; + QDate thisMonth, lastMonth; + QDate thisYear; + int weekStartOfs; + + switch(primarySortKey()) { + case KMyMoneyRegister::PostDateSort: + case KMyMoneyRegister::EntryDateSort: + today = QDate::currentDate(); + thisMonth.setYMD(today.year(), today.month(), 1); + lastMonth = thisMonth.addMonths(-1); + yesterday = today.addDays(-1); + // a = QDate::dayOfWeek() todays weekday (1 = Monday, 7 = Sunday) + // b = KLocale::weekStartDay() first day of week (1 = Monday, 7 = Sunday) + weekStartOfs = today.dayOfWeek() - KGlobal::locale()->weekStartDay(); + if(weekStartOfs < 0) { + weekStartOfs = 7 + weekStartOfs; + } + thisWeek = today.addDays(-weekStartOfs); + lastWeek = thisWeek.addDays(-7); + thisYear.setYMD(today.year(), 1, 1); + if(KMyMoneyGlobalSettings::startDate().date() != QDate(1900,1,1)) + new KMyMoneyRegister::FancyDateGroupMarker(this, KMyMoneyGlobalSettings::startDate().date(), i18n("Prior transactions possibly filtered")); + + if(KMyMoneyGlobalSettings::showFancyMarker()) { + if(m_account.lastReconciliationDate().isValid()) + new KMyMoneyRegister::StatementGroupMarker(this, KMyMoneyRegister::Deposit, m_account.lastReconciliationDate(), i18n("Last reconciliation")); + + if(!m_account.value("lastImportedTransactionDate").isEmpty() + && !m_account.value("lastStatementBalance").isEmpty()) { + MyMoneyMoney balance(m_account.value("lastStatementBalance")); + if(m_account.accountGroup() == MyMoneyAccount::Liability) + balance = -balance; + QString txt = i18n("Online Statement Balance: %1").arg(balance.formatMoney(m_account.fraction())); + new KMyMoneyRegister::StatementGroupMarker(this, KMyMoneyRegister::Deposit, QDate::fromString(m_account.value("lastImportedTransactionDate"), Qt::ISODate), txt); + } + + new KMyMoneyRegister::FancyDateGroupMarker(this, thisYear, i18n("This year")); + new KMyMoneyRegister::FancyDateGroupMarker(this, lastMonth, i18n("Last month")); + new KMyMoneyRegister::FancyDateGroupMarker(this, thisMonth, i18n("This month")); + new KMyMoneyRegister::FancyDateGroupMarker(this, lastWeek, i18n("Last week")); + new KMyMoneyRegister::FancyDateGroupMarker(this, thisWeek, i18n("This week")); + new KMyMoneyRegister::FancyDateGroupMarker(this, yesterday, i18n("Yesterday")); + new KMyMoneyRegister::FancyDateGroupMarker(this, today, i18n("Today")); + new KMyMoneyRegister::FancyDateGroupMarker(this, today.addDays(1), i18n("Future transactions")); + new KMyMoneyRegister::FancyDateGroupMarker(this, thisWeek.addDays(7), i18n("Next week")); + new KMyMoneyRegister::FancyDateGroupMarker(this, thisMonth.addMonths(1), i18n("Next month")); + + } else { + new KMyMoneyRegister::SimpleDateGroupMarker(this, today.addDays(1), i18n("Future transactions")); + } + if(KMyMoneyGlobalSettings::showFiscalMarker()) { + QDate currentFiscalYear(QDate::currentDate().year(), KMyMoneyGlobalSettings::firstFiscalMonth(), KMyMoneyGlobalSettings::firstFiscalDay()); + + if(QDate::currentDate() < currentFiscalYear) + currentFiscalYear = currentFiscalYear.addYears(-1); + QDate previousFiscalYear = currentFiscalYear.addYears(-1); + new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear, i18n("Current fiscal year")); + new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear.addYears(-1), i18n("Previous fiscal year")); + new KMyMoneyRegister::FiscalYearGroupMarker(this, currentFiscalYear.addYears(1), i18n("Next fiscal year")); + } + break; + + case KMyMoneyRegister::TypeSort: + if(KMyMoneyGlobalSettings::showFancyMarker()) { + new KMyMoneyRegister::TypeGroupMarker(this, KMyMoneyRegister::Deposit, m_account.accountType()); + new KMyMoneyRegister::TypeGroupMarker(this, KMyMoneyRegister::Payment, m_account.accountType()); + } + break; + + case KMyMoneyRegister::ReconcileStateSort: + if(KMyMoneyGlobalSettings::showFancyMarker()) { + new KMyMoneyRegister::ReconcileGroupMarker(this, MyMoneySplit::NotReconciled); + new KMyMoneyRegister::ReconcileGroupMarker(this, MyMoneySplit::Cleared); + new KMyMoneyRegister::ReconcileGroupMarker(this, MyMoneySplit::Reconciled); + new KMyMoneyRegister::ReconcileGroupMarker(this, MyMoneySplit::Frozen); + } + break; + + case KMyMoneyRegister::PayeeSort: + if(KMyMoneyGlobalSettings::showFancyMarker()) { + while(p) { + t = dynamic_cast<KMyMoneyRegister::Transaction*>(p); + if(t) { + list[t->sortPayee()] = 1; + } + p = p->nextItem(); + } + for(it = list.begin(); it != list.end(); ++it) { + name = it.key(); + if(name.isEmpty()) { + name = i18n("Unknown payee", "Unknown"); + } + new KMyMoneyRegister::PayeeGroupMarker(this, name); + } + } + break; + + case KMyMoneyRegister::CategorySort: + if(KMyMoneyGlobalSettings::showFancyMarker()) { + while(p) { + t = dynamic_cast<KMyMoneyRegister::Transaction*>(p); + if(t) { + list[t->sortCategory()] = 1; + } + p = p->nextItem(); + } + for(it = list.begin(); it != list.end(); ++it) { + name = it.key(); + if(name.isEmpty()) { + name = i18n("Unknown category", "Unknown"); + } + new KMyMoneyRegister::CategoryGroupMarker(this, name); + } + } + break; + + case KMyMoneyRegister::SecuritySort: + if(KMyMoneyGlobalSettings::showFancyMarker()) { + while(p) { + t = dynamic_cast<KMyMoneyRegister::InvestTransaction*>(p); + if(t) { + list[t->sortSecurity()] = 1; + } + p = p->nextItem(); + } + for(it = list.begin(); it != list.end(); ++it) { + name = it.key(); + if(name.isEmpty()) { + name = i18n("Unknown security", "Unknown"); + } + new KMyMoneyRegister::CategoryGroupMarker(this, name); + } + } + break; + + default: // no markers supported + break; + } +} + +void Register::removeUnwantedGroupMarkers(void) +{ + // remove all trailing group markers except statement markers + KMyMoneyRegister::RegisterItem* q; + KMyMoneyRegister::RegisterItem* p = lastItem(); + while(p) { + q = p; + if(dynamic_cast<KMyMoneyRegister::Transaction*>(p) + || dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(p)) + break; + + p = p->prevItem(); + delete q; + } + + // remove all adjacent group markers + bool lastWasGroupMarker = false; + p = lastItem(); + while(p) { + q = p; + KMyMoneyRegister::GroupMarker* m = dynamic_cast<KMyMoneyRegister::GroupMarker*>(p); + p = p->prevItem(); + if(m) { + m->markVisible(true); + // make adjacent group marker invisible except those that show statement information + if(lastWasGroupMarker && (dynamic_cast<KMyMoneyRegister::StatementGroupMarker*>(m) == 0)) { + m->markVisible(false); + } + lastWasGroupMarker = true; + } else if(q->isVisible()) + lastWasGroupMarker = false; + } +} + + +#include "register.moc" + +// vim:cin:si:ai:et:ts=2:sw=2: |