scaddins/source/datefunc/datefunc.cxx

   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 //------------------------------------------------------------------
  21 //
  22 // date functions add in
  23 //
  24 //------------------------------------------------------------------
  25
  26 #include "datefunc.hxx"
  27 #include "datefunc.hrc"
  28 #include <cppuhelper/factory.hxx>
  29 #include <osl/diagnose.h>
  30 #include <rtl/ustrbuf.hxx>
  31 #include <tools/resmgr.hxx>
  32 #include <tools/rcid.h>
  33 #include <com/sun/star/util/Date.hpp>
  34
  35 using namespace ::com::sun::star;
  36 using namespace ::rtl;
  37
  38 //------------------------------------------------------------------
  39
  40 #define ADDIN_SERVICE           "com.sun.star.sheet.AddIn"
  41 #define MY_SERVICE              "com.sun.star.sheet.addin.DateFunctions"
  42 #define MY_IMPLNAME             "com.sun.star.sheet.addin.DateFunctionsImpl"
  43
  44 //------------------------------------------------------------------
  45
  46 #define STR_FROM_ANSI( s )      OUString( s, strlen( s ), RTL_TEXTENCODING_MS_1252 )
  47
  48 //------------------------------------------------------------------
  49
  50 const sal_uInt32 ScaList::nStartSize = 16;
  51 const sal_uInt32 ScaList::nIncrSize = 16;
  52
  53 ScaList::ScaList() :
  54     pData( new void*[ nStartSize ] ),
  55     nSize( nStartSize ),
  56     nCount( 0 ),
  57     nCurr( 0 )
  58 {
  59 }
  60
  61 ScaList::~ScaList()
  62 {
  63     delete[] pData;
  64 }
  65
  66 void ScaList::_Grow()
  67 {
  68     nSize += nIncrSize;
  69
  70     void** pNewData = new void*[ nSize ];
  71     memcpy( pNewData, pData, nCount * sizeof( void* ) );
  72
  73     delete[] pData;
  74     pData = pNewData;
  75 }
  76
  77 //------------------------------------------------------------------
  78
  79 ScaStringList::~ScaStringList()
  80 {
  81     for( OUString* pStr = First(); pStr; pStr = Next() )
  82         delete pStr;
  83 }
  84
  85 //------------------------------------------------------------------
  86
  87 ScaResId::ScaResId( sal_uInt16 nId, ResMgr& rResMgr ) :
  88     ResId( nId, rResMgr )
  89 {
  90 }
  91
  92
  93 //------------------------------------------------------------------
  94
  95 #define UNIQUE              sal_False   // function name does not exist in Calc
  96
  97 #define STDPAR              sal_False   // all parameters are described
  98 #define INTPAR              sal_True    // first parameter is internal
  99
 100 #define FUNCDATA( FuncName, ParamCount, Category, Double, IntPar )  \
 101     { "get" #FuncName, DATE_FUNCNAME_##FuncName, DATE_FUNCDESC_##FuncName, DATE_DEFFUNCNAME_##FuncName, ParamCount, Category, Double, IntPar }
 102
 103 const ScaFuncDataBase pFuncDataArr[] =
 104 {
 105     FUNCDATA( DiffWeeks,    3, ScaCat_DateTime, UNIQUE, INTPAR ),
 106     FUNCDATA( DiffMonths,   3, ScaCat_DateTime, UNIQUE, INTPAR ),
 107     FUNCDATA( DiffYears,    3, ScaCat_DateTime, UNIQUE, INTPAR ),
 108     FUNCDATA( IsLeapYear,   1, ScaCat_DateTime, UNIQUE, INTPAR ),
 109     FUNCDATA( DaysInMonth,  1, ScaCat_DateTime, UNIQUE, INTPAR ),
 110     FUNCDATA( DaysInYear,   1, ScaCat_DateTime, UNIQUE, INTPAR ),
 111     FUNCDATA( WeeksInYear,  1, ScaCat_DateTime, UNIQUE, INTPAR ),
 112     FUNCDATA( Rot13,        1, ScaCat_Text,     UNIQUE, STDPAR )
 113 };
 114
 115 #undef FUNCDATA
 116
 117
 118 //------------------------------------------------------------------
 119
 120 ScaFuncData::ScaFuncData( const ScaFuncDataBase& rBaseData, ResMgr& rResMgr ) :
 121     aIntName( OUString::createFromAscii( rBaseData.pIntName ) ),
 122     nUINameID( rBaseData.nUINameID ),
 123     nDescrID( rBaseData.nDescrID ),
 124     nCompListID( rBaseData.nCompListID ),
 125     nParamCount( rBaseData.nParamCount ),
 126     eCat( rBaseData.eCat ),
 127     bDouble( rBaseData.bDouble ),
 128     bWithOpt( rBaseData.bWithOpt )
 129 {
 130     ScaResStringArrLoader aArrLoader( RID_DATE_DEFFUNCTION_NAMES, nCompListID, rResMgr );
 131     const ResStringArray& rArr = aArrLoader.GetStringArray();
 132
 133     for( sal_uInt16 nIndex = 0; nIndex < rArr.Count(); nIndex++ )
 134         aCompList.Append( rArr.GetString( nIndex ) );
 135 }
 136
 137 ScaFuncData::~ScaFuncData()
 138 {
 139 }
 140
 141 sal_uInt16 ScaFuncData::GetStrIndex( sal_uInt16 nParam ) const
 142 {
 143     if( !bWithOpt )
 144         nParam++;
 145     return (nParam > nParamCount) ? (nParamCount * 2) : (nParam * 2);
 146 }
 147
 148
 149 //------------------------------------------------------------------
 150
 151 ScaFuncDataList::ScaFuncDataList( ResMgr& rResMgr ) :
 152     nLast( 0xFFFFFFFF )
 153 {
 154     for( sal_uInt16 nIndex = 0; nIndex < SAL_N_ELEMENTS(pFuncDataArr); nIndex++ )
 155         Append( new ScaFuncData( pFuncDataArr[ nIndex ], rResMgr ) );
 156 }
 157
 158 ScaFuncDataList::~ScaFuncDataList()
 159 {
 160     for( ScaFuncData* pFData = First(); pFData; pFData = Next() )
 161         delete pFData;
 162 }
 163
 164 const ScaFuncData* ScaFuncDataList::Get( const OUString& rProgrammaticName ) const
 165 {
 166     if( aLastName == rProgrammaticName )
 167         return Get( nLast );
 168
 169     for( sal_uInt32 nIndex = 0; nIndex < Count(); nIndex++ )
 170     {
 171         const ScaFuncData* pCurr = Get( nIndex );
 172         if( pCurr->Is( rProgrammaticName ) )
 173         {
 174             const_cast< ScaFuncDataList* >( this )->aLastName = rProgrammaticName;
 175             const_cast< ScaFuncDataList* >( this )->nLast = nIndex;
 176             return pCurr;
 177         }
 178     }
 179     return NULL;
 180 }
 181
 182
 183 //------------------------------------------------------------------
 184
 185 ScaFuncRes::ScaFuncRes( ResId& rResId, ResMgr& rResMgr, sal_uInt16 nIndex, OUString& rRet ) :
 186     Resource( rResId )
 187 {
 188     rRet = String( ScaResId( nIndex, rResMgr ) );
 189     FreeResource();
 190 }
 191
 192
 193 //------------------------------------------------------------------
 194 //
 195 //  entry points for service registration / instantiation
 196 //
 197 //------------------------------------------------------------------
 198
 199 uno::Reference< uno::XInterface > SAL_CALL ScaDateAddIn_CreateInstance(
 200         const uno::Reference< lang::XMultiServiceFactory >& )
 201 {
 202     static uno::Reference< uno::XInterface > xInst = (cppu::OWeakObject*) new ScaDateAddIn();
 203     return xInst;
 204 }
 205
 206
 207 //------------------------------------------------------------------------
 208
 209 extern "C" {
 210
 211 SAL_DLLPUBLIC_EXPORT void * SAL_CALL date_component_getFactory(
 212     const sal_Char * pImplName, void * pServiceManager, void * /*pRegistryKey*/ )
 213 {
 214     void* pRet = 0;
 215
 216     if ( pServiceManager &&
 217             OUString::createFromAscii( pImplName ) == ScaDateAddIn::getImplementationName_Static() )
 218     {
 219         uno::Reference< lang::XSingleServiceFactory > xFactory( cppu::createOneInstanceFactory(
 220                 reinterpret_cast< lang::XMultiServiceFactory* >( pServiceManager ),
 221                 ScaDateAddIn::getImplementationName_Static(),
 222                 ScaDateAddIn_CreateInstance,
 223                 ScaDateAddIn::getSupportedServiceNames_Static() ) );
 224
 225         if (xFactory.is())
 226         {
 227             xFactory->acquire();
 228             pRet = xFactory.get();
 229         }
 230     }
 231
 232     return pRet;
 233 }
 234
 235 }   // extern C
 236
 237 //------------------------------------------------------------------------
 238 //
 239 //  "normal" service implementation
 240 //
 241 //------------------------------------------------------------------------
 242
 243 ScaDateAddIn::ScaDateAddIn() :
 244     pDefLocales( NULL ),
 245     pResMgr( NULL ),
 246     pFuncDataList( NULL )
 247 {
 248 }
 249
 250 ScaDateAddIn::~ScaDateAddIn()
 251 {
 252     if( pFuncDataList )
 253         delete pFuncDataList;
 254     if( pDefLocales )
 255         delete[] pDefLocales;
 256
 257     // pResMgr already deleted (_all_ resource managers are deleted _before_ this dtor is called)
 258 }
 259
 260 static const sal_Char*  pLang[] = { "de", "en" };
 261 static const sal_Char*  pCoun[] = { "DE", "US" };
 262 static const sal_uInt32 nNumOfLoc = SAL_N_ELEMENTS( pLang );
 263
 264 void ScaDateAddIn::InitDefLocales()
 265 {
 266     pDefLocales = new lang::Locale[ nNumOfLoc ];
 267
 268     for( sal_uInt32 nIndex = 0; nIndex < nNumOfLoc; nIndex++ )
 269     {
 270         pDefLocales[ nIndex ].Language = OUString::createFromAscii( pLang[ nIndex ] );
 271         pDefLocales[ nIndex ].Country = OUString::createFromAscii( pCoun[ nIndex ] );
 272     }
 273 }
 274
 275 const lang::Locale& ScaDateAddIn::GetLocale( sal_uInt32 nIndex )
 276 {
 277     if( !pDefLocales )
 278         InitDefLocales();
 279
 280     return (nIndex < sizeof( pLang )) ? pDefLocales[ nIndex ] : aFuncLoc;
 281 }
 282
 283 ResMgr& ScaDateAddIn::GetResMgr() throw( uno::RuntimeException )
 284 {
 285     if( !pResMgr )
 286     {
 287         InitData();     // try to get resource manager
 288         if( !pResMgr )
 289             throw uno::RuntimeException();
 290     }
 291     return *pResMgr;
 292 }
 293
 294 void ScaDateAddIn::InitData()
 295 {
 296     if( pResMgr )
 297         delete pResMgr;
 298
 299     OString aModName( "date" );
 300     pResMgr = ResMgr::CreateResMgr( aModName.getStr(), LanguageTag( aFuncLoc) );
 301
 302     if( pFuncDataList )
 303         delete pFuncDataList;
 304
 305     pFuncDataList = pResMgr ? new ScaFuncDataList( *pResMgr ) : NULL;
 306
 307     if( pDefLocales )
 308     {
 309         delete pDefLocales;
 310         pDefLocales = NULL;
 311     }
 312 }
 313
 314 OUString ScaDateAddIn::GetDisplFuncStr( sal_uInt16 nResId ) throw( uno::RuntimeException )
 315 {
 316     return ScaResStringLoader( RID_DATE_FUNCTION_NAMES, nResId, GetResMgr() ).GetString();
 317 }
 318
 319 OUString ScaDateAddIn::GetFuncDescrStr( sal_uInt16 nResId, sal_uInt16 nStrIndex ) throw( uno::RuntimeException )
 320 {
 321     OUString aRet;
 322
 323     ScaResPublisher aResPubl( ScaResId( RID_DATE_FUNCTION_DESCRIPTIONS, GetResMgr() ) );
 324     ScaResId aResId( nResId, GetResMgr() );
 325     aResId.SetRT( RSC_RESOURCE );
 326
 327     if( aResPubl.IsAvailableRes( aResId ) )
 328         ScaFuncRes aSubRes( aResId, GetResMgr(), nStrIndex, aRet );
 329
 330     aResPubl.FreeResource();
 331     return aRet;
 332 }
 333
 334
 335 //------------------------------------------------------------------------
 336
 337 OUString ScaDateAddIn::getImplementationName_Static()
 338 {
 339     return OUString( MY_IMPLNAME );
 340 }
 341
 342 uno::Sequence< OUString > ScaDateAddIn::getSupportedServiceNames_Static()
 343 {
 344     uno::Sequence< OUString > aRet( 2 );
 345     OUString* pArray = aRet.getArray();
 346     pArray[0] = OUString( ADDIN_SERVICE );
 347     pArray[1] = OUString( MY_SERVICE );
 348     return aRet;
 349 }
 350
 351 // XServiceName
 352
 353 OUString SAL_CALL ScaDateAddIn::getServiceName() throw( uno::RuntimeException )
 354 {
 355     // name of specific AddIn service
 356     return OUString( MY_SERVICE );
 357 }
 358
 359 // XServiceInfo
 360
 361 OUString SAL_CALL ScaDateAddIn::getImplementationName() throw( uno::RuntimeException )
 362 {
 363     return getImplementationName_Static();
 364 }
 365
 366 sal_Bool SAL_CALL ScaDateAddIn::supportsService( const OUString& aServiceName ) throw( uno::RuntimeException )
 367 {
 368     return aServiceName == ADDIN_SERVICE || aServiceName == MY_SERVICE;
 369 }
 370
 371 uno::Sequence< OUString > SAL_CALL ScaDateAddIn::getSupportedServiceNames() throw( uno::RuntimeException )
 372 {
 373     return getSupportedServiceNames_Static();
 374 }
 375
 376 // XLocalizable
 377
 378 void SAL_CALL ScaDateAddIn::setLocale( const lang::Locale& eLocale ) throw( uno::RuntimeException )
 379 {
 380     aFuncLoc = eLocale;
 381     InitData();     // change of locale invalidates resources!
 382 }
 383
 384 lang::Locale SAL_CALL ScaDateAddIn::getLocale() throw( uno::RuntimeException )
 385 {
 386     return aFuncLoc;
 387 }
 388
 389 //------------------------------------------------------------------
 390 //
 391 //  function descriptions start here
 392 //
 393 //------------------------------------------------------------------
 394
 395 // XAddIn
 396
 397 OUString SAL_CALL ScaDateAddIn::getProgrammaticFuntionName( const OUString& ) throw( uno::RuntimeException )
 398 {
 399     //  not used by calc
 400     //  (but should be implemented for other uses of the AddIn service)
 401     return OUString();
 402 }
 403
 404 OUString SAL_CALL ScaDateAddIn::getDisplayFunctionName( const OUString& aProgrammaticName ) throw( uno::RuntimeException )
 405 {
 406     OUString aRet;
 407
 408     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 409     if( pFData )
 410     {
 411         aRet = GetDisplFuncStr( pFData->GetUINameID() );
 412         if( pFData->IsDouble() )
 413             aRet += STR_FROM_ANSI( "_ADD" );
 414     }
 415     else
 416     {
 417         aRet = STR_FROM_ANSI( "UNKNOWNFUNC_" );
 418         aRet += aProgrammaticName;
 419     }
 420
 421     return aRet;
 422 }
 423
 424 OUString SAL_CALL ScaDateAddIn::getFunctionDescription( const OUString& aProgrammaticName ) throw( uno::RuntimeException )
 425 {
 426     OUString aRet;
 427
 428     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 429     if( pFData )
 430         aRet = GetFuncDescrStr( pFData->GetDescrID(), 1 );
 431
 432     return aRet;
 433 }
 434
 435 OUString SAL_CALL ScaDateAddIn::getDisplayArgumentName(
 436         const OUString& aProgrammaticName, sal_Int32 nArgument ) throw( uno::RuntimeException )
 437 {
 438     OUString aRet;
 439
 440     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 441     if( pFData && (nArgument <= 0xFFFF) )
 442     {
 443         sal_uInt16 nStr = pFData->GetStrIndex( static_cast< sal_uInt16 >( nArgument ) );
 444         if( nStr )
 445             aRet = GetFuncDescrStr( pFData->GetDescrID(), nStr );
 446         else
 447             aRet = STR_FROM_ANSI( "internal" );
 448     }
 449
 450     return aRet;
 451 }
 452
 453 OUString SAL_CALL ScaDateAddIn::getArgumentDescription(
 454         const OUString& aProgrammaticName, sal_Int32 nArgument ) throw( uno::RuntimeException )
 455 {
 456     OUString aRet;
 457
 458     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 459     if( pFData && (nArgument <= 0xFFFF) )
 460     {
 461         sal_uInt16 nStr = pFData->GetStrIndex( static_cast< sal_uInt16 >( nArgument ) );
 462         if( nStr )
 463             aRet = GetFuncDescrStr( pFData->GetDescrID(), nStr + 1 );
 464         else
 465             aRet = STR_FROM_ANSI( "for internal use only" );
 466     }
 467
 468     return aRet;
 469 }
 470
 471 OUString SAL_CALL ScaDateAddIn::getProgrammaticCategoryName(
 472         const OUString& aProgrammaticName ) throw( uno::RuntimeException )
 473 {
 474     OUString aRet;
 475
 476     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 477     if( pFData )
 478     {
 479         switch( pFData->GetCategory() )
 480         {
 481             case ScaCat_DateTime:   aRet = STR_FROM_ANSI( "Date&Time" );    break;
 482             case ScaCat_Text:       aRet = STR_FROM_ANSI( "Text" );         break;
 483             case ScaCat_Finance:    aRet = STR_FROM_ANSI( "Financial" );    break;
 484             case ScaCat_Inf:        aRet = STR_FROM_ANSI( "Information" );  break;
 485             case ScaCat_Math:       aRet = STR_FROM_ANSI( "Mathematical" ); break;
 486             case ScaCat_Tech:       aRet = STR_FROM_ANSI( "Technical" );    break;
 487             default:    // to prevent compiler warnings
 488                 break;
 489         }
 490     }
 491
 492     if( aRet.isEmpty() )
 493         aRet = STR_FROM_ANSI( "Add-In" );
 494     return aRet;
 495 }
 496
 497 OUString SAL_CALL ScaDateAddIn::getDisplayCategoryName(
 498         const OUString& aProgrammaticName ) throw( uno::RuntimeException )
 499 {
 500     return getProgrammaticCategoryName( aProgrammaticName );
 501 }
 502
 503
 504 // XCompatibilityNames
 505
 506 uno::Sequence< sheet::LocalizedName > SAL_CALL ScaDateAddIn::getCompatibilityNames(
 507         const OUString& aProgrammaticName ) throw( uno::RuntimeException )
 508 {
 509     const ScaFuncData* pFData = pFuncDataList->Get( aProgrammaticName );
 510     if( !pFData )
 511         return uno::Sequence< sheet::LocalizedName >( 0 );
 512
 513     const ScaStringList& rStrList = pFData->GetCompNameList();
 514     sal_uInt32 nCount = rStrList.Count();
 515
 516     uno::Sequence< sheet::LocalizedName > aRet( nCount );
 517     sheet::LocalizedName* pArray = aRet.getArray();
 518
 519     for( sal_uInt32 nIndex = 0; nIndex < nCount; nIndex++ )
 520         pArray[ nIndex ] = sheet::LocalizedName( GetLocale( nIndex ), *rStrList.Get( nIndex ) );
 521
 522     return aRet;
 523 }
 524
 525 namespace {
 526 // auxiliary functions
 527
 528 sal_Bool IsLeapYear( sal_uInt16 nYear )
 529 {
 530     return ((((nYear % 4) == 0) && ((nYear % 100) != 0)) || ((nYear % 400) == 0));
 531 }
 532
 533 sal_uInt16 DaysInMonth( sal_uInt16 nMonth, sal_uInt16 nYear )
 534 {
 535     static sal_uInt16 aDaysInMonth[12] = { 31, 28, 31, 30, 31, 30,
 536                                         31, 31, 30, 31, 30, 31 };
 537
 538     if ( nMonth != 2 )
 539         return aDaysInMonth[nMonth-1];
 540     else
 541     {
 542         if ( IsLeapYear(nYear) )
 543             return aDaysInMonth[nMonth-1] + 1;
 544         else
 545             return aDaysInMonth[nMonth-1];
 546     }
 547 }
 548
 549 /**
 550  * Convert a date to a count of days starting from 01/01/0001
 551  *
 552  * The internal representation of a Date used in this Addin
 553  * is the number of days between 01/01/0001 and the date
 554  * this function converts a Day , Month, Year representation
 555  * to this internal Date value.
 556  */
 557
 558 sal_Int32 DateToDays( sal_uInt16 nDay, sal_uInt16 nMonth, sal_uInt16 nYear )
 559 {
 560     sal_Int32 nDays = ((sal_Int32)nYear-1) * 365;
 561     nDays += ((nYear-1) / 4) - ((nYear-1) / 100) + ((nYear-1) / 400);
 562
 563     for( sal_uInt16 i = 1; i < nMonth; i++ )
 564         nDays += DaysInMonth(i,nYear);
 565     nDays += nDay;
 566
 567     return nDays;
 568 }
 569
 570 /**
 571  * Convert a count of days starting from 01/01/0001 to a date
 572  *
 573  * The internal representation of a Date used in this Addin
 574  * is the number of days between 01/01/0001 and the date
 575  * this function converts this internal Date value
 576  * to a Day , Month, Year representation of a Date.
 577  */
 578
 579 void DaysToDate( sal_Int32 nDays,
 580                 sal_uInt16& rDay, sal_uInt16& rMonth, sal_uInt16& rYear )
 581         throw( lang::IllegalArgumentException )
 582 {
 583     if( nDays < 0 )
 584         throw lang::IllegalArgumentException();
 585
 586     sal_Int32   nTempDays;
 587     sal_Int32   i = 0;
 588     sal_Bool    bCalc;
 589
 590     do
 591     {
 592         nTempDays = nDays;
 593         rYear = (sal_uInt16)((nTempDays / 365) - i);
 594         nTempDays -= ((sal_Int32) rYear -1) * 365;
 595         nTempDays -= (( rYear -1) / 4) - (( rYear -1) / 100) + ((rYear -1) / 400);
 596         bCalc = sal_False;
 597         if ( nTempDays < 1 )
 598         {
 599             i++;
 600             bCalc = sal_True;
 601         }
 602         else
 603         {
 604             if ( nTempDays > 365 )
 605             {
 606                 if ( (nTempDays != 366) || !IsLeapYear( rYear ) )
 607                 {
 608                     i--;
 609                     bCalc = sal_True;
 610                 }
 611             }
 612         }
 613     }
 614     while ( bCalc );
 615
 616     rMonth = 1;
 617     while ( (sal_Int32)nTempDays > DaysInMonth( rMonth, rYear ) )
 618     {
 619         nTempDays -= DaysInMonth( rMonth, rYear );
 620         rMonth++;
 621     }
 622     rDay = (sal_uInt16)nTempDays;
 623 }
 624
 625 /**
 626  * Get the null date used by the spreadsheet document
 627  *
 628  * The internal representation of a Date used in this Addin
 629  * is the number of days between 01/01/0001 and the date
 630  * this function returns this internal Date value for the document null date
 631  *
 632  */
 633
 634 sal_Int32 GetNullDate( const uno::Reference< beans::XPropertySet >& xOptions )
 635         throw( uno::RuntimeException )
 636 {
 637     if (xOptions.is())
 638     {
 639         try
 640         {
 641             uno::Any aAny = xOptions->getPropertyValue(
 642                                         OUString( "NullDate" ) );
 643             util::Date aDate;
 644             if ( aAny >>= aDate )
 645                 return DateToDays( aDate.Day, aDate.Month, aDate.Year );
 646         }
 647         catch (uno::Exception&)
 648         {
 649         }
 650     }
 651
 652     // no null date available -> no calculations possible
 653     throw uno::RuntimeException();
 654 }
 655
 656 }
 657 // XDateFunctions
 658
 659 /**
 660  * Get week difference between 2 dates
 661  *
 662  * new Weeks(date1,date2,mode) function for StarCalc
 663  *
 664  * Two modes of operation are provided.
 665  * The first is just a simple division by 7 calculation.
 666  *
 667  * The second calculates the diffence by week of year.
 668  *
 669  * The International Standard IS-8601 has decreed that Monday
 670  * shall be the first day of the week.
 671  *
 672  * A week that lies partly in one year and partly in annother
 673  * is assigned a number in the year in which most of its days lie.
 674  *
 675  * That means that week 1 of any year is the week that contains the 4. January
 676  *
 677  * The internal representation of a Date used in the Addin is the number of days based on 01/01/0001
 678  *
 679  * A WeekDay can be then calculated by substracting 1 and calculating the rest of
 680  * a division by 7, which gives a 0 - 6 value for Monday - Sunday
 681  *
 682  * Using the 4. January rule explained above the formula
 683  *
 684  *  nWeek1= ( nDays1 - nJan4 + ( (nJan4-1) % 7 ) ) / 7 + 1;
 685  *
 686  * calculates a number between 0-53 for each day which is in the same year as nJan4
 687  * where 0 means that this week belonged to the year before.
 688  *
 689  * If a day in the same or annother year is used in this formula this calculates
 690  * an calendar week offset from a given 4. January
 691  *
 692  *  nWeek2 = ( nDays2 - nJan4 + ( (nJan4-1) % 7 ) ) / 7 + 1;
 693  *
 694  * The 4.January of first Date Argument can thus be used to calculate
 695  * the week difference by calendar weeks which is then nWeek = nWeek2 - nWeek1
 696  *
 697  * which can be optimized to
 698  *
 699  * nWeek = ( (nDays2-nJan4+((nJan4-1)%7))/7 ) - ( (nDays1-nJan4+((nJan4-1)%7))/7 )
 700  *
 701  * Note: All calculations are operating on the long integer data type
 702  * % is the modulo operator in C which calculates the rest of an Integer division
 703  *
 704  *
 705  * mode 0 is the interval between the dates in month, that is days / 7
 706  *
 707  * mode 1 is the difference by week of year
 708  *
 709  */
 710
 711 sal_Int32 SAL_CALL ScaDateAddIn::getDiffWeeks(
 712         const uno::Reference< beans::XPropertySet >& xOptions,
 713         sal_Int32 nStartDate, sal_Int32 nEndDate,
 714         sal_Int32 nMode ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 715 {
 716     sal_Int32 nNullDate = GetNullDate( xOptions );
 717
 718     sal_Int32 nDays1 = nStartDate + nNullDate;
 719     sal_Int32 nDays2 = nEndDate + nNullDate;
 720
 721     sal_Int32 nRet;
 722
 723     if ( nMode == 1 )
 724     {
 725         sal_uInt16 nDay,nMonth,nYear;
 726         DaysToDate( nDays1, nDay, nMonth, nYear );
 727         sal_Int32 nJan4 = DateToDays( 4, 1, nYear );
 728
 729         nRet = ( (nDays2-nJan4+((nJan4-1)%7))/7 ) - ( (nDays1-nJan4+((nJan4-1)%7))/7 );
 730     }
 731     else
 732     {
 733         nRet = (nDays2 - nDays1) / 7;
 734     }
 735     return nRet;
 736 }
 737
 738 /**
 739  * Get month difference between 2 dates
 740  * =Month(start, end, mode) Function for StarCalc
 741  *
 742  * two modes are provided
 743  *
 744  * mode 0 is the interval between the dates in month
 745  *
 746  * mode 1 is the difference in calendar month
 747  */
 748
 749 sal_Int32 SAL_CALL ScaDateAddIn::getDiffMonths(
 750         const uno::Reference< beans::XPropertySet >& xOptions,
 751         sal_Int32 nStartDate, sal_Int32 nEndDate,
 752         sal_Int32 nMode ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 753 {
 754     sal_Int32 nNullDate = GetNullDate( xOptions );
 755
 756     sal_Int32 nDays1 = nStartDate + nNullDate;
 757     sal_Int32 nDays2 = nEndDate + nNullDate;
 758
 759     sal_uInt16 nDay1,nMonth1,nYear1;
 760     sal_uInt16 nDay2,nMonth2,nYear2;
 761     DaysToDate(nDays1,nDay1,nMonth1,nYear1);
 762     DaysToDate(nDays2,nDay2,nMonth2,nYear2);
 763
 764     sal_Int32 nRet = nMonth2 - nMonth1 + (nYear2 - nYear1) * 12;
 765     if ( nMode == 1 || nDays1 == nDays2 ) return nRet;
 766
 767     if ( nDays1 < nDays2 )
 768     {
 769         if ( nDay1 > nDay2 )
 770         {
 771             nRet -= 1;
 772         }
 773     }
 774     else
 775     {
 776         if ( nDay1 < nDay2 )
 777         {
 778             nRet += 1;
 779         }
 780     }
 781
 782     return nRet;
 783 }
 784
 785 /**
 786  * Get Year difference between 2 dates
 787  *
 788  * two modes are provided
 789  *
 790  * mode 0 is the interval between the dates in years
 791  *
 792  * mode 1 is the difference in calendar years
 793  */
 794
 795 sal_Int32 SAL_CALL ScaDateAddIn::getDiffYears(
 796         const uno::Reference< beans::XPropertySet >& xOptions,
 797         sal_Int32 nStartDate, sal_Int32 nEndDate,
 798         sal_Int32 nMode ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 799 {
 800     if ( nMode != 1 )
 801         return getDiffMonths( xOptions, nStartDate, nEndDate, nMode ) / 12;
 802
 803     sal_Int32 nNullDate = GetNullDate( xOptions );
 804
 805     sal_Int32 nDays1 = nStartDate + nNullDate;
 806     sal_Int32 nDays2 = nEndDate + nNullDate;
 807
 808     sal_uInt16 nDay1,nMonth1,nYear1;
 809     sal_uInt16 nDay2,nMonth2,nYear2;
 810     DaysToDate(nDays1,nDay1,nMonth1,nYear1);
 811     DaysToDate(nDays2,nDay2,nMonth2,nYear2);
 812
 813     return nYear2 - nYear1;
 814 }
 815
 816 /**
 817  * Check if a Date is in a leap year in the Gregorian calendar
 818  */
 819
 820 sal_Int32 SAL_CALL ScaDateAddIn::getIsLeapYear(
 821         const uno::Reference< beans::XPropertySet >& xOptions,
 822         sal_Int32 nDate ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 823 {
 824     sal_Int32 nNullDate = GetNullDate( xOptions );
 825     sal_Int32 nDays = nDate + nNullDate;
 826
 827     sal_uInt16 nDay, nMonth, nYear;
 828     DaysToDate(nDays,nDay,nMonth,nYear);
 829
 830     return (sal_Int32)IsLeapYear(nYear);
 831 }
 832
 833 /**
 834  * Get the Number of Days in the month for a date
 835  */
 836
 837 sal_Int32 SAL_CALL ScaDateAddIn::getDaysInMonth(
 838         const uno::Reference<beans::XPropertySet>& xOptions,
 839         sal_Int32 nDate ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 840 {
 841     sal_Int32 nNullDate = GetNullDate( xOptions );
 842     sal_Int32 nDays = nDate + nNullDate;
 843
 844     sal_uInt16 nDay, nMonth, nYear;
 845     DaysToDate(nDays,nDay,nMonth,nYear);
 846
 847     return DaysInMonth( nMonth, nYear );
 848 }
 849
 850 /**
 851  * Get number of days in the year of a date specified
 852  */
 853
 854 sal_Int32 SAL_CALL ScaDateAddIn::getDaysInYear(
 855         const uno::Reference< beans::XPropertySet >& xOptions,
 856         sal_Int32 nDate ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 857 {
 858     sal_Int32 nNullDate = GetNullDate( xOptions );
 859     sal_Int32 nDays = nDate + nNullDate;
 860
 861     sal_uInt16 nDay, nMonth, nYear;
 862     DaysToDate(nDays,nDay,nMonth,nYear);
 863
 864     return ( IsLeapYear(nYear) ? 366 : 365 );
 865 }
 866
 867 /**
 868  * Get number of weeks in the year for a date
 869  *
 870  * Most years have 52 weeks, but years that start on a Thursday
 871  * and leep years that start on a Wednesday have 53 weeks
 872  *
 873  * The International Standard IS-8601 has decreed that Monday
 874  * shall be the first day of the week.
 875  *
 876  * A WeekDay can be calculated by substracting 1 and calculating the rest of
 877  * a division by 7 from the internal date represention
 878  * which gives a 0 - 6 value for Monday - Sunday
 879  *
 880  * @see #IsLeapYear #WeekNumber
 881  */
 882
 883 sal_Int32 SAL_CALL ScaDateAddIn::getWeeksInYear(
 884         const uno::Reference< beans::XPropertySet >& xOptions,
 885         sal_Int32 nDate ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 886 {
 887     sal_Int32 nNullDate = GetNullDate( xOptions );
 888     sal_Int32 nDays = nDate + nNullDate;
 889
 890     sal_uInt16 nDay, nMonth, nYear;
 891     DaysToDate(nDays,nDay,nMonth,nYear);
 892
 893     sal_Int32 nJan1WeekDay = ( DateToDays(1,1,nYear) - 1) % 7;
 894
 895     sal_Int32 nRet;
 896     if ( nJan1WeekDay == 3 )        /* Thursday */
 897         nRet = 53;
 898     else if ( nJan1WeekDay == 2 )   /* Wednesday */
 899         nRet = ( IsLeapYear(nYear) ? 53 : 52 );
 900     else
 901         nRet = 52;
 902
 903     return nRet;
 904 }
 905
 906 /**
 907  * Encrypt or decrypt a string using ROT13 algorithm
 908  *
 909  * This function rotates each character by 13 in the alphabet.
 910  * Only the characters 'a' ... 'z' and 'A' ... 'Z' are modified.
 911  */
 912
 913 OUString SAL_CALL ScaDateAddIn::getRot13( const OUString& aSrcString ) throw( uno::RuntimeException, lang::IllegalArgumentException )
 914 {
 915     OUStringBuffer aBuffer( aSrcString );
 916     for( sal_Int32 nIndex = 0; nIndex < aBuffer.getLength(); nIndex++ )
 917     {
 918         sal_Unicode cChar = aBuffer[nIndex];
 919         if( ((cChar >= 'a') && (cChar <= 'z') && ((cChar += 13) > 'z')) ||
 920             ((cChar >= 'A') && (cChar <= 'Z') && ((cChar += 13) > 'Z')) )
 921             cChar -= 26;
 922         aBuffer[nIndex] = cChar;
 923     }
 924     return aBuffer.makeStringAndClear();
 925 }
 926
 927 //------------------------------------------------------------------
 928
 929 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */