LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/sc/source/filter/oox - unitconverter.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 68 99 68.7 %
Date: 2013-07-09 Functions: 12 16 75.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "unitconverter.hxx"
      21             : 
      22             : #include <com/sun/star/awt/DeviceInfo.hpp>
      23             : #include <com/sun/star/awt/FontDescriptor.hpp>
      24             : #include <com/sun/star/awt/XDevice.hpp>
      25             : #include <com/sun/star/awt/XFont.hpp>
      26             : #include <com/sun/star/util/Date.hpp>
      27             : #include <com/sun/star/util/DateTime.hpp>
      28             : #include <rtl/math.hxx>
      29             : #include "oox/core/filterbase.hxx"
      30             : #include "oox/helper/propertyset.hxx"
      31             : #include "oox/token/properties.hxx"
      32             : #include "stylesbuffer.hxx"
      33             : 
      34             : namespace oox {
      35             : namespace xls {
      36             : 
      37             : // ============================================================================
      38             : 
      39             : using namespace ::com::sun::star::awt;
      40             : using namespace ::com::sun::star::uno;
      41             : using namespace ::com::sun::star::util;
      42             : 
      43             : 
      44             : // ============================================================================
      45             : 
      46             : namespace {
      47             : 
      48             : const double MM100_PER_INCH         = 2540.0;
      49             : const double MM100_PER_POINT        = MM100_PER_INCH / 72.0;
      50             : const double MM100_PER_TWIP         = MM100_PER_POINT / 20.0;
      51             : const double MM100_PER_EMU          = 1.0 / 360.0;
      52             : 
      53             : // ----------------------------------------------------------------------------
      54             : 
      55             : /** Returns true, if the passed year is a leap year. */
      56          42 : inline sal_Int32 lclIsLeapYear( sal_Int32 nYear )
      57             : {
      58          42 :     return ((nYear % 4) == 0) && (((nYear % 100) != 0) || ((nYear % 400) == 0));
      59             : }
      60             : 
      61           0 : void lclSkipYearBlock( sal_Int32& ornDays, sal_Int16& ornYear, sal_Int32 nDaysInBlock, sal_Int32 nYearsPerBlock, sal_Int32 nMaxBlocks )
      62             : {
      63           0 :     sal_Int32 nBlocks = ::std::min< sal_Int32 >( ornDays / nDaysInBlock, nMaxBlocks );
      64           0 :     ornYear = static_cast< sal_Int16 >( ornYear + nYearsPerBlock * nBlocks );
      65           0 :     ornDays -= nBlocks * nDaysInBlock;
      66           0 : }
      67             : 
      68             : /** Returns the number of days before the passed date, starting from the null
      69             :     date 0000-Jan-01, using standard leap year conventions. */
      70          42 : sal_Int32 lclGetDays( const Date& rDate )
      71             : {
      72             :     // number of days in all full years before passed date including all leap days
      73          42 :     sal_Int32 nDays = rDate.Year * 365 + ((rDate.Year + 3) / 4) - ((rDate.Year + 99) / 100) + ((rDate.Year + 399) / 400);
      74             :     OSL_ENSURE( (1 <= rDate.Month) && (rDate.Month <= 12), "lclGetDays - invalid month" );
      75             :     OSL_ENSURE( (1 <= rDate.Day) && (rDate.Day <= 31), "lclGetDays - invalid day" );    // yes, this is weak...
      76          42 :     if( (1 <= rDate.Month) && (rDate.Month <= 12) )
      77             :     {
      78             :         // number of days at start of month   jan feb mar apr  may  jun  jul  aug  sep  oct  nov  dec
      79             :         static const sal_Int32 spnCumDays[] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
      80             :         // add number of days in full months before passed date
      81          42 :         nDays += spnCumDays[ rDate.Month - 1 ];
      82             :         // add number of days from passed date (this adds one day too much)
      83          42 :         nDays += rDate.Day;
      84             :         /*  Remove the one day added too much if there is no leap day before
      85             :             the passed day in the passed year. This means: remove the day, if
      86             :             we are in january or february (leap day not reached if existing),
      87             :             or if the passed year is not a leap year. */
      88          42 :         if( (rDate.Month < 3) || !lclIsLeapYear( rDate.Year ) )
      89          42 :             --nDays;
      90             :     }
      91          42 :     return nDays;
      92             : }
      93             : 
      94             : } // namespace
      95             : 
      96             : // ----------------------------------------------------------------------------
      97             : 
      98          21 : UnitConverter::UnitConverter( const WorkbookHelper& rHelper ) :
      99             :     WorkbookHelper( rHelper ),
     100             :     maCoeffs( UNIT_ENUM_SIZE, 1.0 ),
     101          21 :     mnNullDate( lclGetDays( Date( 30, 12, 1899 ) ) )
     102             : {
     103             :     // initialize constant and default coefficients
     104          21 :     const DeviceInfo& rDeviceInfo = getBaseFilter().getGraphicHelper().getDeviceInfo();
     105          21 :     maCoeffs[ UNIT_INCH ]    = MM100_PER_INCH;
     106          21 :     maCoeffs[ UNIT_POINT ]   = MM100_PER_POINT;
     107          21 :     maCoeffs[ UNIT_TWIP ]    = MM100_PER_TWIP;
     108          21 :     maCoeffs[ UNIT_EMU ]     = MM100_PER_EMU;
     109          21 :     maCoeffs[ UNIT_SCREENX ] = (rDeviceInfo.PixelPerMeterX > 0) ? (100000.0 / rDeviceInfo.PixelPerMeterX) : 50.0;
     110          21 :     maCoeffs[ UNIT_SCREENY ] = (rDeviceInfo.PixelPerMeterY > 0) ? (100000.0 / rDeviceInfo.PixelPerMeterY) : 50.0;
     111          21 :     maCoeffs[ UNIT_REFDEVX ] = 12.5;                 // default: 1 px = 0.125 mm
     112          21 :     maCoeffs[ UNIT_REFDEVY ] = 12.5;                 // default: 1 px = 0.125 mm
     113          21 :     maCoeffs[ UNIT_DIGIT ]   = 200.0;                // default: 1 digit = 2 mm
     114          21 :     maCoeffs[ UNIT_SPACE ]   = 100.0;                // default  1 space = 1 mm
     115             : 
     116             :     // error code maps
     117          21 :     addErrorCode( BIFF_ERR_NULL,  "#NULL!" );
     118          21 :     addErrorCode( BIFF_ERR_DIV0,  "#DIV/0!" );
     119          21 :     addErrorCode( BIFF_ERR_VALUE, "#VALUE!" );
     120          21 :     addErrorCode( BIFF_ERR_REF,   "#REF!" );
     121          21 :     addErrorCode( BIFF_ERR_NAME,  "#NAME?" );
     122          21 :     addErrorCode( BIFF_ERR_NUM,   "#NUM!" );
     123          21 :     addErrorCode( BIFF_ERR_NA,    "#NA" );
     124          21 : }
     125             : 
     126          21 : void UnitConverter::finalizeImport()
     127             : {
     128          21 :     PropertySet aDocProps( getDocument() );
     129          42 :     Reference< XDevice > xDevice( aDocProps.getAnyProperty( PROP_ReferenceDevice ), UNO_QUERY );
     130          21 :     if( xDevice.is() )
     131             :     {
     132             :         // get reference device metric first, needed to get character widths below
     133          21 :         DeviceInfo aInfo = xDevice->getInfo();
     134          21 :         maCoeffs[ UNIT_REFDEVX ] = 100000.0 / aInfo.PixelPerMeterX;
     135          21 :         maCoeffs[ UNIT_REFDEVY ] = 100000.0 / aInfo.PixelPerMeterY;
     136             : 
     137             :         // get character widths from default font
     138          21 :         if( const Font* pDefFont = getStyles().getDefaultFont().get() )
     139             :         {
     140             :             // XDevice expects pixels in font descriptor, but font contains twips
     141          21 :             FontDescriptor aDesc = pDefFont->getFontDescriptor();
     142          42 :             Reference< XFont > xFont = xDevice->getFont( aDesc );
     143          21 :             if( xFont.is() )
     144             :             {
     145             :                 // get maximum width of all digits
     146          21 :                 sal_Int32 nDigitWidth = 0;
     147         231 :                 for( sal_Unicode cChar = '0'; cChar <= '9'; ++cChar )
     148         210 :                     nDigitWidth = ::std::max( nDigitWidth, scaleToMm100( xFont->getCharWidth( cChar ), UNIT_TWIP ) );
     149          21 :                 if( nDigitWidth > 0 )
     150          21 :                     maCoeffs[ UNIT_DIGIT ] = nDigitWidth;
     151             :                 // get width of space character
     152          21 :                 sal_Int32 nSpaceWidth = scaleToMm100( xFont->getCharWidth( ' ' ), UNIT_TWIP );
     153          21 :                 if( nSpaceWidth > 0 )
     154          21 :                     maCoeffs[ UNIT_SPACE ] = nSpaceWidth;
     155          21 :             }
     156             :         }
     157          21 :     }
     158          21 : }
     159             : 
     160          21 : void UnitConverter::finalizeNullDate( const Date& rNullDate )
     161             : {
     162             :     // convert the nulldate to number of days since 0000-Jan-01
     163          21 :     mnNullDate = lclGetDays( rNullDate );
     164          21 : }
     165             : 
     166             : // conversion -----------------------------------------------------------------
     167             : 
     168           8 : double UnitConverter::scaleValue( double fValue, Unit eFromUnit, Unit eToUnit ) const
     169             : {
     170           8 :     return (eFromUnit == eToUnit) ? fValue : (fValue * getCoefficient( eFromUnit ) / getCoefficient( eToUnit ));
     171             : }
     172             : 
     173        1115 : sal_Int32 UnitConverter::scaleToMm100( double fValue, Unit eUnit ) const
     174             : {
     175        1115 :     return static_cast< sal_Int32 >( fValue * getCoefficient( eUnit ) + 0.5 );
     176             : }
     177             : 
     178          31 : double UnitConverter::scaleFromMm100( sal_Int32 nMm100, Unit eUnit ) const
     179             : {
     180          31 :     return static_cast< double >( nMm100 ) / getCoefficient( eUnit );
     181             : }
     182             : 
     183           0 : double UnitConverter::calcSerialFromDateTime( const DateTime& rDateTime ) const
     184             : {
     185           0 :     sal_Int32 nDays = lclGetDays( Date( rDateTime.Day, rDateTime.Month, rDateTime.Year ) ) - mnNullDate;
     186             :     OSL_ENSURE( nDays >= 0, "UnitConverter::calcDateTimeSerial - invalid date" );
     187             :     OSL_ENSURE( (rDateTime.Hours <= 23) && (rDateTime.Minutes <= 59) && (rDateTime.Seconds <= 59), "UnitConverter::calcDateTimeSerial - invalid time" );
     188           0 :     return nDays + rDateTime.Hours / 24.0 + rDateTime.Minutes / 1440.0 + rDateTime.Seconds / 86400.0;
     189             : }
     190             : 
     191           0 : DateTime UnitConverter::calcDateTimeFromSerial( double fSerial ) const
     192             : {
     193           0 :     DateTime aDateTime( 0, 0, 0, 0, 1, 1, 0 );
     194           0 :     double fDays = 0.0;
     195           0 :     double fTime = modf( fSerial, &fDays );
     196             : 
     197             :     // calculate date from number of days with O(1) complexity
     198           0 :     sal_Int32 nDays = getLimitedValue< sal_Int32, double >( fDays + mnNullDate, 0, 3652424 );
     199             :     // skip year 0, assumed to be a leap year. By starting at year 1, leap years can be handled easily
     200           0 :     if( nDays >= 366 ) { ++aDateTime.Year; nDays -= 366; }
     201             :     // skip full blocks of 400, 100, 4 years, and remaining full years
     202           0 :     lclSkipYearBlock( nDays, aDateTime.Year, 400 * 365 + 97, 400, 24 );
     203           0 :     lclSkipYearBlock( nDays, aDateTime.Year, 100 * 365 + 24, 100, 3 );
     204           0 :     lclSkipYearBlock( nDays, aDateTime.Year, 4 * 365 + 1, 4, 24 );
     205           0 :     lclSkipYearBlock( nDays, aDateTime.Year, 365, 1, 3 );
     206             :     // skip full months of current year
     207             :     static const sal_Int32 spnDaysInMonth[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
     208           0 :     if( (nDays >= 59) && !lclIsLeapYear( aDateTime.Year ) ) ++nDays;
     209           0 :     const sal_Int32* pnDaysInMonth = spnDaysInMonth;
     210           0 :     while( *pnDaysInMonth >= nDays ) { ++aDateTime.Month; nDays -= *pnDaysInMonth; ++pnDaysInMonth; }
     211           0 :     aDateTime.Day = static_cast< sal_uInt16 >( nDays + 1 );
     212             : 
     213             :     // calculate time from fractional part of serial
     214           0 :     sal_Int32 nTime = getLimitedValue< sal_Int32, double >( fTime * 86400, 0, 86399 );
     215           0 :     aDateTime.Seconds = static_cast< sal_uInt16 >( nTime % 60 );
     216           0 :     nTime /= 60;
     217           0 :     aDateTime.Minutes = static_cast< sal_uInt16 >( nTime % 60 );
     218           0 :     aDateTime.Hours = static_cast< sal_uInt16 >( nTime / 60 );
     219             : 
     220           0 :     return aDateTime;
     221             : }
     222             : 
     223           0 : sal_uInt8 UnitConverter::calcBiffErrorCode( const OUString& rErrorCode ) const
     224             : {
     225           0 :     OoxErrorCodeMap::const_iterator aIt = maOoxErrCodes.find( rErrorCode );
     226           0 :     return (aIt == maOoxErrCodes.end()) ? BIFF_ERR_NA : aIt->second;
     227             : }
     228             : 
     229         147 : void UnitConverter::addErrorCode( sal_uInt8 nErrorCode, const OUString& rErrorCode )
     230             : {
     231         147 :     maOoxErrCodes[ rErrorCode ]  = nErrorCode;
     232         147 : }
     233             : 
     234        1162 : double UnitConverter::getCoefficient( Unit eUnit ) const
     235             : {
     236             :     OSL_ENSURE( static_cast< size_t >( eUnit ) < UNIT_ENUM_SIZE, "UnitConverter::getCoefficient - invalid unit" );
     237        1162 :     return maCoeffs[ static_cast< size_t >( eUnit ) ];
     238             : }
     239             : 
     240             : // ============================================================================
     241             : 
     242             : } // namespace xls
     243          15 : } // namespace oox
     244             : 
     245             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10