kspread

valueconverter.cc

00001 /* This file is part of the KDE project
00002    Copyright 2004 Tomas Mecir <mecirt@gmail.com>
00003 
00004    This library is free software; you can redistribute it and/or
00005    modify it under the terms of the GNU Library General Public
00006    License as published by the Free Software Foundation; either
00007    version 2 of the License, or (at your option) any later version.
00008 
00009    This library is distributed in the hope that it will be useful,
00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012    Library General Public License for more details.
00013 
00014    You should have received a copy of the GNU Library General Public License
00015    along with this library; see the file COPYING.LIB.  If not, write to
00016    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
00017  * Boston, MA 02110-1301, USA.
00018 */
00019 
00020 #include "valueconverter.h"
00021 
00022 #include "kspread_locale.h"
00023 #include "valueparser.h"
00024 
00025 using namespace KSpread;
00026 
00027 ValueConverter::ValueConverter (ValueParser* p) : parser( p )
00028 {
00029 }
00030 
00031 KLocale* ValueConverter::locale()
00032 {
00033   return parser->locale();
00034 }
00035 
00036 Value ValueConverter::asBoolean (const Value &value) const
00037 {
00038   Value val;
00039   bool ok;  
00040   switch (value.type()) {
00041     case Value::Empty:
00042       val.setValue (false);
00043     break;
00044     case Value::Boolean:
00045       val = value;
00046     break;
00047     case Value::Integer:
00048       val.setValue (value.asInteger() ? true : false); 
00049     break;
00050     case Value::Float:
00051       val.setValue ((value.asFloat() == 0.0) ? false : true);
00052     break;
00053     case Value::String:
00054       val = parser->tryParseBool (value.asString(), &ok);
00055       if (!ok)
00056         val.setValue (false);
00057     break;
00058     case Value::Array:
00059       val = asBoolean (value.element (0, 0));
00060     break;
00061     case Value::CellRange:
00062       /* NOTHING */
00063     break;
00064     case Value::Error:
00065       val.setValue (false);
00066     break;
00067   };
00068   
00069   return val;
00070 }
00071 
00072 Value ValueConverter::asInteger (const Value &value) const
00073 {
00074   Value val;
00075   bool ok;
00076   
00077   switch (value.type()) {
00078     case Value::Empty:
00079       val.setValue (0);
00080     break;
00081     case Value::Boolean:
00082       val.setValue (value.asBoolean() ? 1 : 0);
00083     break;
00084     case Value::Integer:
00085       val = value;
00086     break;
00087     case Value::Float:
00088       val.setValue (value.asInteger());
00089     break;
00090     case Value::String:
00091       val.setValue ((int) parser->tryParseNumber
00092           (value.asString(), &ok).asFloat());
00093       if (!ok)
00094         val.setValue (0);
00095     break;
00096     case Value::Array:
00097       val = asInteger (value.element (0, 0));
00098     break;
00099     case Value::CellRange:
00100       /* NOTHING */
00101     break;
00102     case Value::Error:
00103       val.setValue (0);
00104     break;
00105   };
00106   
00107   return val;
00108 }
00109 
00110 Value ValueConverter::asFloat (const Value &value) const
00111 {
00112   Value val;
00113   bool ok;
00114   
00115   switch (value.type()) {
00116     case Value::Empty:
00117       val.setValue (0.0);
00118     break;
00119     case Value::Boolean:
00120       val.setValue (value.asBoolean() ? 1.0 : 0.0);
00121     break;
00122     case Value::Integer:
00123       val.setValue (value.asFloat ());
00124     break;
00125     case Value::Float:
00126       val = value;
00127     break;
00128     case Value::String:
00129       val = parser->tryParseNumber (value.asString(), &ok);
00130       if (!ok)
00131         val.setValue (0.0);
00132     break;
00133     case Value::Array:
00134       val = asFloat (value.element (0, 0));
00135     break;
00136     case Value::CellRange:
00137       /* NOTHING */
00138     break;
00139     case Value::Error:
00140       val.setValue (0.0);
00141     break;
00142   };
00143   
00144   return val;
00145 }
00146 
00147 Value ValueConverter::asNumeric (const Value &value) const
00148 {
00149   // as of now, we simply go to float; later on, further datatypes
00150   // may be possible as a result of this
00151   return asFloat (value);
00152 }
00153 
00154 Value ValueConverter::asString (const Value &value) const
00155 {
00156   // This is a simpler version of ValueFormatter... We cannot use that one,
00157   // as we sometimes want to generate the string differently ...
00158 
00159   Value val;
00160   QString s;
00161   Value::Format fmt;
00162   QChar decimal_point;
00163   int pos;
00164   switch (value.type()) {
00165     case Value::Empty:
00166       val = QString::null;
00167     break;
00168     case Value::Boolean:
00169       val.setValue (value.asBoolean() ? parser->locale()->translate ("True") :
00170           parser->locale()->translate ("False"));
00171     break;
00172     case Value::Integer:
00173     {
00174       fmt = value.format();
00175       if (fmt == Value::fmt_Percent)
00176         val = QString::number (value.asInteger() * 100) + " %";
00177       else if (fmt == Value::fmt_DateTime)
00178         val = parser->locale()->formatDateTime (value.asDateTime());
00179       else if (fmt == Value::fmt_Date)
00180         val = parser->locale()->formatDate (value.asDate());
00181       else if (fmt == Value::fmt_Time)
00182         val = parser->locale()->formatTime (value.asTime());
00183       else
00184         val = QString::number (value.asInteger());
00185     }
00186     break;
00187     case Value::Float:
00188       fmt = value.format();
00189       if (fmt == Value::fmt_DateTime)
00190         val = parser->locale()->formatDateTime (value.asDateTime());
00191       else if (fmt == Value::fmt_Date)
00192         val = parser->locale()->formatDate (value.asDate(), true);
00193       else if (fmt == Value::fmt_Time)
00194         val = parser->locale()->formatTime (value.asTime());
00195       else
00196       {
00197         //convert the number, change decimal point from English to local
00198         s = QString::number (value.asFloat(), 'g', 10);
00199         decimal_point = parser->locale()->decimalSymbol()[0];
00200         if (decimal_point && ((pos = s.find ('.')) != -1))
00201           s = s.replace (pos, 1, decimal_point);
00202         if (fmt == Value::fmt_Percent)
00203           s += " %";
00204         val.setValue (s);
00205       }
00206     break;
00207     case Value::String:
00208       val = value;
00209     break;
00210     case Value::Array:
00211       val = asString (value.element (0, 0));
00212     break;
00213     case Value::CellRange:
00214       /* NOTHING */
00215     break;
00216     case Value::Error:
00217       val.setValue (value.errorMessage ());
00218     break;
00219   };
00220   
00221   return val;
00222 }
00223 
00224 Value ValueConverter::asDateTime (const Value &value) const
00225 {
00226   Value val;
00227   bool ok;
00228   
00229   switch (value.type()) {
00230     case Value::Empty:
00231       val.setValue (QDateTime::currentDateTime());
00232     break;
00233     case Value::Boolean:
00234       //ignore the bool value... any better idea? ;)
00235       val.setValue (QDateTime::currentDateTime());
00236     break;
00237     case Value::Integer:
00238       val.setValue (value.asFloat());
00239       val.setFormat (Value::fmt_DateTime);
00240     break;
00241     case Value::Float:
00242       val.setValue (value.asFloat());
00243       val.setFormat (Value::fmt_DateTime);
00244     break;
00245     case Value::String:
00246       //no DateTime parser, so we parse as Date, hoping for the best ...
00247       val = parser->tryParseDate (value.asString(), &ok);
00248       if (!ok)
00249         val = Value::errorVALUE();
00250       val.setFormat (Value::fmt_DateTime);
00251     break;
00252     case Value::Array:
00253       val = asDateTime (value.element (0, 0));
00254     break;
00255     case Value::CellRange:
00256       /* NOTHING */
00257     break;
00258     case Value::Error:
00259     break;
00260   };
00261   
00262   return val;
00263 }
00264 
00265 Value ValueConverter::asDate (const Value &value) const
00266 {
00267   Value val;
00268   bool ok;
00269   
00270   switch (value.type()) {
00271     case Value::Empty:
00272       val.setValue (QDate::currentDate());
00273     break;
00274     case Value::Boolean:
00275       //ignore the bool value... any better idea? ;)
00276       val.setValue (QDate::currentDate());
00277     break;
00278     case Value::Integer:
00279       val.setValue (value.asFloat());
00280       val.setFormat (Value::fmt_Date);
00281     break;
00282     case Value::Float:
00283       val.setValue (value.asFloat());
00284       val.setFormat (Value::fmt_Date);
00285     break;
00286     case Value::String:
00287       val = parser->tryParseDate (value.asString(), &ok);
00288       if (!ok)
00289         val = Value::errorVALUE();
00290     break;
00291     case Value::Array:
00292       val = asDate (value.element (0, 0));
00293     break;
00294     case Value::CellRange:
00295       /* NOTHING */
00296     break;
00297     case Value::Error:
00298     break;
00299   };
00300   
00301   return val;
00302 }
00303 
00304 Value ValueConverter::asTime (const Value &value) const
00305 {
00306   Value val;
00307   bool ok;
00308   
00309   switch (value.type()) {
00310     case Value::Empty:
00311       val.setValue (QTime::currentTime());
00312     break;
00313     case Value::Boolean:
00314       //ignore the bool value... any better idea? ;)
00315       val.setValue (QTime::currentTime());
00316     break;
00317     case Value::Integer:
00318       val.setValue (value.asInteger());
00319       val.setFormat (Value::fmt_Time);
00320     break;
00321     case Value::Float:
00322       val.setValue (value.asFloat());
00323       val.setFormat (Value::fmt_Time);
00324     break;
00325     case Value::String:
00326       val = parser->tryParseTime (value.asString(), &ok);
00327       if (!ok)
00328         val = Value::errorVALUE();
00329     break;
00330     case Value::Array:
00331       val = asTime (value.element (0, 0));
00332     break;
00333     case Value::CellRange:
00334       /* NOTHING */
00335     break;
00336     case Value::Error:
00337     break;
00338   };
00339   
00340   return val;
00341 }
00342 
KDE Home | KDE Accessibility Home | Description of Access Keys