• Skip to content
  • Skip to link menu
KDE 3.5 API Reference
  • KDE API Reference
  • API Reference
  • Sitemap
  • Contact Us
 

kdeui

knumvalidator.cpp

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

kdeui

Skip menu "kdeui"
  • Main Page
  • Namespace List
  • Class Hierarchy
  • Alphabetical List
  • Class List
  • File List
  • Namespace Members
  • Class Members
  • Related Pages

API Reference

Skip menu "API Reference"
  • dcop
  • DNSSD
  • interfaces
  • Kate
  • kconf_update
  • KDECore
  • KDED
  • kdefx
  • KDEsu
  • kdeui
  • KDocTools
  • KHTML
  • KImgIO
  • KInit
  • kio
  • kioslave
  • KJS
  • KNewStuff
  • KParts
  • KUtils
Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal