kdeui Library API Documentation

knumvalidator.cpp

00001 /**********************************************************************
00002 **
00003 ** $Id: knumvalidator.cpp,v 1.12 2002/12/29 15:45:34 buis Exp $
00004 **
00005 ** KIntValidator, KFloatValidator:
00006 **   Copyright (C) 1999 Glen Parker <glenebob@nwlink.com>
00007 ** KDoubleValidator:
00008 **   Copyright (c) 2002 Marc Mutz <mutz@kde.org>
00009 **
00010 ** This library is free software; you can redistribute it and/or
00011 ** modify it under the terms of the GNU Library General Public
00012 ** License as published by the Free Software Foundation; either
00013 ** version 2 of the License, or (at your option) any later version.
00014 **
00015 ** This library is distributed in the hope that it will be useful,
00016 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018 ** Library General Public License for more details.
00019 **
00020 ** You should have received a copy of the GNU Library General Public
00021 ** License along with this library; if not, write to the Free
00022 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00023 **
00024 *****************************************************************************/
00025 
00026 #include <qwidget.h>
00027 #include <qstring.h>
00028 
00029 #include "knumvalidator.h"
00030 #include <klocale.h>
00031 #include <kglobal.h>
00032 #include <kdebug.h>
00033 
00035 //  Implementation of KIntValidator
00036 //
00037 
00038 KIntValidator::KIntValidator ( QWidget * parent, int base, const char * name )
00039   : QValidator(parent, name)
00040 {
00041   _base = base;
00042   if (_base < 2) _base = 2;
00043   if (_base > 36) _base = 36;
00044 
00045   _min = _max = 0;
00046 }
00047 
00048 KIntValidator::KIntValidator ( int bottom, int top, QWidget * parent, int base, const char * name )
00049   : QValidator(parent, name)
00050 {
00051   _base = base;
00052   if (_base > 36) _base = 36;
00053 
00054   _min = bottom;
00055   _max = top;
00056 }
00057 
00058 KIntValidator::~KIntValidator ()
00059 {}
00060 
00061 QValidator::State KIntValidator::validate ( QString &str, int & ) const
00062 {
00063   bool ok;
00064   int  val = 0;
00065   QString newStr;
00066 
00067   newStr = str.stripWhiteSpace();
00068   if (_base > 10)
00069     newStr = newStr.upper();
00070 
00071   if (newStr == QString::fromLatin1("-")) // a special case
00072     if ((_min || _max) && _min >= 0)
00073       ok = false;
00074     else
00075       return QValidator::Acceptable;
00076   else if (newStr.length())
00077     val = newStr.toInt(&ok, _base);
00078   else {
00079     val = 0;
00080     ok = true;
00081   }
00082 
00083   if (! ok)
00084     return QValidator::Invalid;
00085 
00086   if ((! _min && ! _max) || (val >= _min && val <= _max))
00087     return QValidator::Acceptable;
00088 
00089   if (_max && _min >= 0 && val < 0)
00090     return QValidator::Invalid;
00091 
00092   return QValidator::Valid;
00093 }
00094 
00095 void KIntValidator::fixup ( QString &str ) const
00096 {
00097   int                dummy;
00098   int                val;
00099   QValidator::State  state;
00100 
00101   state = validate(str, dummy);
00102 
00103   if (state == QValidator::Invalid || state == QValidator::Acceptable)
00104     return;
00105 
00106   if (! _min && ! _max)
00107     return;
00108 
00109   val = str.toInt(0, _base);
00110 
00111   if (val < _min) val = _min;
00112   if (val > _max) val = _max;
00113 
00114   str.setNum(val, _base);
00115 }
00116 
00117 void KIntValidator::setRange ( int bottom, int top )
00118 {
00119   _min = bottom;
00120   _max = top;
00121 
00122     if (_max < _min)
00123         _max = _min;
00124 }
00125 
00126 void KIntValidator::setBase ( int base )
00127 {
00128   _base = base;
00129   if (_base < 2) _base = 2;
00130 }
00131 
00132 int KIntValidator::bottom () const
00133 {
00134   return _min;
00135 }
00136 
00137 int KIntValidator::top () const
00138 {
00139   return _max;
00140 }
00141 
00142 int KIntValidator::base () const
00143 {
00144   return _base;
00145 }
00146 
00147 
00149 //  Implementation of KFloatValidator
00150 //
00151 
00152 class KFloatValidatorPrivate
00153 {
00154 public:
00155     KFloatValidatorPrivate()
00156     {
00157     }
00158     ~KFloatValidatorPrivate()
00159     {
00160     }
00161     bool acceptLocalizedNumbers;
00162 };
00163 
00164 
00165 KFloatValidator::KFloatValidator ( QWidget * parent, const char * name )
00166   : QValidator(parent, name)
00167 {
00168     d = new KFloatValidatorPrivate;
00169     d->acceptLocalizedNumbers=false;
00170     _min = _max = 0;
00171 }
00172 
00173 KFloatValidator::KFloatValidator ( double bottom, double top, QWidget * parent, const char * name )
00174   : QValidator(parent, name)
00175 {
00176     d = new KFloatValidatorPrivate;
00177     d->acceptLocalizedNumbers=false;
00178     _min = bottom;
00179     _max = top;
00180 }
00181 
00182 KFloatValidator::KFloatValidator ( double bottom, double top, bool localeAware, QWidget * parent, const char * name )
00183   : QValidator(parent, name)
00184 {
00185     d = new KFloatValidatorPrivate;
00186     d->acceptLocalizedNumbers = localeAware;
00187     _min = bottom;
00188     _max = top;
00189 }
00190 
00191 KFloatValidator::~KFloatValidator ()
00192 {
00193      delete d;
00194 }
00195 
00196 void KFloatValidator::setAcceptLocalizedNumbers(bool _b)
00197 {
00198     d->acceptLocalizedNumbers=_b;
00199 }
00200 
00201 bool KFloatValidator::acceptLocalizedNumbers() const
00202 {
00203     return d->acceptLocalizedNumbers;
00204 }
00205 
00206 QValidator::State KFloatValidator::validate ( QString &str, int & ) const
00207 {
00208   bool    ok;
00209   double  val = 0;
00210   QString newStr;
00211   newStr = str.stripWhiteSpace();
00212 
00213   if (newStr == QString::fromLatin1("-")) // a special case
00214     if ((_min || _max) && _min >= 0)
00215       ok = false;
00216     else
00217       return QValidator::Acceptable;
00218   else if (newStr == QString::fromLatin1(".") || (d->acceptLocalizedNumbers && newStr==KGlobal::locale()->decimalSymbol())) // another special case
00219     return QValidator::Acceptable;
00220   else if (newStr.length())
00221   {
00222     val = newStr.toDouble(&ok);
00223     if(!ok && d->acceptLocalizedNumbers)
00224        val= KGlobal::locale()->readNumber(newStr,&ok);
00225   }
00226   else {
00227     val = 0;
00228     ok = true;
00229   }
00230 
00231   if (! ok)
00232     return QValidator::Invalid;
00233 
00234   if (( !_min && !_max) || (val >= _min && val <= _max))
00235     return QValidator::Acceptable;
00236 
00237   if (_max && _min >= 0 && val < 0)
00238     return QValidator::Invalid;
00239 
00240   if ( (_min || _max) && (val < _min || val > _max))
00241     return QValidator::Invalid;
00242 
00243   return QValidator::Valid;
00244 }
00245 
00246 void KFloatValidator::fixup ( QString &str ) const
00247 {
00248   int                dummy;
00249   double             val;
00250   QValidator::State  state;
00251 
00252   state = validate(str, dummy);
00253 
00254   if (state == QValidator::Invalid || state == QValidator::Acceptable)
00255     return;
00256 
00257   if (! _min && ! _max)
00258     return;
00259 
00260   val = str.toDouble();
00261 
00262   if (val < _min) val = _min;
00263   if (val > _max) val = _max;
00264 
00265   str.setNum(val);
00266 }
00267 
00268 void KFloatValidator::setRange ( double bottom, double top )
00269 {
00270   _min = bottom;
00271   _max = top;
00272 
00273     if (_max < _min)
00274         _max = _min;
00275 }
00276 
00277 double KFloatValidator::bottom () const
00278 {
00279   return _min;
00280 }
00281 
00282 double KFloatValidator::top () const
00283 {
00284   return _max;
00285 }
00286 
00287 
00288 
00289 
00291 //  Implementation of KDoubleValidator
00292 //
00293 
00294 class KDoubleValidator::Private {
00295 public:
00296   Private( bool accept=true ) : acceptLocalizedNumbers( accept ) {}
00297 
00298   bool acceptLocalizedNumbers;
00299 };
00300 
00301 KDoubleValidator::KDoubleValidator( QObject * parent, const char * name )
00302   : QDoubleValidator( parent, name ), d( 0 )
00303 {
00304   d = new Private();
00305 }
00306 
00307 KDoubleValidator::KDoubleValidator( double bottom, double top, int decimals,
00308                     QObject * parent, const char * name )
00309   : QDoubleValidator( bottom, top, decimals, parent, name ), d( 0 )
00310 {
00311   d = new Private();
00312 }
00313 
00314 KDoubleValidator::~KDoubleValidator()
00315 {
00316     delete d;
00317 }
00318 
00319 bool KDoubleValidator::acceptLocalizedNumbers() const {
00320   return d->acceptLocalizedNumbers;
00321 }
00322 
00323 void KDoubleValidator::setAcceptLocalizedNumbers( bool accept ) {
00324   d->acceptLocalizedNumbers = accept;
00325 }
00326 
00327 QValidator::State KDoubleValidator::validate( QString & input, int & p ) const {
00328   QString s = input;
00329   if ( acceptLocalizedNumbers() ) {
00330     KLocale * l = KGlobal::locale();
00331     // ok, we have to re-format the number to have:
00332     // 1. decimalSymbol == '.'
00333     // 2. negativeSign  == '-'
00334     // 3. positiveSign  == <empty>
00335     // 4. thousandsSeparator() == <empty> (we don't check that there
00336     //    are exactly three decimals between each separator):
00337     QString d = l->decimalSymbol(),
00338             n = l->negativeSign(),
00339             p = l->positiveSign(),
00340             t = l->thousandsSeparator();
00341     // first, delete p's and t's:
00342     if ( !p.isEmpty() )
00343       for ( int idx = s.find( p ) ; idx >= 0 ; idx = s.find( p, idx ) )
00344     s.remove( idx, p.length() );
00345 
00346 
00347     if ( !t.isEmpty() )
00348       for ( int idx = s.find( t ) ; idx >= 0 ; idx = s.find( t, idx ) )
00349     s.remove( idx, t.length() );
00350 
00351     // then, replace the d's and n's
00352     if ( ( !n.isEmpty() && n.find('.') != -1 ) ||
00353      ( !d.isEmpty() && d.find('-') != -1 ) ) {
00354       // make sure we don't replace something twice:
00355       kdWarning() << "KDoubleValidator: decimal symbol contains '-' or "
00356              "negative sign contains '.' -> improve algorithm" << endl;
00357       return Invalid;
00358     }
00359 
00360     if ( !d.isEmpty() && d != "." )
00361       for ( int idx = s.find( d ) ; idx >= 0 ; idx = s.find( d, idx + 1 ) )
00362     s.replace( idx, d.length(), ".");
00363 
00364     if ( !n.isEmpty() && n != "-" )
00365       for ( int idx = s.find( n ) ; idx >= 0 ; idx = s.find( n, idx + 1 ) )
00366     s.replace( idx, n.length(), "-" );
00367   }
00368 
00369   return base::validate( s, p );
00370 }
00371 
00372 #include "knumvalidator.moc"
KDE Logo
This file is part of the documentation for kdeui Library Version 3.2.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Thu Mar 4 22:43:53 2004 by doxygen 1.3.6-20040222 written by Dimitri van Heesch, © 1997-2003