kspread Library API Documentation

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., 59 Temple Place - Suite 330,
00017    Boston, MA 02111-1307, 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 KSpreadValue ValueConverter::asBoolean (const KSpreadValue &value) const
00037 {
00038   KSpreadValue val;
00039   bool ok;  
00040   switch (value.type()) {
00041     case KSpreadValue::Empty:
00042       val.setValue (false);
00043     break;
00044     case KSpreadValue::Boolean:
00045       val = value;
00046     break;
00047     case KSpreadValue::Integer:
00048       val.setValue (value.asInteger() ? true : false); 
00049     break;
00050     case KSpreadValue::Float:
00051       val.setValue ((value.asFloat() == 0.0) ? false : true);
00052     break;
00053     case KSpreadValue::String:
00054       val = parser->tryParseBool (value.asString(), &ok);
00055       if (!ok)
00056         val.setValue (false);
00057     break;
00058     case KSpreadValue::Array:
00059       val = asBoolean (value.element (0, 0));
00060     break;
00061     case KSpreadValue::CellRange:
00062       /* NOTHING */
00063     break;
00064     case KSpreadValue::Error:
00065       val.setValue (false);
00066     break;
00067   };
00068   
00069   return val;
00070 }
00071 
00072 KSpreadValue ValueConverter::asInteger (const KSpreadValue &value) const
00073 {
00074   KSpreadValue val;
00075   bool ok;
00076   
00077   switch (value.type()) {
00078     case KSpreadValue::Empty:
00079       val.setValue (0);
00080     break;
00081     case KSpreadValue::Boolean:
00082       val.setValue (value.asBoolean() ? 1 : 0);
00083     break;
00084     case KSpreadValue::Integer:
00085       val = value;
00086     break;
00087     case KSpreadValue::Float:
00088       val.setValue (value.asInteger());
00089     break;
00090     case KSpreadValue::String:
00091       val.setValue ((int) parser->tryParseNumber
00092           (value.asString(), &ok).asFloat());
00093       if (!ok)
00094         val.setValue (0);
00095     break;
00096     case KSpreadValue::Array:
00097       val = asInteger (value.element (0, 0));
00098     break;
00099     case KSpreadValue::CellRange:
00100       /* NOTHING */
00101     break;
00102     case KSpreadValue::Error:
00103       val.setValue (0);
00104     break;
00105   };
00106   
00107   return val;
00108 }
00109 
00110 KSpreadValue ValueConverter::asFloat (const KSpreadValue &value) const
00111 {
00112   KSpreadValue val;
00113   bool ok;
00114   
00115   switch (value.type()) {
00116     case KSpreadValue::Empty:
00117       val.setValue (0.0);
00118     break;
00119     case KSpreadValue::Boolean:
00120       val.setValue (value.asBoolean() ? 1.0 : 0.0);
00121     break;
00122     case KSpreadValue::Integer:
00123       val.setValue (value.asFloat ());
00124     break;
00125     case KSpreadValue::Float:
00126       val = value;
00127     break;
00128     case KSpreadValue::String:
00129       val = parser->tryParseNumber (value.asString(), &ok);
00130       if (!ok)
00131         val.setValue (0.0);
00132     break;
00133     case KSpreadValue::Array:
00134       val = asFloat (value.element (0, 0));
00135     break;
00136     case KSpreadValue::CellRange:
00137       /* NOTHING */
00138     break;
00139     case KSpreadValue::Error:
00140       val.setValue (0.0);
00141     break;
00142   };
00143   
00144   return val;
00145 }
00146 
00147 KSpreadValue ValueConverter::asString (const KSpreadValue &value) const
00148 {
00149   // This is a simpler version of ValueFormatter... We cannot use that one,
00150   // as we sometimes want to generate the string differently ...
00151 
00152   KSpreadValue val;
00153   QString s;
00154   KSpreadValue::Format fmt;
00155   QChar decimal_point;
00156   int pos;
00157   switch (value.type()) {
00158     case KSpreadValue::Empty:
00159       val = QString::null;
00160     break;
00161     case KSpreadValue::Boolean:
00162       val.setValue (value.asBoolean() ? parser->locale()->translate ("True") :
00163           parser->locale()->translate ("False"));
00164     break;
00165     case KSpreadValue::Integer:
00166     {
00167       fmt = value.format();
00168       if (fmt == KSpreadValue::fmt_Percent)
00169         val = QString::number (value.asInteger() * 100) + " %";
00170       else if (fmt == KSpreadValue::fmt_DateTime)
00171         val = parser->locale()->formatDateTime (value.asDateTime());
00172       else if (fmt == KSpreadValue::fmt_Date)
00173         val = parser->locale()->formatDate (value.asDate());
00174       else if (fmt == KSpreadValue::fmt_Time)
00175         val = parser->locale()->formatTime (value.asTime());
00176       else
00177         val = QString::number (value.asInteger());
00178     }
00179     break;
00180     case KSpreadValue::Float:
00181       fmt = value.format();
00182       if (fmt == KSpreadValue::fmt_DateTime)
00183         val = parser->locale()->formatDateTime (value.asDateTime());
00184       else if (fmt == KSpreadValue::fmt_Date)
00185         val = parser->locale()->formatDate (value.asDate(), true);
00186       else if (fmt == KSpreadValue::fmt_Time)
00187         val = parser->locale()->formatTime (value.asTime());
00188       else
00189       {
00190         //convert the number, change decimal point from English to local
00191         s = QString::number (value.asFloat(), 'g', 10);
00192         decimal_point = parser->locale()->decimalSymbol()[0];
00193         if (decimal_point && ((pos = s.find ('.')) != -1))
00194           s = s.replace (pos, 1, decimal_point);
00195         if (fmt == KSpreadValue::fmt_Percent)
00196           s += " %";
00197         val.setValue (s);
00198       }
00199     break;
00200     case KSpreadValue::String:
00201       val = value;
00202     break;
00203     case KSpreadValue::Array:
00204       val = asString (value.element (0, 0));
00205     break;
00206     case KSpreadValue::CellRange:
00207       /* NOTHING */
00208     break;
00209     case KSpreadValue::Error:
00210       val.setValue (value.errorMessage ());
00211     break;
00212   };
00213   
00214   return val;
00215 }
00216 
00217 KSpreadValue ValueConverter::asDateTime (const KSpreadValue &value) const
00218 {
00219   KSpreadValue val;
00220   bool ok;
00221   
00222   switch (value.type()) {
00223     case KSpreadValue::Empty:
00224       val.setValue (QDateTime::currentDateTime());
00225     break;
00226     case KSpreadValue::Boolean:
00227       //ignore the bool value... any better idea? ;)
00228       val.setValue (QDateTime::currentDateTime());
00229     break;
00230     case KSpreadValue::Integer:
00231       val.setValue (value.asFloat());
00232       val.setFormat (KSpreadValue::fmt_DateTime);
00233     break;
00234     case KSpreadValue::Float:
00235       val.setValue (value.asFloat());
00236       val.setFormat (KSpreadValue::fmt_DateTime);
00237     break;
00238     case KSpreadValue::String:
00239       //no DateTime parser, so we parse as Date, hoping for the best ...
00240       val = parser->tryParseDate (value.asString(), &ok);
00241       if (!ok)
00242         val.setValue (QDateTime::currentDateTime());
00243       val.setFormat (KSpreadValue::fmt_DateTime);
00244     break;
00245     case KSpreadValue::Array:
00246       val = asDateTime (value.element (0, 0));
00247     break;
00248     case KSpreadValue::CellRange:
00249       /* NOTHING */
00250     break;
00251     case KSpreadValue::Error:
00252       val.setValue (QDateTime::currentDateTime());
00253     break;
00254   };
00255   
00256   return val;
00257 }
00258 
00259 KSpreadValue ValueConverter::asDate (const KSpreadValue &value) const
00260 {
00261   KSpreadValue val;
00262   bool ok;
00263   
00264   switch (value.type()) {
00265     case KSpreadValue::Empty:
00266       val.setValue (QDate::currentDate());
00267     break;
00268     case KSpreadValue::Boolean:
00269       //ignore the bool value... any better idea? ;)
00270       val.setValue (QDate::currentDate());
00271     break;
00272     case KSpreadValue::Integer:
00273       val.setValue (value.asFloat());
00274       val.setFormat (KSpreadValue::fmt_Date);
00275     break;
00276     case KSpreadValue::Float:
00277       val.setValue (value.asFloat());
00278       val.setFormat (KSpreadValue::fmt_Date);
00279     break;
00280     case KSpreadValue::String:
00281       val = parser->tryParseDate (value.asString(), &ok);
00282       if (!ok)
00283         val.setValue (QDate::currentDate());
00284     break;
00285     case KSpreadValue::Array:
00286       val = asDate (value.element (0, 0));
00287     break;
00288     case KSpreadValue::CellRange:
00289       /* NOTHING */
00290     break;
00291     case KSpreadValue::Error:
00292       val.setValue (QDate::currentDate());
00293     break;
00294   };
00295   
00296   return val;
00297 }
00298 
00299 KSpreadValue ValueConverter::asTime (const KSpreadValue &value) const
00300 {
00301   KSpreadValue val;
00302   bool ok;
00303   
00304   switch (value.type()) {
00305     case KSpreadValue::Empty:
00306       val.setValue (QTime::currentTime());
00307     break;
00308     case KSpreadValue::Boolean:
00309       //ignore the bool value... any better idea? ;)
00310       val.setValue (QTime::currentTime());
00311     break;
00312     case KSpreadValue::Integer:
00313       val.setValue (value.asFloat());
00314       val.setFormat (KSpreadValue::fmt_Time);
00315     break;
00316     case KSpreadValue::Float:
00317       val.setValue (value.asFloat());
00318       val.setFormat (KSpreadValue::fmt_Time);
00319     break;
00320     case KSpreadValue::String:
00321       val = parser->tryParseTime (value.asString(), &ok);
00322       if (!ok)
00323         val.setValue (QTime::currentTime());
00324     break;
00325     case KSpreadValue::Array:
00326       val = asTime (value.element (0, 0));
00327     break;
00328     case KSpreadValue::CellRange:
00329       /* NOTHING */
00330     break;
00331     case KSpreadValue::Error:
00332       val.setValue (QTime::currentTime());
00333     break;
00334   };
00335   
00336   return val;
00337 }
00338 
KDE Logo
This file is part of the documentation for kspread Library Version 1.4.2.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Mon Feb 13 09:43:38 2006 by doxygen 1.4.2 written by Dimitri van Heesch, © 1997-2003