unotools/source/i18n/calendarwrapper.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 #include <rtl/strbuf.hxx>
  22 #include <tools/string.hxx>
  23 #include <tools/debug.hxx>
  24 #include <unotools/calendarwrapper.hxx>
  25 #include <com/sun/star/i18n/CalendarFieldIndex.hpp>
  26 #include <com/sun/star/i18n/LocaleCalendar.hpp>
  27
  28 using namespace ::com::sun::star;
  29 using namespace ::com::sun::star::i18n;
  30 using namespace ::com::sun::star::uno;
  31
  32
  33 const double MILLISECONDS_PER_DAY = 1000.0 * 60.0 * 60.0 * 24.0;
  34
  35
  36 CalendarWrapper::CalendarWrapper(
  37             const Reference< uno::XComponentContext > & rxContext
  38             )
  39         :
  40         aEpochStart( Date( 1, 1, 1970 ) )
  41 {
  42     xC = LocaleCalendar::create(rxContext);
  43 }
  44
  45 CalendarWrapper::~CalendarWrapper()
  46 {
  47 }
  48
  49
  50 void CalendarWrapper::loadDefaultCalendar( const ::com::sun::star::lang::Locale& rLocale )
  51 {
  52     try
  53     {
  54         if ( xC.is() )
  55             xC->loadDefaultCalendar( rLocale );
  56     }
  57     catch (const Exception& e)
  58     {
  59         SAL_WARN( "unotools.i18n", "loadDefaultCalendar: Exception caught " << e.Message );
  60     }
  61 }
  62
  63
  64 void CalendarWrapper::loadCalendar( const OUString& rUniqueID, const ::com::sun::star::lang::Locale& rLocale )
  65 {
  66     try
  67     {
  68         if ( xC.is() )
  69             xC->loadCalendar( rUniqueID, rLocale );
  70     }
  71     catch (const Exception& e)
  72     {
  73         SAL_WARN( "unotools.i18n", "loadCalendar: Exception caught requested: "
  74             << rUniqueID << "   Locale: " << rLocale.Language << "_" << rLocale.Country << " " << e.Message );
  75     }
  76 }
  77
  78
  79 ::com::sun::star::uno::Sequence< OUString > CalendarWrapper::getAllCalendars( const ::com::sun::star::lang::Locale& rLocale ) const
  80 {
  81     try
  82     {
  83         if ( xC.is() )
  84             return xC->getAllCalendars( rLocale );
  85     }
  86     catch (const Exception& e)
  87     {
  88         SAL_WARN( "unotools.i18n", "getAllCalendars: Exception caught " << e.Message );
  89     }
  90
  91     return ::com::sun::star::uno::Sequence< OUString > (0);
  92 }
  93
  94
  95 OUString CalendarWrapper::getUniqueID() const
  96 {
  97     try
  98     {
  99         if ( xC.is() )
 100             return xC->getUniqueID();
 101     }
 102     catch (const Exception& e)
 103     {
 104         SAL_WARN( "unotools.i18n", "getUniqueID: Exception caught " << e.Message );
 105     }
 106     return OUString();
 107 }
 108
 109
 110 void CalendarWrapper::setDateTime( double nTimeInDays )
 111 {
 112     try
 113     {
 114         if ( xC.is() )
 115             xC->setDateTime( nTimeInDays );
 116     }
 117     catch (const Exception& e)
 118     {
 119         SAL_WARN( "unotools.i18n", "setDateTime: Exception caught " << e.Message );
 120     }
 121 }
 122
 123
 124 double CalendarWrapper::getDateTime() const
 125 {
 126     try
 127     {
 128         if ( xC.is() )
 129             return xC->getDateTime();
 130     }
 131     catch (const Exception& e)
 132     {
 133         SAL_WARN( "unotools.i18n", "getDateTime: Exception caught " << e.Message );
 134     }
 135     return 0.0;
 136 }
 137
 138
 139 sal_Int32 CalendarWrapper::getCombinedOffsetInMillis(
 140         sal_Int16 nParentFieldIndex, sal_Int16 nChildFieldIndex ) const
 141 {
 142     sal_Int32 nOffset = 0;
 143     try
 144     {
 145         if ( xC.is() )
 146         {
 147             nOffset = static_cast<sal_Int32>( xC->getValue( nParentFieldIndex )) * 60000;
 148             sal_Int16 nSecondMillis = xC->getValue( nChildFieldIndex );
 149             if (nOffset < 0)
 150                 nOffset -= static_cast<sal_uInt16>( nSecondMillis);
 151             else
 152                 nOffset += static_cast<sal_uInt16>( nSecondMillis);
 153         }
 154     }
 155     catch (const Exception& e)
 156     {
 157         SAL_WARN( "unotools.i18n", "setLocalDateTime: Exception caught " << e.Message );
 158     }
 159     return nOffset;
 160 }
 161
 162
 163 sal_Int32 CalendarWrapper::getZoneOffsetInMillis() const
 164 {
 165     return getCombinedOffsetInMillis( CalendarFieldIndex::ZONE_OFFSET,
 166             CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS);
 167 }
 168
 169
 170 sal_Int32 CalendarWrapper::getDSTOffsetInMillis() const
 171 {
 172     return getCombinedOffsetInMillis( CalendarFieldIndex::DST_OFFSET,
 173             CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS);
 174 }
 175
 176
 177 void CalendarWrapper::setLocalDateTime( double nTimeInDays )
 178 {
 179     try
 180     {
 181         if ( xC.is() )
 182         {
 183             // First set a nearby value to obtain the timezone and DST offset.
 184             // This is necessary to let ICU choose the corresponding
 185             // OlsonTimeZone transitions. Since ICU incorporates also
 186             // historical data even the timezone may differ for different
 187             // dates! (Which was the cause for #i76623# when the timezone of a
 188             // previously set date was used.) Timezone may also include
 189             // seconds, so use milliseconds field as well.
 190             xC->setDateTime( nTimeInDays );
 191             sal_Int32 nZone1 = getZoneOffsetInMillis();
 192             sal_Int32 nDST1  = getDSTOffsetInMillis();
 193             double nLoc = nTimeInDays - (double)(nZone1 + nDST1) / MILLISECONDS_PER_DAY;
 194             xC->setDateTime( nLoc );
 195             sal_Int32 nZone2 = getZoneOffsetInMillis();
 196             sal_Int32 nDST2  = getDSTOffsetInMillis();
 197             // If DSTs differ after calculation, we crossed boundaries. Do it
 198             // again, this time using the DST corrected initial value for the
 199             // real local time.
 200             // See also localtime/gmtime conversion pitfalls at
 201             // http://www.erack.de/download/timetest.c
 202             if ( nDST1 != nDST2 )
 203             {
 204                 nLoc = nTimeInDays - (double)(nZone2 + nDST2) / MILLISECONDS_PER_DAY;
 205                 xC->setDateTime( nLoc );
 206                 // #i17222# If the DST onset rule says to switch from 00:00 to
 207                 // 01:00 and we tried to set onsetDay 00:00 with DST, the
 208                 // result was onsetDay-1 23:00 and no DST, which is not what we
 209                 // want. So once again without DST, resulting in onsetDay
 210                 // 01:00 and DST. Yes, this seems to be weird, but logically
 211                 // correct.
 212                 sal_Int32 nDST3 = getDSTOffsetInMillis();
 213                 if ( nDST2 != nDST3 && !nDST3 )
 214                 {
 215                     nLoc = nTimeInDays - (double)(nZone2 + nDST3) / MILLISECONDS_PER_DAY;
 216                     xC->setDateTime( nLoc );
 217                 }
 218             }
 219         }
 220     }
 221     catch (const Exception& e)
 222     {
 223         SAL_WARN( "unotools.i18n",  "setLocalDateTime: Exception caught " << e.Message );
 224     }
 225 }
 226
 227
 228 double CalendarWrapper::getLocalDateTime() const
 229 {
 230     try
 231     {
 232         if ( xC.is() )
 233         {
 234             double nTimeInDays = xC->getDateTime();
 235             sal_Int32 nZone = getZoneOffsetInMillis();
 236             sal_Int32 nDST = getDSTOffsetInMillis();
 237             nTimeInDays += (double)(nZone + nDST) / MILLISECONDS_PER_DAY;
 238             return nTimeInDays;
 239         }
 240     }
 241     catch (const Exception& e)
 242     {
 243         SAL_WARN( "unotools.i18n",  "getLocalDateTime: Exception caught " << e.Message );
 244     }
 245     return 0.0;
 246 }
 247
 248
 249 void CalendarWrapper::setValue( sal_Int16 nFieldIndex, sal_Int16 nValue )
 250 {
 251     try
 252     {
 253         if ( xC.is() )
 254             xC->setValue( nFieldIndex, nValue );
 255     }
 256     catch (const Exception& e)
 257     {
 258         SAL_WARN( "unotools.i18n",  "setValue: Exception caught " << e.Message );
 259     }
 260 }
 261
 262
 263 sal_Bool CalendarWrapper::isValid() const
 264 {
 265     try
 266     {
 267         if ( xC.is() )
 268             return xC->isValid();
 269     }
 270     catch (const Exception& e)
 271     {
 272         SAL_WARN( "unotools.i18n",  "isValue: Exception caught " << e.Message );
 273     }
 274     return sal_False;
 275 }
 276
 277
 278 sal_Int16 CalendarWrapper::getValue( sal_Int16 nFieldIndex ) const
 279 {
 280     try
 281     {
 282         if ( xC.is() )
 283             return xC->getValue( nFieldIndex );
 284     }
 285     catch (const Exception& e)
 286     {
 287         SAL_WARN( "unotools.i18n", "getValue: Exception caught " << e.Message );
 288     }
 289     return 0;
 290 }
 291
 292
 293 void CalendarWrapper::addValue( sal_Int16 nFieldIndex, sal_Int32 nAmount )
 294 {
 295     try
 296     {
 297         if ( xC.is() )
 298             xC->addValue( nFieldIndex, nAmount );
 299     }
 300     catch (const Exception& e)
 301     {
 302         SAL_WARN( "unotools.i18n", "addValue: Exception caught " << e.Message );
 303     }
 304 }
 305
 306
 307 sal_Int16 CalendarWrapper::getFirstDayOfWeek() const
 308 {
 309     try
 310     {
 311         if ( xC.is() )
 312             return xC->getFirstDayOfWeek();
 313     }
 314     catch (const Exception& e)
 315     {
 316         SAL_WARN( "unotools.i18n", "getFirstDayOfWeek: Exception caught " << e.Message );
 317     }
 318     return 0;
 319 }
 320
 321
 322 sal_Int16 CalendarWrapper::getNumberOfMonthsInYear() const
 323 {
 324     try
 325     {
 326         if ( xC.is() )
 327             return xC->getNumberOfMonthsInYear();
 328     }
 329     catch (const Exception& e)
 330     {
 331         SAL_WARN( "unotools.i18n", "getNumberOfMonthsInYear: Exception caught " << e.Message );
 332     }
 333     return 0;
 334 }
 335
 336
 337 sal_Int16 CalendarWrapper::getNumberOfDaysInWeek() const
 338 {
 339     try
 340     {
 341         if ( xC.is() )
 342             return xC->getNumberOfDaysInWeek();
 343     }
 344     catch (const Exception& e)
 345     {
 346         SAL_WARN( "unotools.i18n", "getNumberOfDaysInWeek: Exception caught " << e.Message );
 347     }
 348     return 0;
 349 }
 350
 351
 352 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > CalendarWrapper::getMonths() const
 353 {
 354     try
 355     {
 356         if ( xC.is() )
 357             return xC->getMonths2();
 358     }
 359     catch (const Exception& e)
 360     {
 361         SAL_WARN( "unotools.i18n", "getMonths: Exception caught " << e.Message );
 362     }
 363     return ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > (0);
 364 }
 365
 366
 367 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > CalendarWrapper::getDays() const
 368 {
 369     try
 370     {
 371         if ( xC.is() )
 372             return xC->getDays2();
 373     }
 374     catch (const Exception& e)
 375     {
 376         SAL_WARN( "unotools.i18n", "getDays: Exception caught " << e.Message );
 377     }
 378     return ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > (0);
 379 }
 380
 381
 382 String CalendarWrapper::getDisplayName( sal_Int16 nCalendarDisplayIndex, sal_Int16 nIdx, sal_Int16 nNameType ) const
 383 {
 384     try
 385     {
 386         if ( xC.is() )
 387             return xC->getDisplayName( nCalendarDisplayIndex, nIdx, nNameType );
 388     }
 389     catch (const Exception& e)
 390     {
 391         SAL_WARN( "unotools.i18n", "getDisplayName: Exception caught " << e.Message );
 392     }
 393     return String();
 394 }
 395
 396
 397 // --- XExtendedCalendar -----------------------------------------------------
 398
 399 String CalendarWrapper::getDisplayString( sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode ) const
 400 {
 401     try
 402     {
 403         if ( xC.is() )
 404             return xC->getDisplayString( nCalendarDisplayCode, nNativeNumberMode );
 405     }
 406     catch (const Exception& e)
 407     {
 408         SAL_WARN( "unotools.i18n", "getDisplayString: Exception caught " << e.Message );
 409     }
 410     return String();
 411 }
 412
 413
 414 // --- XCalendar3 ------------------------------------------------------------
 415
 416 ::com::sun::star::i18n::Calendar2 CalendarWrapper::getLoadedCalendar() const
 417 {
 418     try
 419     {
 420         if ( xC.is() )
 421             return xC->getLoadedCalendar2();
 422     }
 423     catch (const Exception& e)
 424     {
 425         SAL_WARN( "unotools.i18n", "getLoadedCalendar2: Exception caught " << e.Message );
 426     }
 427     return ::com::sun::star::i18n::Calendar2();
 428 }
 429
 430
 431 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > CalendarWrapper::getGenitiveMonths() const
 432 {
 433     try
 434     {
 435         if ( xC.is() )
 436             return xC->getGenitiveMonths2();
 437     }
 438     catch (const Exception& e)
 439     {
 440         SAL_WARN( "unotools.i18n", "getGenitiveMonths: Exception caught " << e.Message );
 441     }
 442     return ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > (0);
 443 }
 444
 445
 446 ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > CalendarWrapper::getPartitiveMonths() const
 447 {
 448     try
 449     {
 450         if ( xC.is() )
 451             return xC->getPartitiveMonths2();
 452     }
 453     catch (const Exception& e)
 454     {
 455         SAL_WARN( "unotools.i18n", "getPartitiveMonths: Exception caught " << e.Message );
 456     }
 457     return ::com::sun::star::uno::Sequence< ::com::sun::star::i18n::CalendarItem2 > (0);
 458 }
 459
 460 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */