You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
kmymoney/kmymoney2/widgets/kmymoneyedit.cpp

560 lines
16 KiB

/***************************************************************************
kmymoneyedit.cpp
-------------------
copyright : (C) 2000 by Michael Edwardes,
2004 by Thomas Baumgart
email : mte@users.sourceforge.net
ipwizard@users.sourceforge.net
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
// ----------------------------------------------------------------------------
// QT Includes
#include <tqapplication.h>
#include <tqdesktopwidget.h>
#include <tqwidget.h>
#include <tqvbox.h>
// ----------------------------------------------------------------------------
// KDE Includes
#include <kglobal.h>
#include <klocale.h>
#include <kdebug.h>
#include <klineedit.h>
#include <kiconloader.h>
#include <kconfig.h>
// ----------------------------------------------------------------------------
// Project Includes
#include <kmymoney/kmymoneylineedit.h>
#include "kmymoneyedit.h"
#include "kmymoneycalculator.h"
#include "../mymoney/mymoneymoney.h"
kMyMoneyMoneyValidator::kMyMoneyMoneyValidator(TQObject * parent, const char * name) :
TQDoubleValidator(parent, name)
{
}
kMyMoneyMoneyValidator::kMyMoneyMoneyValidator( double bottom, double top, int decimals,
TQObject * parent, const char * name ) :
TQDoubleValidator(bottom, top, decimals, parent, name)
{
}
/*
* The code of the following function is taken from tdeui/knumvalidator.cpp
* and adjusted to always use the monetary symbols defined in the KDE control center
*/
TQValidator::State kMyMoneyMoneyValidator::validate( TQString & input, int & _p ) const
{
TQString s = input;
KLocale * l = KGlobal::locale();
// ok, we have to re-format the number to have:
// 1. decimalSymbol == '.'
// 2. negativeSign == '-'
// 3. positiveSign == <empty>
// 4. thousandsSeparator() == <empty> (we don't check that there
// are exactly three decimals between each separator):
TQString d = l->monetaryDecimalSymbol(),
n = l->negativeSign(),
p = l->positiveSign(),
t = l->monetaryThousandsSeparator();
// first, delete p's and t's:
if ( !p.isEmpty() )
for ( int idx = s.find( p ) ; idx >= 0 ; idx = s.find( p, idx ) )
s.remove( idx, p.length() );
if ( !t.isEmpty() )
for ( int idx = s.find( t ) ; idx >= 0 ; idx = s.find( t, idx ) )
s.remove( idx, t.length() );
// then, replace the d's and n's
if ( ( !n.isEmpty() && n.find('.') != -1 ) ||
( !d.isEmpty() && d.find('-') != -1 ) ) {
// make sure we don't replace something twice:
kdWarning() << "KDoubleValidator: decimal symbol contains '-' or "
"negative sign contains '.' -> improve algorithm" << endl;
return Invalid;
}
if ( !d.isEmpty() && d != "." )
for ( int idx = s.find( d ) ; idx >= 0 ; idx = s.find( d, idx + 1 ) )
s.replace( idx, d.length(), ".");
if ( !n.isEmpty() && n != "-" )
for ( int idx = s.find( n ) ; idx >= 0 ; idx = s.find( n, idx + 1 ) )
s.replace( idx, n.length(), "-" );
// Take care of monetary parens around the value if selected via
// the locale settings.
// If the lead-in or lead-out paren is present, remove it
// before passing the string to the TQDoubleValidator
if(l->negativeMonetarySignPosition() == KLocale::ParensAround
|| l->positiveMonetarySignPosition() == KLocale::ParensAround) {
TQRegExp regExp("^(\\()?([\\d-\\.]*)(\\))?$");
if(s.find(regExp) != -1) {
s = regExp.cap(2);
}
}
// check for non numeric values (TQDoubleValidator allows an 'e', we don't)
TQRegExp nonNumeric("[^\\d-\\.]+");
if(s.find(nonNumeric) != -1)
return Invalid;
// check for minus sign trailing the number
TQRegExp trailingMinus("^([^-]*)\\w*-$");
if(s.find(trailingMinus) != -1) {
s = TQString("-%1").tqarg(trailingMinus.cap(1));
}
// check for the maximum allowed number of decimal places
int decPos = s.find('.');
if(decPos != -1) {
if(decimals() == 0)
return Invalid;
if(((int)(s.length()) - decPos) > decimals())
return Invalid;
}
// If we have just a single minus sign, we are done
if(s == TQString("-"))
return Acceptable;
TQValidator::State rc = TQDoubleValidator::validate( s, _p );
if(rc == Acceptable) {
// If the numeric value is acceptable, we check if the parens
// are ok. If only the lead-in is present, the return value
// is intermediate, if only the lead-out is present then it
// definitely is invalid. Nevertheless, we check for parens
// only, if the locale settings have it enabled.
if(l->negativeMonetarySignPosition() == KLocale::ParensAround
|| l->positiveMonetarySignPosition() == KLocale::ParensAround) {
int tmp = input.contains('(') - input.contains(')');
if(tmp > 0)
rc = Intermediate;
else if(tmp < 0)
rc = Invalid;
}
}
return rc;
}
kMyMoneyEdit::kMyMoneyEdit(TQWidget *parent, const char *name, const int prec)
: TQHBox(parent, name)
{
m_prec = prec;
if(prec < -1 || prec > 20)
m_prec = KGlobal::locale()->fracDigits();
init();
}
kMyMoneyEdit::kMyMoneyEdit(const MyMoneySecurity& sec, TQWidget *parent, const char *name)
: TQHBox(parent, name)
{
m_prec = MyMoneyMoney::denomToPrec(sec.smallestAccountFraction());
init();
}
// converted image from trinity.5.1/share/apps/kdevdesignerpart/pics/designer_resetproperty.png
static const uchar resetButtonImage[] = {
0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A,
0x00,0x00,0x00,0x0D,0x49,0x48,0x44,0x52,
0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x06,
0x08,0x06,0x00,0x00,0x00,0x0F,0x0E,0x84,
0x76,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,0x07,0x74,0x49,0x4D,0x45,
0x07,0xD6,0x06,0x10,0x09,0x36,0x0C,0x58,
0x91,0x11,0x7C,0x00,0x00,0x00,0x64,0x49,
0x44,0x41,0x54,0x78,0xDA,0x65,0xC9,0xA1,
0x0D,0x02,0x41,0x18,0x84,0xD1,0xF7,0x5F,
0x13,0x04,0x9A,0x39,0x43,0x68,0x81,0x02,
0x10,0xB8,0x13,0x74,0x80,0xC1,0x21,0x76,
0x1D,0xDD,0xD0,0x01,0x65,0x10,0x34,0x9A,
0x0C,0x66,0x83,0x61,0x92,0x2F,0x23,0x5E,
0x25,0x01,0xBD,0x6A,0xC6,0x1D,0x9B,0x25,
0x79,0xC2,0x34,0xE0,0x30,0x00,0x56,0xBD,
0x6A,0x0D,0xD5,0x38,0xE1,0xEA,0x7F,0xE7,
0x4A,0xA2,0x57,0x1D,0x71,0xC1,0x07,0xBB,
0x81,0x8F,0x09,0x96,0xE4,0x86,0x3D,0xDE,
0x78,0x8D,0x48,0xF2,0xAB,0xB1,0x1D,0x9F,
0xC6,0xFC,0x05,0x46,0x68,0x28,0x6B,0x58,
0xEE,0x72,0x0A,0x00,0x00,0x00,0x00,0x49,
0x45,0x4E,0x44,0xAE,0x42,0x60,0x82
};
void kMyMoneyEdit::init(void)
{
allowEmpty = false;
m_edit = new kMyMoneyLineEdit(this, 0, true);
m_edit->installEventFilter(this);
setFocusProxy(m_edit);
// Yes, just a simple double validator !
kMyMoneyMoneyValidator *validator = new kMyMoneyMoneyValidator(TQT_TQOBJECT(this));
m_edit->setValidator(validator);
m_edit->tqsetAlignment(AlignRight | AlignVCenter);
m_calculatorFrame = new TQVBox(this, 0, WType_Popup);
m_calculatorFrame->setFrameStyle(TQFrame::PopupPanel | TQFrame::Raised);
m_calculatorFrame->setLineWidth(3);
m_calculator = new kMyMoneyCalculator(m_calculatorFrame);
m_calculatorFrame->setFixedSize(m_calculator->width()+3, m_calculator->height()+3);
m_calculatorFrame->hide();
m_calcButton = new KPushButton(TQIconSet(TQPixmap(KGlobal::iconLoader()->iconPath("kcalc", -KIcon::SizeSmall))), TQString(""), this);
m_calcButton->setFixedWidth( m_calcButton->tqsizeHint().width() );
m_calcButton->setFixedHeight(m_edit->tqsizeHint().height());
m_calcButton->setFocusProxy(m_edit);
TQPixmap pixmap;
pixmap.loadFromData(resetButtonImage, sizeof(resetButtonImage), "PNG", 0);
m_resetButton = new KPushButton(TQIconSet(pixmap), TQString(""), this);
m_resetButton->setFixedWidth( m_resetButton->tqsizeHint().width() );
m_resetButton->setFixedHeight(m_edit->tqsizeHint().height());
m_resetButton->setEnabled(false);
m_resetButton->setFocusProxy(m_edit);
KConfig *kconfig = KGlobal::config();
kconfig->setGroup("General Options");
if(kconfig->readBoolEntry("DontShowCalculatorButton", false) == true)
setCalculatorButtonVisible(false);
setSpacing(0);
connect(m_edit, TQT_SIGNAL(textChanged(const TQString&)), this, TQT_SLOT(theTextChanged(const TQString&)));
connect(m_calculator, TQT_SIGNAL(signalResultAvailable()), this, TQT_SLOT(slotCalculatorResult()));
connect(m_calcButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotCalculatorOpen()));
connect(m_resetButton, TQT_SIGNAL(clicked()), this, TQT_SLOT(resetText()));
}
void kMyMoneyEdit::setValidator(const TQValidator* v)
{
m_edit->setValidator(v);
}
kMyMoneyEdit::~kMyMoneyEdit()
{
delete m_calculatorFrame;
}
KLineEdit* kMyMoneyEdit::lineedit(void) const
{
return m_edit;
}
void kMyMoneyEdit::setPrecision(const int prec)
{
if(prec >= -1 && prec <= 20) {
if(prec != m_prec) {
m_prec = prec;
// update current display
setValue(value());
}
}
}
bool kMyMoneyEdit::isValid(void) const
{
return !(m_edit->text().isEmpty());
}
MyMoneyMoney kMyMoneyEdit::value(void) const
{
TQString txt = m_edit->text();
ensureFractionalPart(txt);
MyMoneyMoney money(txt);
if(m_prec != -1)
money = money.convert(MyMoneyMoney::precToDenom(m_prec));
return money;
}
void kMyMoneyEdit::setValue(const MyMoneyMoney& value)
{
// load the value into the widget but don't use thousandsSeparators
TQString txt = value.formatMoney("", m_prec, false);
loadText(txt);
}
void kMyMoneyEdit::loadText(const TQString& txt)
{
m_edit->setText(txt);
if(isEnabled() && !txt.isEmpty())
ensureFractionalPart();
m_text = m_edit->text();
m_resetButton->setEnabled(false);
}
void kMyMoneyEdit::clearText(void)
{
m_text = TQString();
m_edit->setText(m_text);
}
void kMyMoneyEdit::resetText(void)
{
m_edit->setText(m_text);
m_resetButton->setEnabled(false);
}
void kMyMoneyEdit::theTextChanged(const TQString & theText)
{
KLocale * l = KGlobal::locale();
TQString d = l->monetaryDecimalSymbol();
TQString l_text = theText;
TQString nsign, psign;
if(l->negativeMonetarySignPosition() == KLocale::ParensAround
|| l->positiveMonetarySignPosition() == KLocale::ParensAround) {
nsign = psign = "(";
} else {
nsign = l->negativeSign();
psign = l->positiveSign();
}
int i = 0;
if(isEnabled()) {
TQValidator::State state = m_edit->validator()->validate( l_text, i);
if(state == TQValidator::Intermediate) {
if(l_text.length() == 1) {
if(l_text != d && l_text != nsign && l_text != psign && l_text != "-")
state = TQValidator::Invalid;
}
}
if (state==TQValidator::Invalid)
m_edit->setText(previousText);
else {
previousText = l_text;
emit textChanged(m_edit->text());
m_resetButton->setEnabled(true);
}
}
}
void kMyMoneyEdit::ensureFractionalPart(void)
{
TQString s(m_edit->text());
ensureFractionalPart(s);
m_edit->setText(s);
}
void kMyMoneyEdit::ensureFractionalPart(TQString& s) const
{
KLocale* locale = KGlobal::locale();
TQString decimalSymbol = locale->monetaryDecimalSymbol();
if(decimalSymbol.isEmpty())
decimalSymbol = ".";
// If text contains no 'monetaryDecimalSymbol' then add it
// followed by the required number of 0s
if (!s.isEmpty()) {
if(m_prec > 0) {
if (!s.contains(decimalSymbol)) {
s += decimalSymbol;
for (int i=0; i < m_prec; i++)
s += "0";
}
} else if(m_prec == 0) {
while(s.contains(decimalSymbol)) {
int pos = s.findRev(decimalSymbol);
if(pos != -1) {
s.truncate(pos);
}
}
} else if(s.contains(decimalSymbol)) { // m_prec == -1 && fraction
// no trailing zeroes
while(s.endsWith("0")) {
s.truncate(s.length()-1);
}
// no trailing decimalSymbol
if(s.endsWith(decimalSymbol))
s.truncate(s.length()-1);
}
}
}
bool kMyMoneyEdit::eventFilter(TQObject * /* o */ , TQEvent *e )
{
bool rc = false;
// we want to catch some keys that are usually handled by
// the base class (e.g. '+', '-', etc.)
if(e->type() == TQEvent::KeyPress) {
TQKeyEvent *k = TQT_TQKEYEVENT (e);
rc = true;
switch(k->key()) {
case TQt::Key_Plus:
case TQt::Key_Minus:
if(m_edit->hasSelectedText()) {
m_edit->cut();
}
if(m_edit->text().length() == 0) {
rc = false;
break;
}
// in case of '-' we do not enter the calculator when
// the current position is the beginning and there is
// no '-' sign at the first position.
if(k->key() == TQt::Key_Minus) {
if(m_edit->cursorPosition() == 0 && m_edit->text()[0] != '-') {
rc = false;
break;
}
}
// otherwise, tricky fall through here!
case TQt::Key_Slash:
case TQt::Key_Asterisk:
case TQt::Key_Percent:
if(m_edit->hasSelectedText()) {
// remove the selected text
m_edit->cut();
}
calculatorOpen(k);
break;
default:
rc = false;
break;
}
} else if(e->type() == TQEvent::FocusOut) {
if(!m_edit->text().isEmpty() || !allowEmpty)
ensureFractionalPart();
if(MyMoneyMoney(m_edit->text()) != MyMoneyMoney(m_text)
&& !m_calculator->isVisible()) {
emit valueChanged(m_edit->text());
}
m_text = m_edit->text();
}
return rc;
}
void kMyMoneyEdit::slotCalculatorOpen(void)
{
calculatorOpen(0);
}
void kMyMoneyEdit::calculatorOpen(TQKeyEvent* k)
{
m_calculator->setInitialValues(m_edit->text(), k);
int h = m_calculatorFrame->height();
int w = m_calculatorFrame->width();
// usually, the calculator widget is shown underneath the MoneyEdit widget
// if it does not fit on the screen, we show it above this widget
TQPoint p = mapToGlobal(TQPoint(0,0));
if(p.y() + height() + h > TQApplication::desktop()->height())
p.setY(p.y() - h);
else
p.setY(p.y() + height());
// usually, it is shown left aligned. If it does not fit, we align it
// to the right edge of the widget
if(p.x() + w > TQApplication::desktop()->width())
p.setX(p.x() + width() - w);
TQRect r = m_calculator->tqgeometry();
r.moveTopLeft(p);
m_calculatorFrame->setGeometry(r);
m_calculatorFrame->show();
m_calculator->setFocus();
}
void kMyMoneyEdit::slotCalculatorResult(void)
{
TQString result;
if(m_calculator != 0) {
m_calculatorFrame->hide();
m_edit->setText(m_calculator->result());
ensureFractionalPart();
emit valueChanged(m_edit->text());
m_text = m_edit->text();
}
}
TQWidget* kMyMoneyEdit::tqfocusWidget(void) const
{
TQWidget* w = m_edit;
while(w->focusProxy())
w = TQT_TQWIDGET(w->focusProxy());
return w;
}
void kMyMoneyEdit::setCalculatorButtonVisible(const bool show)
{
m_calcButton->setShown(show);
}
void kMyMoneyEdit::setResetButtonVisible(const bool show)
{
m_resetButton->setShown(show);
}
void kMyMoneyEdit::setAllowEmpty(bool allowed)
{
allowEmpty = allowed;
}
bool kMyMoneyEdit::isCalculatorButtonVisible(void) const
{
return m_calcButton->isVisible();
}
bool kMyMoneyEdit::isResetButtonVisible(void) const
{
return m_resetButton->isVisible();
}
bool kMyMoneyEdit::isEmptyAllowed(void) const
{
return allowEmpty;
}
void kMyMoneyEdit::setHint(const TQString& hint) const
{
if(m_edit)
m_edit->setHint(hint);
}
bool kMyMoneyEdit::isReadOnly(void) const
{
if(m_edit)
return m_edit->isReadOnly();
return false;
}
void kMyMoneyEdit::setReadOnly(bool readOnly)
{
// we use the TQLineEdit::setReadOnly() method directly to avoid
// changing the background between readonly and read/write mode
// as it is done by the KLineEdit code.
if(m_edit)
m_edit->TQLineEdit::setReadOnly(readOnly);
}
#include "kmymoneyedit.moc"