oox/source/xls/unitconverter.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unitconverter.cxx,v $
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #include "oox/xls/unitconverter.hxx"
  32 #include <rtl/math.hxx>
  33 #include <com/sun/star/awt/FontDescriptor.hpp>
  34 #include <com/sun/star/awt/XDevice.hpp>
  35 #include <com/sun/star/awt/DeviceInfo.hpp>
  36 #include <com/sun/star/awt/XFont.hpp>
  37 #include <com/sun/star/util/Date.hpp>
  38 #include <com/sun/star/util/DateTime.hpp>
  39 #include "oox/core/filterbase.hxx"
  40 #include "oox/xls/stylesbuffer.hxx"
  41
  42 using ::rtl::OUString;
  43 using ::com::sun::star::uno::Reference;
  44 using ::com::sun::star::awt::FontDescriptor;
  45 using ::com::sun::star::awt::XDevice;
  46 using ::com::sun::star::awt::DeviceInfo;
  47 using ::com::sun::star::awt::XFont;
  48 using ::com::sun::star::util::Date;
  49 using ::com::sun::star::util::DateTime;
  50
  51 namespace oox {
  52 namespace xls {
  53
  54 // ============================================================================
  55
  56 namespace {
  57
  58 const double MM100_PER_INCH         = 2540.0;
  59 const double MM100_PER_POINT        = MM100_PER_INCH / 72.0;
  60 const double MM100_PER_TWIP         = MM100_PER_POINT / 20.0;
  61 const double MM100_PER_EMU          = 1.0 / 360.0;
  62
  63 // ----------------------------------------------------------------------------
  64
  65 /** Returns true, if the passed year is a leap year. */
  66 inline sal_Int32 lclIsLeapYear( sal_Int32 nYear )
  67 {
  68     return ((nYear % 4) == 0) && (((nYear % 100) != 0) || ((nYear % 400) == 0));
  69 }
  70
  71 void lclSkipYearBlock( sal_Int32& ornDays, sal_uInt16& ornYear, sal_Int32 nDaysInBlock, sal_Int32 nYearsPerBlock, sal_Int32 nMaxBlocks )
  72 {
  73     sal_Int32 nBlocks = ::std::min< sal_Int32 >( ornDays / nDaysInBlock, nMaxBlocks );
  74     ornYear = static_cast< sal_uInt16 >( ornYear + nYearsPerBlock * nBlocks );
  75     ornDays -= nBlocks * nDaysInBlock;
  76 }
  77
  78 /** Returns the number of days before the passed date, starting from the null
  79     date 0000-Jan-01, using standard leap year conventions. */
  80 sal_Int32 lclGetDays( const Date& rDate )
  81 {
  82     // number of days in all full years before passed date including all leap days
  83     sal_Int32 nDays = rDate.Year * 365 + ((rDate.Year + 3) / 4) - ((rDate.Year + 99) / 100) + ((rDate.Year + 399) / 400);
  84     OSL_ENSURE( (1 <= rDate.Month) && (rDate.Month <= 12), "lclGetDays - invalid month" );
  85     OSL_ENSURE( (1 <= rDate.Day) && (rDate.Day <= 31), "lclGetDays - invalid day" );    // yes, this is weak...
  86     if( (1 <= rDate.Month) && (rDate.Month <= 12) )
  87     {
  88         // number of days at start of month   jan feb mar apr  may  jun  jul  aug  sep  oct  nov  dec
  89         static const sal_Int32 spnCumDays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
  90         // add number of days in full months before passed date
  91         nDays += spnCumDays[ rDate.Month - 1 ];
  92         // add number of days from passed date (this adds one day too much)
  93         nDays += rDate.Day;
  94         /*  Remove the one day added too much if there is no leap day before
  95             the passed day in the passed year. This means: remove the day, if
  96             we are in january or february (leap day not reached if existing),
  97             or if the passed year is not a leap year. */
  98         if( (rDate.Month < 3) || !lclIsLeapYear( rDate.Year ) )
  99             --nDays;
 100     }
 101     return nDays;
 102 }
 103
 104 } // namespace
 105
 106 // ----------------------------------------------------------------------------
 107
 108 UnitConverter::UnitConverter( const WorkbookHelper& rHelper ) :
 109     WorkbookHelper( rHelper ),
 110     maCoeffs( UNIT_ENUM_SIZE, 1.0 ),
 111     mnNullDate( lclGetDays( Date( 30, 12, 1899 ) ) )
 112 {
 113     // initialize constant and default coefficients
 114     const DeviceInfo& rDeviceInfo = getBaseFilter().getDeviceInfo();
 115     maCoeffs[ UNIT_INCH ]    = MM100_PER_INCH;
 116     maCoeffs[ UNIT_POINT ]   = MM100_PER_POINT;
 117     maCoeffs[ UNIT_TWIP ]    = MM100_PER_TWIP;
 118     maCoeffs[ UNIT_EMU ]     = MM100_PER_EMU;
 119     maCoeffs[ UNIT_SCREENX ] = (rDeviceInfo.PixelPerMeterX > 0) ? (100000.0 / rDeviceInfo.PixelPerMeterX) : 50.0;
 120     maCoeffs[ UNIT_SCREENY ] = (rDeviceInfo.PixelPerMeterY > 0) ? (100000.0 / rDeviceInfo.PixelPerMeterY) : 50.0;
 121     maCoeffs[ UNIT_REFDEVX ] = 12.5;                 // default: 1 px = 0.125 mm
 122     maCoeffs[ UNIT_REFDEVY ] = 12.5;                 // default: 1 px = 0.125 mm
 123     maCoeffs[ UNIT_DIGIT ]   = 200.0;                // default: 1 digit = 2 mm
 124     maCoeffs[ UNIT_SPACE ]   = 100.0;                // default  1 space = 1 mm
 125
 126     // error code maps
 127     addErrorCode( BIFF_ERR_NULL,  CREATE_OUSTRING( "#NULL!" ) );
 128     addErrorCode( BIFF_ERR_DIV0,  CREATE_OUSTRING( "#DIV/0!" ) );
 129     addErrorCode( BIFF_ERR_VALUE, CREATE_OUSTRING( "#VALUE!" ) );
 130     addErrorCode( BIFF_ERR_REF,   CREATE_OUSTRING( "#REF!" ) );
 131     addErrorCode( BIFF_ERR_NAME,  CREATE_OUSTRING( "#NAME?" ) );
 132     addErrorCode( BIFF_ERR_NUM,   CREATE_OUSTRING( "#NUM!" ) );
 133     addErrorCode( BIFF_ERR_NA,    CREATE_OUSTRING( "#NA" ) );
 134 }
 135
 136 void UnitConverter::finalizeImport()
 137 {
 138     Reference< XDevice > xDevice = getReferenceDevice();
 139     if( xDevice.is() )
 140     {
 141         // get reference device metric first, needed to get character widths below
 142         DeviceInfo aInfo = xDevice->getInfo();
 143         maCoeffs[ UNIT_REFDEVX ] = 100000.0 / aInfo.PixelPerMeterX;
 144         maCoeffs[ UNIT_REFDEVY ] = 100000.0 / aInfo.PixelPerMeterY;
 145
 146         // get character widths from default font
 147         if( const Font* pDefFont = getStyles().getDefaultFont().get() )
 148         {
 149             // XDevice expects pixels in font descriptor, but font contains twips
 150             FontDescriptor aDesc = pDefFont->getFontDescriptor();
 151             aDesc.Height = static_cast< sal_Int16 >( scaleValue( aDesc.Height, UNIT_TWIP, UNIT_REFDEVX ) + 0.5 );
 152             Reference< XFont > xFont = xDevice->getFont( aDesc );
 153             if( xFont.is() )
 154             {
 155                 // get maximum width of all digits
 156                 sal_Int32 nDigitWidth = 0;
 157                 for( sal_Unicode cChar = '0'; cChar <= '9'; ++cChar )
 158                     nDigitWidth = ::std::max( nDigitWidth, scaleToMm100( xFont->getCharWidth( cChar ), UNIT_REFDEVX ) );
 159                 if( nDigitWidth > 0 )
 160                     maCoeffs[ UNIT_DIGIT ] = nDigitWidth;
 161                 // get width of space character
 162                 sal_Int32 nSpaceWidth = scaleToMm100( xFont->getCharWidth( ' ' ), UNIT_REFDEVX );
 163                 if( nSpaceWidth > 0 )
 164                     maCoeffs[ UNIT_SPACE ] = nSpaceWidth;
 165             }
 166         }
 167     }
 168 }
 169
 170 void UnitConverter::finalizeNullDate( const Date& rNullDate )
 171 {
 172     // convert the nulldate to number of days since 0000-Jan-01
 173     mnNullDate = lclGetDays( rNullDate );
 174 }
 175
 176 // conversion -----------------------------------------------------------------
 177
 178 double UnitConverter::scaleValue( double fValue, Unit eFromUnit, Unit eToUnit ) const
 179 {
 180     return (eFromUnit == eToUnit) ? fValue : (fValue * getCoefficient( eFromUnit ) / getCoefficient( eToUnit ));
 181 }
 182
 183 sal_Int32 UnitConverter::scaleToMm100( double fValue, Unit eUnit ) const
 184 {
 185     return static_cast< sal_Int32 >( fValue * getCoefficient( eUnit ) + 0.5 );
 186 }
 187
 188 double UnitConverter::scaleFromMm100( sal_Int32 nMm100, Unit eUnit ) const
 189 {
 190     return static_cast< double >( nMm100 ) / getCoefficient( eUnit );
 191 }
 192
 193 double UnitConverter::calcSerialFromDateTime( const DateTime& rDateTime ) const
 194 {
 195     sal_Int32 nDays = lclGetDays( Date( rDateTime.Day, rDateTime.Month, rDateTime.Year ) ) - mnNullDate;
 196     OSL_ENSURE( nDays >= 0, "UnitConverter::calcDateTimeSerial - invalid date" );
 197     OSL_ENSURE( (rDateTime.Hours <= 23) && (rDateTime.Minutes <= 59) && (rDateTime.Seconds <= 59), "UnitConverter::calcDateTimeSerial - invalid time" );
 198     return nDays + rDateTime.Hours / 24.0 + rDateTime.Minutes / 1440.0 + rDateTime.Seconds / 86400.0;
 199 }
 200
 201 DateTime UnitConverter::calcDateTimeFromSerial( double fSerial ) const
 202 {
 203     DateTime aDateTime( 0, 0, 0, 0, 1, 1, 0 );
 204     double fDays = 0.0;
 205     double fTime = modf( fSerial, &fDays );
 206
 207     // calculate date from number of days with O(1) complexity
 208     sal_Int32 nDays = getLimitedValue< sal_Int32, double >( fDays + mnNullDate, 0, 3652424 );
 209     // skip year 0, assumed to be a leap year. By starting at year 1, leap years can be handled easily
 210     if( nDays >= 366 ) { ++aDateTime.Year; nDays -= 366; }
 211     // skip full blocks of 400, 100, 4 years, and remaining full years
 212     lclSkipYearBlock( nDays, aDateTime.Year, 400 * 365 + 97, 400, 24 );
 213     lclSkipYearBlock( nDays, aDateTime.Year, 100 * 365 + 24, 100, 3 );
 214     lclSkipYearBlock( nDays, aDateTime.Year, 4 * 365 + 1, 4, 24 );
 215     lclSkipYearBlock( nDays, aDateTime.Year, 365, 1, 3 );
 216     // skip full months of current year
 217     static const sal_Int32 spnDaysInMonth[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
 218     if( (nDays >= 59) && !lclIsLeapYear( aDateTime.Year ) ) ++nDays;
 219     const sal_Int32* pnDaysInMonth = spnDaysInMonth;
 220     while( *pnDaysInMonth >= nDays ) { ++aDateTime.Month; nDays -= *pnDaysInMonth; ++pnDaysInMonth; }
 221     aDateTime.Day = static_cast< sal_uInt16 >( nDays + 1 );
 222
 223     // calculate time from fractional part of serial
 224     sal_Int32 nTime = getLimitedValue< sal_Int32, double >( fTime * 86400, 0, 86399 );
 225     aDateTime.Seconds = static_cast< sal_uInt16 >( nTime % 60 );
 226     nTime /= 60;
 227     aDateTime.Minutes = static_cast< sal_uInt16 >( nTime % 60 );
 228     aDateTime.Hours = static_cast< sal_uInt16 >( nTime / 60 );
 229
 230     return aDateTime;
 231 }
 232
 233 OUString UnitConverter::calcOoxErrorCode( sal_uInt8 nErrorCode ) const
 234 {
 235     BiffErrorCodeMap::const_iterator aIt = maBiffErrCodes.find( nErrorCode );
 236     return (aIt == maBiffErrCodes.end()) ? CREATE_OUSTRING( "#N/A" ) : aIt->second;
 237 }
 238
 239 sal_uInt8 UnitConverter::calcBiffErrorCode( const OUString& rErrorCode ) const
 240 {
 241     OoxErrorCodeMap::const_iterator aIt = maOoxErrCodes.find( rErrorCode );
 242     return (aIt == maOoxErrCodes.end()) ? BIFF_ERR_NA : aIt->second;
 243 }
 244
 245 void UnitConverter::addErrorCode( sal_uInt8 nErrorCode, const OUString& rErrorCode )
 246 {
 247     maOoxErrCodes[ rErrorCode ]  = nErrorCode;
 248     maBiffErrCodes[ nErrorCode ] = rErrorCode;
 249 }
 250
 251 double UnitConverter::getCoefficient( Unit eUnit ) const
 252 {
 253     OSL_ENSURE( static_cast< size_t >( eUnit ) < UNIT_ENUM_SIZE, "UnitConverter::getCoefficient - invalid unit" );
 254     return maCoeffs[ static_cast< size_t >( eUnit ) ];
 255 }
 256
 257 // ============================================================================
 258
 259 } // namespace xls
 260 } // namespace oox
 261