From dadc34655c3ab961b0b0b94a10eaaba710f0b5e8 Mon Sep 17 00:00:00 2001 From: tpearson Date: Mon, 4 Jul 2011 22:38:03 +0000 Subject: Added kmymoney git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kmymoney2/dialogs/kmymoneysplittable.cpp | 999 +++++++++++++++++++++++++++++++ 1 file changed, 999 insertions(+) create mode 100644 kmymoney2/dialogs/kmymoneysplittable.cpp (limited to 'kmymoney2/dialogs/kmymoneysplittable.cpp') diff --git a/kmymoney2/dialogs/kmymoneysplittable.cpp b/kmymoney2/dialogs/kmymoneysplittable.cpp new file mode 100644 index 0000000..5b5f1af --- /dev/null +++ b/kmymoney2/dialogs/kmymoneysplittable.cpp @@ -0,0 +1,999 @@ +/*************************************************************************** + kmymoneysplittable.cpp - description + ------------------- + begin : Thu Jan 10 2002 + copyright : (C) 2000-2002 by Michael Edwardes + email : mte@users.sourceforge.net + Javier Campos Morales + Felix Rodriguez + John C + Thomas Baumgart + Kevin Tambascio + ***************************************************************************/ + +/*************************************************************************** + * * + * 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 + +// ---------------------------------------------------------------------------- +// QT Includes + +#include +#include +#include +#include +#include +#include +#include + +// ---------------------------------------------------------------------------- +// KDE Includes + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// ---------------------------------------------------------------------------- +// Project Includes + +#include "kmymoneysplittable.h" +#include +#include +#include +#include +#include +#include +#include + +#include "../dialogs/kcurrencycalculator.h" + +#include "../mymoney/mymoneyutils.h" + +kMyMoneySplitTable::kMyMoneySplitTable(QWidget *parent, const char *name ) : + QTable(parent,name), + m_currentRow(0), + m_maxRows(0), + m_editMode(false), + m_amountWidth(80), + m_editCategory(0), + m_editMemo(0), + m_editAmount(0) +{ + // setup the transactions table + setNumRows(1); + setNumCols(3); + horizontalHeader()->setLabel(0, i18n("Category")); + horizontalHeader()->setLabel(1, i18n("Memo")); + horizontalHeader()->setLabel(2, i18n("Amount")); + setSelectionMode(QTable::NoSelection); + setLeftMargin(0); + verticalHeader()->hide(); + setColumnStretchable(0, false); + setColumnStretchable(1, false); + setColumnStretchable(2, false); + horizontalHeader()->setResizeEnabled(false); + horizontalHeader()->setMovingEnabled(false); + horizontalHeader()->setFont(KMyMoneyGlobalSettings::listHeaderFont()); + + setVScrollBarMode(QScrollView::AlwaysOn); + // never show a horizontal scroll bar + setHScrollBarMode(QScrollView::AlwaysOff); + + // setup the context menu + m_contextMenu = new KPopupMenu(this); + KIconLoader *il = KGlobal::iconLoader(); + m_contextMenu->insertTitle(il->loadIcon("transaction", KIcon::MainToolbar), i18n("Split Options")); + m_contextMenu->insertItem(il->loadIcon("edit", KIcon::Small), i18n("Edit..."), this, SLOT(slotStartEdit())); + m_contextMenuDuplicate = m_contextMenu->insertItem(il->loadIcon("editcopy", KIcon::Small), i18n("Duplicate"), this, SLOT(slotDuplicateSplit())); + m_contextMenuDelete = m_contextMenu->insertItem(il->loadIcon("delete", KIcon::Small), + i18n("Delete ..."), + this, SLOT(slotDeleteSplit())); + + connect(this, SIGNAL(clicked(int, int, int, const QPoint&)), + this, SLOT(slotSetFocus(int, int, int, const QPoint&))); + + connect(this, SIGNAL(transactionChanged(const MyMoneyTransaction&)), + this, SLOT(slotUpdateData(const MyMoneyTransaction&))); +} + +kMyMoneySplitTable::~kMyMoneySplitTable() +{ +} + +void kMyMoneySplitTable::setup(const QMap& priceInfo) +{ + m_priceInfo = priceInfo; +} + +const QColor kMyMoneySplitTable::rowBackgroundColor(const int row) const +{ + return (row % 2) ? KMyMoneyGlobalSettings::listColor() : KMyMoneyGlobalSettings::listBGColor(); +} + +void kMyMoneySplitTable::paintCell(QPainter *p, int row, int col, const QRect& r, bool /*selected*/) +{ + QColorGroup g = colorGroup(); + QColor textColor; + + g.setColor(QColorGroup::Base, rowBackgroundColor(row)); + + p->setFont(KMyMoneyGlobalSettings::listCellFont()); + + QString firsttext = text(row, col); + QString qstringCategory; + QString qstringMemo; + + int intPos = firsttext.find("|"); + if(intPos > -1) + { + qstringCategory = firsttext.left(intPos); + qstringMemo = firsttext.mid(intPos + 1); + } + + QRect rr = r; + QRect rr2 = r; + rr.setX(0); + rr.setY(0); + rr.setWidth(columnWidth(col)); + rr.setHeight(rowHeight(row)); + + rr2.setX(2); + rr2.setY(0); + rr2.setWidth(columnWidth(col)-4); + rr2.setHeight(rowHeight(row)); + + + if(row == m_currentRow) { + QBrush backgroundBrush(g.highlight()); + textColor = g.highlightedText(); + p->fillRect(rr,backgroundBrush); + + } else { + QBrush backgroundBrush(g.base()); + textColor = g.text(); + p->fillRect(rr,backgroundBrush); + } + + if (KMyMoneyGlobalSettings::showGrid()) { + p->setPen(KMyMoneyGlobalSettings::listGridColor()); + if(col != 0) + p->drawLine(rr.x(), 0, rr.x(), rr.height()-1); // left frame + p->drawLine(rr.x(), rr.y(), rr.width(), 0); // bottom frame + p->setPen(textColor); + } + + switch (col) { + case 0: // category + case 1: // memo + p->drawText(rr2, Qt::AlignLeft | Qt::AlignVCenter, text(row, col)); + break; + + case 2: // amount + p->drawText(rr2, Qt::AlignRight | Qt::AlignVCenter,firsttext); + break; + } +} + +/** Override the QTable member function to avoid display of focus */ +void kMyMoneySplitTable::paintFocus(QPainter * /* p */, const QRect & /*cr*/) +{ +} + +void kMyMoneySplitTable::columnWidthChanged(int col) +{ + for (int i=0; i (e); + bool rc = false; + int row = currentRow(); + int lines = visibleHeight()/rowHeight(0); + QWidget* w; + + if(e->type() == QEvent::KeyPress && !isEditMode()) { + rc = true; + switch(k->key()) { + case Qt::Key_Up: + if(row) + slotSetFocus(row-1); + break; + + case Qt::Key_Down: + if(row < static_cast (m_transaction.splits().count()-1)) + slotSetFocus(row+1); + break; + + case Qt::Key_Home: + slotSetFocus(0); + break; + + case Qt::Key_End: + slotSetFocus(m_transaction.splits().count()-1); + break; + + case Qt::Key_PageUp: + if(lines) { + while(lines-- > 0 && row) + row--; + slotSetFocus(row); + } + break; + + case Qt::Key_PageDown: + if(row < static_cast (m_transaction.splits().count()-1)) { + while(lines-- > 0 && row < static_cast (m_transaction.splits().count()-1)) + row++; + slotSetFocus(row); + } + break; + + case Qt::Key_Delete: + slotDeleteSplit(); + break; + + case Qt::Key_Return: + case Qt::Key_Enter: + if(row < static_cast (m_transaction.splits().count()-1) + && KMyMoneyGlobalSettings::enterMovesBetweenFields()) { + slotStartEdit(); + } else + emit returnPressed(); + break; + + case Qt::Key_Escape: + emit escapePressed(); + break; + + case Qt::Key_F2: + slotStartEdit(); + break; + + default: + rc = true; + KShortcut copySplit(i18n("Duplicate split", "CTRL+c")); + KShortcut newSplit(QKeySequence(Qt::CTRL | Qt::Key_Insert)); + if(copySplit.contains(KKey(k))) { + slotDuplicateSplit(); + + } else if(newSplit.contains(KKey(k))) { + slotSetFocus(m_transaction.splits().count()-1); + slotStartEdit(); + + } else if ( k->text()[ 0 ].isPrint() ) { + w = slotStartEdit(); + // make sure, the widget receives the key again + QApplication::sendEvent(w, e); + } + break; + } + + } else if(e->type() == QEvent::KeyPress && isEditMode()) { + bool terminate = true; + rc = true; + switch(k->key()) { + // suppress the F2 functionality to start editing in inline edit mode + case Qt::Key_F2: + // suppress the cursor movement in inline edit mode + case Qt::Key_Up: + case Qt::Key_Down: + case Qt::Key_PageUp: + case Qt::Key_PageDown: + break; + + case Qt::Key_Return: + case Qt::Key_Enter: + // we cannot call the slot directly, as it destroys the caller of + // this method :-( So we let the event handler take care of calling + // the respective slot using a timeout. For a KLineEdit derived object + // it could be, that at this point the user selected a value from + // a completion list. In this case, we close the completion list and + // do not end editing of the transaction. + if(o->inherits("KLineEdit")) { + KLineEdit* le = dynamic_cast (o); + KCompletionBox* box = le->completionBox(false); + if(box && box->isVisible()) { + terminate = false; + le->completionBox(false)->hide(); + } + } + + // in case we have the 'enter moves focus between fields', we need to simulate + // a TAB key when the object 'o' points to the category or memo field. + if(KMyMoneyGlobalSettings::enterMovesBetweenFields()) { + if(o == m_editCategory->lineEdit() || o == m_editMemo) { + terminate = false; + QKeyEvent evt(e->type(), + Key_Tab, 0, k->state(), QString::null, + k->isAutoRepeat(), k->count()); + + QApplication::sendEvent( o, &evt ); + } + } + + if(terminate) { + QTimer::singleShot(0, this, SLOT(slotEndEditKeyboard())); + } + break; + + case Qt::Key_Escape: + // we cannot call the slot directly, as it destroys the caller of + // this method :-( So we let the event handler take care of calling + // the respective slot using a timeout. + QTimer::singleShot(0, this, SLOT(slotCancelEdit())); + break; + + default: + rc = false; + break; + } + } else if(e->type() == QEvent::KeyRelease && !isEditMode()) { + // for some reason, we only see a KeyRelease event of the Menu key + // here. In other locations (e.g. Register::eventFilter()) we see + // a KeyPress event. Strange. (ipwizard - 2008-05-10) + switch(k->key()) { + case Qt::Key_Menu: + // if the very last entry is selected, the delete + // operation is not available otherwise it is + m_contextMenu->setItemEnabled(m_contextMenuDelete, + row < static_cast (m_transaction.splits().count()-1)); + m_contextMenu->setItemEnabled(m_contextMenuDuplicate, + row < static_cast (m_transaction.splits().count()-1)); + + m_contextMenu->exec(QCursor::pos()); + rc = true; + break; + default: + break; + } + } + + // if the event has not been processed here, forward it to + // the base class implementation if it's not a key event + if(rc == false) { + if(e->type() != QEvent::KeyPress + && e->type() != QEvent::KeyRelease) { + rc = QTable::eventFilter(o, e); + } + } + + return rc; +} + +void kMyMoneySplitTable::slotSetFocus(int realrow, int /* col */, int button, const QPoint& /* point */) +{ + MYMONEYTRACER(tracer); + int row = realrow; + + // adjust row to used area + if(row > static_cast (m_transaction.splits().count()-1)) + row = m_transaction.splits().count()-1; + if(row < 0) + row = 0; + + // make sure the row will be on the screen + ensureCellVisible(row, 0); + + if(button == Qt::LeftButton) { // left mouse button + if(isEditMode()) { // in edit mode? + if(KMyMoneyGlobalSettings::focusChangeIsEnter()) + slotEndEdit(); + else + slotCancelEdit(); + } + if(row != static_cast (currentRow())) { + // setup new current row and update visible selection + setCurrentCell(row, 0); + slotUpdateData(m_transaction); + } + } else if(button == Qt::RightButton) { + // context menu is only available when cursor is on + // an existing transaction or the first line after this area + if(row == realrow) { + // setup new current row and update visible selection + setCurrentCell(row, 0); + slotUpdateData(m_transaction); + + // if the very last entry is selected, the delete + // operation is not available otherwise it is + m_contextMenu->setItemEnabled(m_contextMenuDelete, + row < static_cast (m_transaction.splits().count()-1)); + m_contextMenu->setItemEnabled(m_contextMenuDuplicate, + row < static_cast (m_transaction.splits().count()-1)); + + m_contextMenu->exec(QCursor::pos()); + } + } +} + +void kMyMoneySplitTable::contentsMousePressEvent( QMouseEvent* e ) +{ + slotSetFocus( rowAt(e->pos().y()), columnAt(e->pos().x()), e->button(), e->pos() ); +} + +/* turn off QTable behaviour */ +void kMyMoneySplitTable::contentsMouseReleaseEvent( QMouseEvent* /* e */ ) +{ +} + +void kMyMoneySplitTable::contentsMouseDoubleClickEvent( QMouseEvent *e ) +{ + MYMONEYTRACER(tracer); + + int col = columnAt(e->pos().x()); + slotSetFocus( rowAt(e->pos().y()), col, e->button(), e->pos() ); + slotStartEdit(); + + KLineEdit* editWidget = 0; + switch(col) { + case 1: + editWidget = m_editMemo; + break; + + case 2: + editWidget = dynamic_cast (m_editAmount->focusWidget()); + break; + + default: + break; + } + if(editWidget) { + editWidget->setFocus(); + editWidget->selectAll(); + // we need to call setFocus on the edit widget from the + // main loop again to get the keyboard focus to the widget also + QTimer::singleShot(0, editWidget, SLOT(setFocus())); + } +} + +void kMyMoneySplitTable::setCurrentCell(int row, int /* col */) +{ + MYMONEYTRACER(tracer); + + if(row > m_maxRows) + row = m_maxRows; + m_currentRow = row; + QTable::setCurrentCell(row, 0); + QValueList list = getSplits(m_transaction); + if(row < static_cast(list.count())) + m_split = list[row]; + else + m_split = MyMoneySplit(); +} + +void kMyMoneySplitTable::setNumRows(int irows) +{ + QTable::setNumRows(irows); + + // determine row height according to the edit widgets + // we use the category widget as the base + QFontMetrics fm( KMyMoneyGlobalSettings::listCellFont() ); + int height = fm.lineSpacing()+6; +#if 0 + // recalculate row height hint + KMyMoneyCategory cat; + height = QMAX(cat.sizeHint().height(), height); +#endif + + verticalHeader()->setUpdatesEnabled(false); + + for(int i = 0; i < irows; ++i) + verticalHeader()->resizeSection(i, height); + + verticalHeader()->setUpdatesEnabled(true); + + // add or remove scrollbars as required + updateScrollBars(); +} + +void kMyMoneySplitTable::setTransaction(const MyMoneyTransaction& t, const MyMoneySplit& s, const MyMoneyAccount& acc) +{ + MYMONEYTRACER(tracer); + m_transaction = t; + m_account = acc; + m_hiddenSplit = s; + setCurrentCell(0, 0); + slotUpdateData(m_transaction); +} + +const QValueList kMyMoneySplitTable::getSplits(const MyMoneyTransaction& t) const +{ + QValueList list; + QValueList::Iterator it; + + // get list of splits + list = t.splits(); + + // and ignore the one that should be hidden + + for(it = list.begin(); it != list.end(); ++it) { + if((*it).id() == m_hiddenSplit.id()) { + list.remove(it); + break; + } + } + return list; +} + +void kMyMoneySplitTable::slotUpdateData(const MyMoneyTransaction& t) +{ + MYMONEYTRACER(tracer); + unsigned long rowCount=0; + + QValueList list = getSplits(t); + updateTransactionTableSize(); + + // fill the part that is used by transactions + QValueList::Iterator it; + kMyMoneyEdit* valfield = new kMyMoneyEdit(); + for(it = list.begin(); it != list.end(); ++it) { + QString colText; + MyMoneyMoney value = (*it).value(); + if(!(*it).accountId().isEmpty()) { + try { + colText = MyMoneyFile::instance()->accountToCategory((*it).accountId()); + } catch(MyMoneyException *e) { + qDebug("Unexpected exception in kMyMoneySplitTable::slotUpdateData()"); + delete e; + } + } + QString amountTxt = value.formatMoney(m_account.fraction()); + if(value == MyMoneyMoney::autoCalc) { + amountTxt = i18n("will be calculated"); + } + + if(colText.isEmpty() && (*it).memo().isEmpty() && value.isZero()) + amountTxt = QString(); + + unsigned width = fontMetrics().width(amountTxt); + valfield->setMinimumWidth(width); + width = valfield->minimumSizeHint().width(); + + if(width > m_amountWidth) + m_amountWidth = width; + + setText(rowCount, 0, colText); + setText(rowCount, 1, (*it).memo()); + setText(rowCount, 2, amountTxt); + + rowCount++; + } + delete valfield; + + // now clean out the remainder of the table + while(rowCount < static_cast (numRows())) { + setText(rowCount, 0, ""); + setText(rowCount, 1, ""); + setText(rowCount, 2, ""); + ++rowCount; + } +} + +void kMyMoneySplitTable::updateTransactionTableSize(void) +{ + // get current size of transactions table + int rowHeight = cellGeometry(0, 0).height(); + + // add half a row to the height to avoid unnecessary toggling when + // changing the number of rows + int tableHeight = (height() + rowHeight/2); + int splitCount = m_transaction.splits().count()-1; + + if(splitCount < 0) + splitCount = 0; + + // see if we need some extra lines to fill the current size with the grid + int numExtraLines = (tableHeight / rowHeight) - splitCount; + if(numExtraLines < 2) + numExtraLines = 2; + + setNumRows(splitCount + numExtraLines); + // setMaxRows(splitCount); + m_maxRows = splitCount; +} + +void kMyMoneySplitTable::resizeEvent(QResizeEvent* /* ev */) +{ + int w = visibleWidth() - m_amountWidth; + + // resize the columns + setColumnWidth(0, w/2); + setColumnWidth(1, w/2); + setColumnWidth(2, m_amountWidth); + + updateTransactionTableSize(); +} + +void kMyMoneySplitTable::slotDuplicateSplit(void) +{ + MYMONEYTRACER(tracer); + QValueList list = getSplits(m_transaction); + if(m_currentRow < static_cast (list.count())) { + MyMoneySplit split = list[m_currentRow]; + split.clearId(); + try { + m_transaction.addSplit(split); + emit transactionChanged(m_transaction); + } catch(MyMoneyException *e) { + qDebug("Cannot duplicate split: %s", e->what().latin1()); + delete e; + } + } +} + +void kMyMoneySplitTable::slotDeleteSplit(void) +{ + MYMONEYTRACER(tracer); + QValueList list = getSplits(m_transaction); + if(m_currentRow < static_cast (list.count())) { + if(KMessageBox::warningContinueCancel (this, + i18n("You are about to delete the selected split. " + "Do you really want to continue?"), + i18n("KMyMoney"), + i18n("Continue") + ) == KMessageBox::Continue) { + try { + m_transaction.removeSplit(list[m_currentRow]); + // if we removed the last split, select the previous + if(m_currentRow && m_currentRow == static_cast(list.count())-1) + setCurrentCell(m_currentRow-1, 0); + else + setCurrentCell(m_currentRow, 0); + emit transactionChanged(m_transaction); + } catch(MyMoneyException *e) { + qDebug("Cannot remove split: %s", e->what().latin1()); + delete e; + } + } + } +} + +QWidget* kMyMoneySplitTable::slotStartEdit(void) +{ + MYMONEYTRACER(tracer); + return createEditWidgets(); +} + +void kMyMoneySplitTable::slotEndEdit(void) +{ + endEdit(false); +} + +void kMyMoneySplitTable::slotEndEditKeyboard(void) +{ + endEdit(true); +} + +void kMyMoneySplitTable::endEdit(bool keyBoardDriven) +{ + // Don't proceed, if we're not in edit mode + if(!m_editCategory) + return; + + MyMoneyFile* file = MyMoneyFile::instance(); + + MYMONEYTRACER(tracer); + MyMoneySplit s1 = m_split; + + if (m_editCategory->selectedItem().isEmpty()) { + KMessageBox::information(this, i18n("You need to assign a category to this split before it can be entered."), i18n("Enter split"), "EnterSplitWithEmptyCategory"); + m_editCategory->setFocus(); + return; + } + + bool needUpdate = false; + if(m_editCategory->selectedItem() != m_split.accountId()) { + s1.setAccountId(m_editCategory->selectedItem()); + needUpdate = true; + } + if(m_editMemo->text() != m_split.memo()) { + s1.setMemo(m_editMemo->text()); + needUpdate = true; + } + if(m_editAmount->value() != m_split.value()) { + s1.setValue(m_editAmount->value()); + needUpdate = true; + } + + if(needUpdate) { + if(!s1.value().isZero()) { + MyMoneyAccount cat = file->account(s1.accountId()); + if(cat.currencyId() != m_transaction.commodity()) { + + MyMoneySecurity fromCurrency, toCurrency; + MyMoneyMoney fromValue, toValue; + fromCurrency = file->security(m_transaction.commodity()); + toCurrency = file->security(cat.currencyId()); + + // determine the fraction required for this category + int fract = toCurrency.smallestAccountFraction(); + if(cat.accountType() == MyMoneyAccount::Cash) + fract = toCurrency.smallestCashFraction(); + + // display only positive values to the user + fromValue = s1.value().abs(); + + // if we had a price info in the beginning, we use it here + if(m_priceInfo.find(cat.currencyId()) != m_priceInfo.end()) { + toValue = (fromValue * m_priceInfo[cat.currencyId()]).convert(fract); + } + + // if the shares are still 0, we need to change that + if(toValue.isZero()) { + MyMoneyPrice price = MyMoneyFile::instance()->price(fromCurrency.id(), toCurrency.id()); + // if the price is valid calculate the shares. If it is invalid + // assume a conversion rate of 1.0 + if(price.isValid()) { + toValue = (price.rate(toCurrency.id()) * fromValue).convert(fract); + } else { + toValue = fromValue; + } + } + + // now present all that to the user + KCurrencyCalculator calc(fromCurrency, + toCurrency, + fromValue, + toValue, + m_transaction.postDate(), + fract, + this, "currencyCalculator"); + + if(calc.exec() == QDialog::Rejected) { + return; + } else { + s1.setShares((s1.value() * calc.price()).convert(fract)); + } + + } else { + s1.setShares(s1.value()); + } + } else + s1.setShares(s1.value()); + + m_split = s1; + try { + if(m_split.id().isEmpty()) { + m_transaction.addSplit(m_split); + } else { + m_transaction.modifySplit(m_split); + } + emit transactionChanged(m_transaction); + } catch(MyMoneyException *e) { + qDebug("Cannot add/modify split: %s", e->what().latin1()); + delete e; + } + } + this->setFocus(); + destroyEditWidgets(); + slotSetFocus(currentRow()+1); + + // if we still have more splits, we start editing right away + // in case we have selected 'enter moves betweeen fields' + if(keyBoardDriven + && currentRow() < static_cast (m_transaction.splits().count()-1) + && KMyMoneyGlobalSettings::enterMovesBetweenFields()) { + slotStartEdit(); + } + +} + +void kMyMoneySplitTable::slotCancelEdit(void) +{ + MYMONEYTRACER(tracer); + if(isEditMode()) { + destroyEditWidgets(); + this->setFocus(); + } +} + +bool kMyMoneySplitTable::isEditMode(void) const +{ + return m_editMode; +} + +void kMyMoneySplitTable::destroyEditWidgets(void) +{ + MYMONEYTRACER(tracer); + + disconnect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadEditWidgets())); + + clearCellWidget(m_currentRow, 0); + clearCellWidget(m_currentRow, 1); + clearCellWidget(m_currentRow, 2); + clearCellWidget(m_currentRow+1, 0); + m_editMode = false; + + QApplication::eventLoop()->processEvents(QEventLoop::ExcludeUserInput, 100); +} + +QWidget* kMyMoneySplitTable::createEditWidgets(void) +{ + MYMONEYTRACER(tracer); + + QFont cellFont = KMyMoneyGlobalSettings::listCellFont(); + m_tabOrderWidgets.clear(); + + // create the widgets + m_editAmount = new kMyMoneyEdit(0); + m_editAmount->setFont(cellFont); + m_editAmount->setResetButtonVisible(false); + + m_editCategory = new KMyMoneyCategory(); + m_editCategory->setHint(i18n("Category")); + m_editCategory->setFont(cellFont); + connect(m_editCategory, SIGNAL(createItem(const QString&, QString&)), this, SIGNAL(createCategory(const QString&, QString&))); + connect(m_editCategory, SIGNAL(objectCreation(bool)), this, SIGNAL(objectCreation(bool))); + + m_editMemo = new kMyMoneyLineEdit(0, 0, false, AlignLeft|AlignVCenter); + m_editMemo->setHint(i18n("Memo")); + m_editMemo->setFont(cellFont); + + // create buttons for the mouse users + KIconLoader *il = KGlobal::iconLoader(); + m_registerButtonFrame = new QFrame(this, "buttonFrame"); + QPalette palette = m_registerButtonFrame->palette(); + palette.setColor(QColorGroup::Background, rowBackgroundColor(m_currentRow+1) ); + m_registerButtonFrame->setPalette(palette); + + QHBoxLayout* l = new QHBoxLayout(m_registerButtonFrame); + m_registerEnterButton = new KPushButton(il->loadIcon("button_ok", KIcon::Small, KIcon::SizeSmall), QString(), m_registerButtonFrame, "EnterButton"); + + m_registerCancelButton = new KPushButton(il->loadIcon("button_cancel", KIcon::Small, KIcon::SizeSmall), QString(), m_registerButtonFrame, "CancelButton"); + + l->addWidget(m_registerEnterButton); + l->addWidget(m_registerCancelButton); + l->addStretch(2); + + connect(m_registerEnterButton, SIGNAL(clicked()), this, SLOT(slotEndEdit())); + connect(m_registerCancelButton, SIGNAL(clicked()), this, SLOT(slotCancelEdit())); + + // setup tab order + addToTabOrder(m_editCategory); + addToTabOrder(m_editMemo); + addToTabOrder(m_editAmount); + addToTabOrder(m_registerEnterButton); + addToTabOrder(m_registerCancelButton); + + if(!m_split.accountId().isEmpty()) { + m_editCategory->setSelectedItem(m_split.accountId()); + } else { + // check if the transaction is balanced or not. If not, + // assign the remainder to the amount. + MyMoneyMoney diff; + QValueList list = m_transaction.splits(); + QValueList::ConstIterator it_s; + for(it_s = list.begin(); it_s != list.end(); ++it_s) { + if(!(*it_s).accountId().isEmpty()) + diff += (*it_s).value(); + } + m_split.setValue(-diff); + } + + m_editMemo->loadText(m_split.memo()); + // don't allow automatically calculated values to be modified + if(m_split.value() == MyMoneyMoney::autoCalc) { + m_editAmount->setEnabled(false); + m_editAmount->loadText("will be calculated"); + } else + m_editAmount->setValue(m_split.value()); + + setCellWidget(m_currentRow, 0, m_editCategory); + setCellWidget(m_currentRow, 1, m_editMemo); + setCellWidget(m_currentRow, 2, m_editAmount); + setCellWidget(m_currentRow+1, 0, m_registerButtonFrame); + + // load e.g. the category widget with the account list + slotLoadEditWidgets(); + connect(MyMoneyFile::instance(), SIGNAL(dataChanged()), this, SLOT(slotLoadEditWidgets())); + + // setup the keyboard filter for all widgets + for(QWidget* w = m_tabOrderWidgets.first(); w; w = m_tabOrderWidgets.next()) { + w->installEventFilter(this); + } + + m_editCategory->setFocus(); + m_editCategory->lineEdit()->selectAll(); + m_editMode = true; + + return m_editCategory->lineEdit(); +} + +void kMyMoneySplitTable::slotLoadEditWidgets(void) +{ + // reload category widget + QString categoryId = m_editCategory->selectedItem(); + + AccountSet aSet; + aSet.addAccountGroup(MyMoneyAccount::Asset); + aSet.addAccountGroup(MyMoneyAccount::Liability); + aSet.addAccountGroup(MyMoneyAccount::Income); + aSet.addAccountGroup(MyMoneyAccount::Expense); + if(KMyMoneyGlobalSettings::expertMode()) + aSet.addAccountGroup(MyMoneyAccount::Equity); + + // remove the accounts with invalid types at this point + aSet.removeAccountType(MyMoneyAccount::CertificateDep); + aSet.removeAccountType(MyMoneyAccount::Investment); + aSet.removeAccountType(MyMoneyAccount::Stock); + aSet.removeAccountType(MyMoneyAccount::MoneyMarket); + + aSet.load(m_editCategory->selector()); + + // if an account is specified then remove it from the widget so that the user + // cannot create a transfer with from and to account being the same account + if(!m_account.id().isEmpty()) + m_editCategory->selector()->removeItem(m_account.id()); + + if(!categoryId.isEmpty()) + m_editCategory->setSelectedItem(categoryId); + +} + +void kMyMoneySplitTable::addToTabOrder(QWidget* w) +{ + if(w) { + while(w->focusProxy()) + w = w->focusProxy(); + m_tabOrderWidgets.append(w); + } +} + +bool kMyMoneySplitTable::focusNextPrevChild(bool next) +{ + MYMONEYTRACER(tracer); + bool rc = false; + + if(m_editCategory) { + QWidget *w = 0; + QWidget *currentWidget; + + m_tabOrderWidgets.find(qApp->focusWidget()); + currentWidget = m_tabOrderWidgets.current(); + w = next ? m_tabOrderWidgets.next() : m_tabOrderWidgets.prev(); + + do { + if(!w) { + w = next ? m_tabOrderWidgets.first() : m_tabOrderWidgets.last(); + } + + if(w != currentWidget + && ((w->focusPolicy() & TabFocus) == TabFocus) + && w->isVisible() && w->isEnabled()) { + w->setFocus(); + rc = true; + break; + } + w = next ? m_tabOrderWidgets.next() : m_tabOrderWidgets.prev(); + } while(w != currentWidget); + + } else + rc = QTable::focusNextPrevChild(next); + + return rc; +} + + + +#include "kmymoneysplittable.moc" -- cgit v1.2.3