diff options
Diffstat (limited to 'i18npool/source/calendar')
| -rw-r--r-- | i18npool/source/calendar/calendarImpl.cxx | 324 | ||||
| -rw-r--r-- | i18npool/source/calendar/calendar_gregorian.cxx | 1098 | ||||
| -rw-r--r-- | i18npool/source/calendar/calendar_hijri.cxx | 341 | ||||
| -rw-r--r-- | i18npool/source/calendar/calendar_jewish.cxx | 306 | ||||
| -rw-r--r-- | i18npool/source/calendar/makefile.mk | 53 |
5 files changed, 2122 insertions, 0 deletions
diff --git a/i18npool/source/calendar/calendarImpl.cxx b/i18npool/source/calendar/calendarImpl.cxx new file mode 100644 index 000000000000..2d09d047c7cb --- /dev/null +++ b/i18npool/source/calendar/calendarImpl.cxx @@ -0,0 +1,324 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_i18npool.hxx" + +#include "calendarImpl.hxx" +#include "localedata.hxx" +#include <comphelper/processfactory.hxx> + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::i18n; +using namespace ::rtl; + +#define ERROR RuntimeException() + +CalendarImpl::CalendarImpl(const Reference< XMultiServiceFactory > &rxMSF) : xMSF(rxMSF) +{ +} + +CalendarImpl::~CalendarImpl() +{ + // Clear lookuptable + for (size_t l = 0; l < lookupTable.size(); l++) + delete lookupTable[l]; + lookupTable.clear(); +} + + +void SAL_CALL +CalendarImpl::loadDefaultCalendar( const Locale& rLocale ) throw(RuntimeException) +{ + Sequence< Calendar> xC = LocaleData().getAllCalendars(rLocale); + for (sal_Int32 i = 0; i < xC.getLength(); i++) { + if (xC[i].Default) { + loadCalendar(xC[i].Name, rLocale); + return; + } + } + throw ERROR; +} + +void SAL_CALL +CalendarImpl::loadCalendar(const OUString& uniqueID, const Locale& rLocale ) throw (RuntimeException) +{ + Reference < XExtendedCalendar > xOldCalendar( xCalendar ); // backup + sal_Int32 i; + + for (i = 0; i < sal::static_int_cast<sal_Int32>(lookupTable.size()); i++) { + lookupTableItem *listItem = lookupTable[i]; + if (uniqueID == listItem->uniqueID) { + xCalendar = listItem->xCalendar; + break; + } + } + + if (i >= sal::static_int_cast<sal_Int32>(lookupTable.size())) { + Reference < XInterface > xI = xMSF->createInstance( + OUString::createFromAscii("com.sun.star.i18n.Calendar_") + uniqueID); + + if ( ! xI.is() ) { + // check if the calendar is defined in localedata, load gregorian calendar service. + Sequence< Calendar> xC = LocaleData().getAllCalendars(rLocale); + for (i = 0; i < xC.getLength(); i++) { + if (uniqueID == xC[i].Name) { + xI = xMSF->createInstance( + OUString::createFromAscii("com.sun.star.i18n.Calendar_gregorian")); + break; + } + } + } + + if ( xI.is() ) + xI->queryInterface(::getCppuType((const Reference< XExtendedCalendar>*)0)) >>= xCalendar; + else + throw ERROR; + + lookupTable.push_back( new lookupTableItem(uniqueID, xCalendar) ); + } + + if ( !xCalendar.is() ) + { + xCalendar = xOldCalendar; + throw ERROR; + } + + try + { + xCalendar->loadCalendar(uniqueID, rLocale); + } + catch ( Exception& ) + { // restore previous calendar and re-throw + xCalendar = xOldCalendar; + throw; + } +} + +Calendar SAL_CALL +CalendarImpl::getLoadedCalendar() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getLoadedCalendar(); + else + throw ERROR ; +} + +Sequence< OUString > SAL_CALL +CalendarImpl::getAllCalendars( const Locale& rLocale ) throw(RuntimeException) +{ + Sequence< Calendar> xC = LocaleData().getAllCalendars(rLocale); + sal_Int32 nLen = xC.getLength(); + Sequence< OUString > xSeq( nLen ); + for (sal_Int32 i = 0; i < nLen; i++) + xSeq[i] = xC[i].Name; + return xSeq; +} + +void SAL_CALL +CalendarImpl::setDateTime( double timeInDays ) throw(RuntimeException) +{ + if (xCalendar.is()) + xCalendar->setDateTime( timeInDays ); + else + throw ERROR ; +} + +double SAL_CALL +CalendarImpl::getDateTime() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getDateTime(); + else + throw ERROR ; +} + +OUString SAL_CALL +CalendarImpl::getUniqueID() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getUniqueID(); + else + throw ERROR ; +} + +void SAL_CALL +CalendarImpl::setValue( sal_Int16 fieldIndex, sal_Int16 value ) throw(RuntimeException) +{ + if (xCalendar.is()) + xCalendar->setValue( fieldIndex, value ); + else + throw ERROR ; +} + +sal_Int16 SAL_CALL +CalendarImpl::getValue( sal_Int16 fieldIndex ) throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getValue( fieldIndex ); + else + throw ERROR ; +} + +void SAL_CALL +CalendarImpl::addValue( sal_Int16 fieldIndex, sal_Int32 amount ) throw(RuntimeException) +{ + if (xCalendar.is()) + xCalendar->addValue( fieldIndex, amount); + else + throw ERROR ; +} + +sal_Int16 SAL_CALL +CalendarImpl::getFirstDayOfWeek() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getFirstDayOfWeek(); + else + throw ERROR ; +} + +void SAL_CALL +CalendarImpl::setFirstDayOfWeek( sal_Int16 day ) +throw(RuntimeException) +{ + if (xCalendar.is()) + xCalendar->setFirstDayOfWeek(day); + else + throw ERROR ; +} + +void SAL_CALL +CalendarImpl::setMinimumNumberOfDaysForFirstWeek( sal_Int16 days ) throw(RuntimeException) +{ + if (xCalendar.is()) + xCalendar->setMinimumNumberOfDaysForFirstWeek(days); + else + throw ERROR ; +} + +sal_Int16 SAL_CALL +CalendarImpl::getMinimumNumberOfDaysForFirstWeek() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getMinimumNumberOfDaysForFirstWeek(); + else + throw ERROR ; +} + + +OUString SAL_CALL +CalendarImpl::getDisplayName( sal_Int16 displayIndex, sal_Int16 idx, sal_Int16 nameType ) throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getDisplayName( displayIndex, idx, nameType ); + else + throw ERROR ; +} + +sal_Int16 SAL_CALL +CalendarImpl::getNumberOfMonthsInYear() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getNumberOfMonthsInYear(); + else + throw ERROR ; +} + + +sal_Int16 SAL_CALL +CalendarImpl::getNumberOfDaysInWeek() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getNumberOfDaysInWeek(); + else + throw ERROR ; +} + + +Sequence< CalendarItem > SAL_CALL +CalendarImpl::getMonths() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getMonths(); + else + throw ERROR ; +} + + +Sequence< CalendarItem > SAL_CALL +CalendarImpl::getDays() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getDays(); + else + throw ERROR ; +} + + +sal_Bool SAL_CALL +CalendarImpl::isValid() throw(RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->isValid(); + else + throw ERROR ; +} + +OUString SAL_CALL +CalendarImpl::getDisplayString( sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode ) + throw (RuntimeException) +{ + if (xCalendar.is()) + return xCalendar->getDisplayString(nCalendarDisplayCode, nNativeNumberMode); + else + throw ERROR ; +} + +OUString SAL_CALL +CalendarImpl::getImplementationName(void) throw( RuntimeException ) +{ + return OUString::createFromAscii("com.sun.star.i18n.CalendarImpl"); +} + +const sal_Char cCalendar[] = "com.sun.star.i18n.LocaleCalendar"; + +sal_Bool SAL_CALL +CalendarImpl::supportsService(const OUString& rServiceName) throw( RuntimeException ) +{ + return !rServiceName.compareToAscii(cCalendar); +} + +Sequence< OUString > SAL_CALL +CalendarImpl::getSupportedServiceNames(void) throw( RuntimeException ) +{ + Sequence< OUString > aRet(1); + aRet[0] = OUString::createFromAscii(cCalendar); + return aRet; +} + diff --git a/i18npool/source/calendar/calendar_gregorian.cxx b/i18npool/source/calendar/calendar_gregorian.cxx new file mode 100644 index 000000000000..727a6f601ba3 --- /dev/null +++ b/i18npool/source/calendar/calendar_gregorian.cxx @@ -0,0 +1,1098 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_i18npool.hxx" + +#include "calendar_gregorian.hxx" +#include "localedata.hxx" +#include <com/sun/star/i18n/AmPmValue.hpp> +#include <com/sun/star/i18n/Months.hpp> +#include <com/sun/star/i18n/Weekdays.hpp> +#include <com/sun/star/i18n/reservedWords.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <comphelper/processfactory.hxx> + +#include <stdio.h> +#include <string.h> + +#define erDUMP_ICU_CALENDAR 0 +#define erDUMP_I18N_CALENDAR 0 +#if erDUMP_ICU_CALENDAR || erDUMP_I18N_CALENDAR +// If both are used, DUMP_ICU_CAL_MSG() must be used before DUMP_I18N_CAL_MSG() +// to obtain internally set values from ICU, else Calendar::get() calls in +// DUMP_I18N_CAL_MSG() recalculate! + +// These pieces of macro are shamelessly borrowed from icu's olsontz.cpp, the +// double parens'ed approach to pass multiple parameters as one macro parameter +// is appealing. +static void debug_cal_loc(const char *f, int32_t l) +{ + fprintf(stderr, "%s:%d: ", f, l); +} +# include <stdarg.h> +static void debug_cal_msg(const char *pat, ...) +{ + va_list ap; + va_start(ap, pat); + vfprintf(stderr, pat, ap); +} + +#if erDUMP_ICU_CALENDAR +// Make icu with +// DEFS = -DU_DEBUG_CALSVC -DUCAL_DEBUG_DUMP +// in icu/$(INPATH)/misc/build/icu/source/icudefs.mk +// May need some patches to fix unmaintained things there. +extern void ucal_dump( const icu::Calendar & ); +static void debug_icu_cal_dump( const ::icu::Calendar & r ) +{ + ucal_dump(r); + fflush(stderr); + // set a breakpoint here to pause display between dumps +} +// must use double parens, i.e.: DUMP_ICU_CAL_MSG(("four is: %d",4)); +#define DUMP_ICU_CAL_MSG(x) {debug_cal_loc(__FILE__,__LINE__);debug_cal_msg x;debug_icu_cal_dump(*body);} +#else // erDUMP_ICU_CALENDAR +#define DUMP_ICU_CAL_MSG(x) +#endif // erDUMP_ICU_CALENDAR + +#if erDUMP_I18N_CALENDAR +static void debug_cal_millis_to_time( long nMillis, long & h, long & m, long & s, long & f ) +{ + int sign = (nMillis < 0 ? -1 : 1); + nMillis = ::std::abs(nMillis); + h = sign * nMillis / (60 * 60 * 1000); + nMillis -= sign * h * (60 * 60 * 1000); + m = nMillis / (60 * 1000); + nMillis -= m * (60 * 1000); + s = nMillis / (1000); + nMillis -= s * (1000); + f = nMillis; +} +static void debug_i18n_cal_dump( const ::icu::Calendar & r ) +{ + UErrorCode status; + long nMillis, h, m, s, f; + fprintf( stderr, " %04ld", (long)r.get( UCAL_YEAR, status = U_ZERO_ERROR)); + fprintf( stderr, "-%02ld", (long)r.get( UCAL_MONTH, status = U_ZERO_ERROR)+1); + fprintf( stderr, "-%02ld", (long)r.get( UCAL_DATE, status = U_ZERO_ERROR)); + fprintf( stderr, " %02ld", (long)r.get( UCAL_HOUR_OF_DAY, status = U_ZERO_ERROR)); + fprintf( stderr, ":%02ld", (long)r.get( UCAL_MINUTE, status = U_ZERO_ERROR)); + fprintf( stderr, ":%02ld", (long)r.get( UCAL_SECOND, status = U_ZERO_ERROR)); + fprintf( stderr, " zone: %ld", (long)(nMillis = r.get( UCAL_ZONE_OFFSET, status = U_ZERO_ERROR))); + fprintf( stderr, " (%f min)", (double)nMillis / 60000); + debug_cal_millis_to_time( nMillis, h, m, s, f); + fprintf( stderr, " (%ld:%02ld:%02ld.%ld)", h, m, s, f); + fprintf( stderr, " DST: %ld", (long)(nMillis = r.get( UCAL_DST_OFFSET, status = U_ZERO_ERROR))); + fprintf( stderr, " (%f min)", (double)nMillis / 60000); + debug_cal_millis_to_time( nMillis, h, m, s, f); + fprintf( stderr, " (%ld:%02ld:%02ld.%ld)", h, m, s, f); + fprintf( stderr, "\n"); + fflush(stderr); +} +// must use double parens, i.e.: DUMP_I18N_CAL_MSG(("four is: %d",4)); +#define DUMP_I18N_CAL_MSG(x) {debug_cal_loc(__FILE__,__LINE__);debug_cal_msg x;debug_i18n_cal_dump(*body);} +#else // erDUMP_I18N_CALENDAR +#define DUMP_I18N_CAL_MSG(x) +#endif // erDUMP_I18N_CALENDAR + +#else // erDUMP_ICU_CALENDAR || erDUMP_I18N_CALENDAR +#define DUMP_ICU_CAL_MSG(x) +#define DUMP_I18N_CAL_MSG(x) +#endif // erDUMP_ICU_CALENDAR || erDUMP_I18N_CALENDAR + + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::i18n; +using namespace ::rtl; + +#define ERROR RuntimeException() + +Calendar_gregorian::Calendar_gregorian() +{ + init(NULL); +} +Calendar_gregorian::Calendar_gregorian(Era *_earArray) +{ + init(_earArray); +} +void SAL_CALL +Calendar_gregorian::init(Era *_eraArray) +{ + cCalendar = "com.sun.star.i18n.Calendar_gregorian"; + + // #i102356# With icu::Calendar::createInstance(UErrorCode) in a Thai + // th_TH system locale we accidentally used a Buddhist calendar. Though + // the ICU documentation says that should be the case only for + // th_TH_TRADITIONAL (and ja_JP_TRADITIONAL Gengou), a plain th_TH + // already triggers that behavior, ja_JP does not. Strange enough, + // passing a th_TH locale to the calendar creation doesn't trigger + // this. + // See also http://userguide.icu-project.org/datetime/calendar + + // Whatever ICU offers as the default calendar for a locale, ensure we + // have a Gregorian calendar as requested. + + /* XXX: with the current implementation the aLocale member variable is + * not set prior to loading a calendar from locale data. This + * creates an empty (root) locale for ICU, but at least the correct + * calendar is used. The language part must not be NULL (respectively + * not all, language and country and variant), otherwise the current + * default locale would be used again and the calendar keyword ignored. + * */ + icu::Locale aIcuLocale( "", NULL, NULL, "calendar=gregorian"); + + UErrorCode status; + body = icu::Calendar::createInstance( aIcuLocale, status = U_ZERO_ERROR); + if (!body || !U_SUCCESS(status)) throw ERROR; + +#if 0 + { + icu::Locale loc; + loc = body->getLocale( ULOC_ACTUAL_LOCALE, status = U_ZERO_ERROR); + fprintf( stderr, "\nICU calendar actual locale: %s\n", loc.getName()); + loc = body->getLocale( ULOC_VALID_LOCALE, status = U_ZERO_ERROR); + fprintf( stderr, "ICU calendar valid locale: %s\n", loc.getName()); + } +#endif + + eraArray=_eraArray; +} + +Calendar_gregorian::~Calendar_gregorian() +{ + delete body; +} + +Calendar_hanja::Calendar_hanja() +{ + cCalendar = "com.sun.star.i18n.Calendar_hanja"; +} + +OUString SAL_CALL +Calendar_hanja::getDisplayName( sal_Int16 displayIndex, sal_Int16 idx, sal_Int16 nameType ) throw(RuntimeException) +{ + if ( displayIndex == CalendarDisplayIndex::AM_PM ) { + // Am/Pm string for Korean Hanja calendar will refer to Japanese locale + com::sun::star::lang::Locale jaLocale = + com::sun::star::lang::Locale(OUString::createFromAscii("ja"), OUString(), OUString()); + if (idx == 0) return LocaleData().getLocaleItem(jaLocale).timeAM; + else if (idx == 1) return LocaleData().getLocaleItem(jaLocale).timePM; + else throw ERROR; + } + else + return Calendar_gregorian::getDisplayName( displayIndex, idx, nameType ); +} + +void SAL_CALL +Calendar_hanja::loadCalendar( const OUString& /*uniqueID*/, const com::sun::star::lang::Locale& rLocale ) throw(RuntimeException) +{ + // Since this class could be called by service name 'hanja_yoil', we have to + // rename uniqueID to get right calendar defined in locale data. + Calendar_gregorian::loadCalendar(OUString::createFromAscii("hanja"), rLocale); +} + +static Era gengou_eraArray[] = { + {1868, 1, 1}, + {1912, 7, 30}, + {1926, 12, 25}, + {1989, 1, 8}, + {0, 0, 0} +}; +Calendar_gengou::Calendar_gengou() : Calendar_gregorian(gengou_eraArray) +{ + cCalendar = "com.sun.star.i18n.Calendar_gengou"; +} + +static Era ROC_eraArray[] = { + {1912, 1, 1}, + {0, 0, 0} +}; +Calendar_ROC::Calendar_ROC() : Calendar_gregorian(ROC_eraArray) +{ + cCalendar = "com.sun.star.i18n.Calendar_ROC"; +} + +static Era buddhist_eraArray[] = { + {-542, 1, 1}, + {0, 0, 0} +}; +Calendar_buddhist::Calendar_buddhist() : Calendar_gregorian(buddhist_eraArray) +{ + cCalendar = "com.sun.star.i18n.Calendar_buddhist"; +} + +void SAL_CALL +Calendar_gregorian::loadCalendar( const OUString& uniqueID, const com::sun::star::lang::Locale& rLocale ) throw(RuntimeException) +{ + // init. fieldValue[] + getValue(); + + aLocale = rLocale; + Sequence< Calendar> xC = LocaleData().getAllCalendars(rLocale); + for (sal_Int32 i = 0; i < xC.getLength(); i++) + { + if (uniqueID == xC[i].Name) + { + aCalendar = xC[i]; + // setup minimalDaysInFirstWeek + setMinimumNumberOfDaysForFirstWeek( + aCalendar.MinimumNumberOfDaysForFirstWeek); + // setup first day of week + for (sal_Int16 day = sal::static_int_cast<sal_Int16>( + aCalendar.Days.getLength()-1); day>=0; day--) + { + if (aCalendar.StartOfWeek == aCalendar.Days[day].ID) + { + setFirstDayOfWeek( day); + return; + } + } + } + } + // Calendar is not for the locale + throw ERROR; +} + + +com::sun::star::i18n::Calendar SAL_CALL +Calendar_gregorian::getLoadedCalendar() throw(RuntimeException) +{ + return aCalendar; +} + +OUString SAL_CALL +Calendar_gregorian::getUniqueID() throw(RuntimeException) +{ + return aCalendar.Name; +} + +void SAL_CALL +Calendar_gregorian::setDateTime( double timeInDays ) throw(RuntimeException) +{ + UErrorCode status; + body->setTime(timeInDays * U_MILLIS_PER_DAY, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) throw ERROR; + getValue(); +} + +double SAL_CALL +Calendar_gregorian::getDateTime() throw(RuntimeException) +{ + if (fieldSet) { + setValue(); + getValue(); + } + UErrorCode status; + double r = body->getTime(status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) throw ERROR; + return r / U_MILLIS_PER_DAY; +} + +// map field value from gregorian calendar to other calendar, it can be overwritten by derived class. +// By using eraArray, it can take care Japanese and Taiwan ROC calendar. +void Calendar_gregorian::mapFromGregorian() throw(RuntimeException) +{ + if (eraArray) { + sal_Int16 e, y, m, d; + + e = fieldValue[CalendarFieldIndex::ERA]; + y = fieldValue[CalendarFieldIndex::YEAR]; + m = fieldValue[CalendarFieldIndex::MONTH] + 1; + d = fieldValue[CalendarFieldIndex::DAY_OF_MONTH]; + + // since the year is reversed for first era, it is reversed again here for Era compare. + if (e == 0) + y = 1 - y; + + for (e = 0; eraArray[e].year; e++) + if ((y != eraArray[e].year) ? y < eraArray[e].year : + (m != eraArray[e].month) ? m < eraArray[e].month : d < eraArray[e].day) + break; + + fieldValue[CalendarFieldIndex::ERA] = e; + fieldValue[CalendarFieldIndex::YEAR] = + sal::static_int_cast<sal_Int16>( (e == 0) ? (eraArray[0].year - y) : (y - eraArray[e-1].year + 1) ); + } +} + +#define FIELDS ((1 << CalendarFieldIndex::ERA) | (1 << CalendarFieldIndex::YEAR)) +// map field value from other calendar to gregorian calendar, it can be overwritten by derived class. +// By using eraArray, it can take care Japanese and Taiwan ROC calendar. +void Calendar_gregorian::mapToGregorian() throw(RuntimeException) +{ + if (eraArray && (fieldSet & FIELDS)) { + sal_Int16 y, e = fieldValue[CalendarFieldIndex::ERA]; + if (e == 0) + y = sal::static_int_cast<sal_Int16>( eraArray[0].year - fieldValue[CalendarFieldIndex::YEAR] ); + else + y = sal::static_int_cast<sal_Int16>( eraArray[e-1].year + fieldValue[CalendarFieldIndex::YEAR] - 1 ); + + fieldSetValue[CalendarFieldIndex::ERA] = y <= 0 ? 0 : 1; + fieldSetValue[CalendarFieldIndex::YEAR] = (y <= 0 ? 1 - y : y); + fieldSet |= FIELDS; + } +} + +static UCalendarDateFields fieldNameConverter(sal_Int16 fieldIndex) throw(RuntimeException) +{ + UCalendarDateFields f; + + switch (fieldIndex) { + case CalendarFieldIndex::AM_PM: f = UCAL_AM_PM; break; + case CalendarFieldIndex::DAY_OF_MONTH: f = UCAL_DATE; break; + case CalendarFieldIndex::DAY_OF_WEEK: f = UCAL_DAY_OF_WEEK; break; + case CalendarFieldIndex::DAY_OF_YEAR: f = UCAL_DAY_OF_YEAR; break; + case CalendarFieldIndex::DST_OFFSET: f = UCAL_DST_OFFSET; break; + case CalendarFieldIndex::ZONE_OFFSET: f = UCAL_ZONE_OFFSET; break; + case CalendarFieldIndex::HOUR: f = UCAL_HOUR_OF_DAY; break; + case CalendarFieldIndex::MINUTE: f = UCAL_MINUTE; break; + case CalendarFieldIndex::SECOND: f = UCAL_SECOND; break; + case CalendarFieldIndex::MILLISECOND: f = UCAL_MILLISECOND; break; + case CalendarFieldIndex::WEEK_OF_MONTH: f = UCAL_WEEK_OF_MONTH; break; + case CalendarFieldIndex::WEEK_OF_YEAR: f = UCAL_WEEK_OF_YEAR; break; + case CalendarFieldIndex::YEAR: f = UCAL_YEAR; break; + case CalendarFieldIndex::MONTH: f = UCAL_MONTH; break; + case CalendarFieldIndex::ERA: f = UCAL_ERA; break; + default: throw ERROR; + } + return f; +} + +void SAL_CALL +Calendar_gregorian::setValue( sal_Int16 fieldIndex, sal_Int16 value ) throw(RuntimeException) +{ + if (fieldIndex < 0 || FIELD_INDEX_COUNT <= fieldIndex) + throw ERROR; + fieldSet |= (1 << fieldIndex); + fieldValue[fieldIndex] = value; +} + +bool Calendar_gregorian::getCombinedOffset( sal_Int32 & o_nOffset, + sal_Int16 nParentFieldIndex, sal_Int16 nChildFieldIndex ) const +{ + o_nOffset = 0; + bool bFieldsSet = false; + if (fieldSet & (1 << nParentFieldIndex)) + { + bFieldsSet = true; + o_nOffset = static_cast<sal_Int32>( fieldValue[nParentFieldIndex]) * 60000; + } + if (fieldSet & (1 << nChildFieldIndex)) + { + bFieldsSet = true; + if (o_nOffset < 0) + o_nOffset -= static_cast<sal_uInt16>( fieldValue[nChildFieldIndex]); + else + o_nOffset += static_cast<sal_uInt16>( fieldValue[nChildFieldIndex]); + } + return bFieldsSet; +} + +bool Calendar_gregorian::getZoneOffset( sal_Int32 & o_nOffset ) const +{ + return getCombinedOffset( o_nOffset, CalendarFieldIndex::ZONE_OFFSET, + CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS); +} + +bool Calendar_gregorian::getDSTOffset( sal_Int32 & o_nOffset ) const +{ + return getCombinedOffset( o_nOffset, CalendarFieldIndex::DST_OFFSET, + CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS); +} + +void Calendar_gregorian::submitFields() throw(com::sun::star::uno::RuntimeException) +{ + for (sal_Int16 fieldIndex = 0; fieldIndex < FIELD_INDEX_COUNT; fieldIndex++) + { + if (fieldSet & (1 << fieldIndex)) + { + switch (fieldIndex) + { + default: + body->set(fieldNameConverter(fieldIndex), fieldSetValue[fieldIndex]); + break; + case CalendarFieldIndex::ZONE_OFFSET: + case CalendarFieldIndex::DST_OFFSET: + case CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS: + case CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS: + break; // nothing, extra handling + } + } + } + sal_Int32 nZoneOffset, nDSTOffset; + if (getZoneOffset( nZoneOffset)) + body->set( fieldNameConverter( CalendarFieldIndex::ZONE_OFFSET), nZoneOffset); + if (getDSTOffset( nDSTOffset)) + body->set( fieldNameConverter( CalendarFieldIndex::DST_OFFSET), nDSTOffset); +} + +void Calendar_gregorian::submitValues( sal_Int32 nYear, + sal_Int32 nMonth, sal_Int32 nDay, sal_Int32 nHour, sal_Int32 nMinute, + sal_Int32 nSecond, sal_Int32 nMilliSecond, sal_Int32 nZone, sal_Int32 nDST ) + throw(com::sun::star::uno::RuntimeException) +{ + submitFields(); + if (nYear >= 0) + body->set( UCAL_YEAR, nYear); + if (nMonth >= 0) + body->set( UCAL_MONTH, nMonth); + if (nDay >= 0) + body->set( UCAL_DATE, nDay); + if (nHour >= 0) + body->set( UCAL_HOUR_OF_DAY, nHour); + if (nMinute >= 0) + body->set( UCAL_MINUTE, nMinute); + if (nSecond >= 0) + body->set( UCAL_SECOND, nSecond); + if (nMilliSecond >= 0) + body->set( UCAL_MILLISECOND, nMilliSecond); + if (nZone != 0) + body->set( UCAL_ZONE_OFFSET, nZone); + if (nDST != 0) + body->set( UCAL_DST_OFFSET, nDST); +} + +static void lcl_setCombinedOffsetFieldValues( sal_Int32 nValue, + sal_Int16 rFieldSetValue[], sal_Int16 rFieldValue[], + sal_Int16 nParentFieldIndex, sal_Int16 nChildFieldIndex ) +{ + sal_Int32 nTrunc = nValue / 60000; + rFieldSetValue[nParentFieldIndex] = rFieldValue[nParentFieldIndex] = + static_cast<sal_Int16>( nTrunc); + sal_uInt16 nMillis = static_cast<sal_uInt16>( abs( nValue - nTrunc * 60000)); + rFieldSetValue[nChildFieldIndex] = rFieldValue[nChildFieldIndex] = + static_cast<sal_Int16>( nMillis); +} + +void Calendar_gregorian::setValue() throw(RuntimeException) +{ + // Correct DST glitch, see also localtime/gmtime conversion pitfalls at + // http://www.erack.de/download/timetest.c + // + // #i24082# in order to make the DST correction work in all + // circumstances, the time values have to be always resubmitted, + // regardless whether specified by the caller or not. It is not + // sufficient to rely on the ICU internal values previously set, as the + // following may happen: + // - Let 2004-03-28T02:00 be the onsetRule. + // - On 2004-03-29 (calendar initialized with 2004-03-29T00:00 DST) set + // a date of 2004-03-28 => calendar results in 2004-03-27T23:00 no DST. + // - Correcting this with simply "2004-03-28 no DST" and no time + // specified results in 2004-03-29T00:00, the ICU internal 23:00 time + // being adjusted to 24:00 in this case, switching one day further. + // => submit 2004-03-28T00:00 no DST. + + // This got even weirder since ICU incorporated also historical data, + // even the timezone may differ for different dates! It is necessary to + // let ICU choose the corresponding OlsonTimeZone transitions and adapt + // values. + // #i86094# gives examples where that went wrong: + // TZ=Europe/Moscow date <= 1919-07-01 + // zone +2:30:48 (!) instead of +3h, DST +2h instead of +1h + // TZ=America/St_Johns date <= 1935-03-30 + // zone -3:30:52 (!) instead of -3:30 + + // Copy fields before calling submitFields() directly or indirectly below. + memcpy(fieldSetValue, fieldValue, sizeof(fieldSetValue)); + // Possibly setup ERA and YEAR in fieldSetValue. + mapToGregorian(); + + DUMP_ICU_CAL_MSG(("%s\n","setValue() before any submission")); + DUMP_I18N_CAL_MSG(("%s\n","setValue() before any submission")); + + bool bNeedZone = !(fieldSet & (1 << CalendarFieldIndex::ZONE_OFFSET)); + bool bNeedDST = !(fieldSet & (1 << CalendarFieldIndex::DST_OFFSET)); + sal_Int32 nZone1, nDST1, nYear, nMonth, nDay, nHour, nMinute, nSecond, nMilliSecond, nZone0, nDST0; + nZone1 = nDST1 = nZone0 = nDST0 = 0; + nYear = nMonth = nDay = nHour = nMinute = nSecond = nMilliSecond = -1; + if ( bNeedZone || bNeedDST ) + { + UErrorCode status; + if ( !(fieldSet & (1 << CalendarFieldIndex::YEAR)) ) + { + nYear = body->get( UCAL_YEAR, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nYear = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::MONTH)) ) + { + nMonth = body->get( UCAL_MONTH, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nMonth = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::DAY_OF_MONTH)) ) + { + nDay = body->get( UCAL_DATE, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nDay = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::HOUR)) ) + { + nHour = body->get( UCAL_HOUR_OF_DAY, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nHour = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::MINUTE)) ) + { + nMinute = body->get( UCAL_MINUTE, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nMinute = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::SECOND)) ) + { + nSecond = body->get( UCAL_SECOND, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nSecond = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::MILLISECOND)) ) + { + nMilliSecond = body->get( UCAL_MILLISECOND, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nMilliSecond = -1; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::ZONE_OFFSET)) ) + { + nZone0 = body->get( UCAL_ZONE_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nZone0 = 0; + } + if ( !(fieldSet & (1 << CalendarFieldIndex::DST_OFFSET)) ) + { + nDST0 = body->get( UCAL_DST_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nDST0 = 0; + } + + // Submit values to obtain a time zone and DST corresponding to the date/time. + submitValues( nYear, nMonth, nDay, nHour, nMinute, nSecond, nMilliSecond, nZone0, nDST0); + + DUMP_ICU_CAL_MSG(("%s\n","setValue() in bNeedZone||bNeedDST after submitValues()")); + DUMP_I18N_CAL_MSG(("%s\n","setValue() in bNeedZone||bNeedDST after submitValues()")); + nZone1 = body->get( UCAL_ZONE_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nZone1 = 0; + nDST1 = body->get( UCAL_DST_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nDST1 = 0; + } + + // The original submission, may lead to a different zone/DST and + // different date. + submitFields(); + DUMP_ICU_CAL_MSG(("%s\n","setValue() after original submission")); + DUMP_I18N_CAL_MSG(("%s\n","setValue() after original submission")); + + if ( bNeedZone || bNeedDST ) + { + UErrorCode status; + sal_Int32 nZone2 = body->get( UCAL_ZONE_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nZone2 = nZone1; + sal_Int32 nDST2 = body->get( UCAL_DST_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nDST2 = nDST1; + if ( nZone0 != nZone1 || nZone2 != nZone1 || nDST0 != nDST1 || nDST2 != nDST1 ) + { + // Due to different DSTs, resulting date values may differ if + // DST is onset at 00:00 and the very onsetRule date was + // submitted with DST off => date-1 23:00, for example, which + // is not what we want. + // Resubmit all values, this time including DST => date 01:00 + // Similar for zone differences. + // If already the first full submission with nZone0 and nDST0 + // lead to date-1 23:00, the original submission was based on + // that date if it wasn't a full date (nDST0 set, nDST1 not + // set, nDST2==nDST1). If it was January 1st without year we're + // even off by one year now. Resubmit all values including new + // DST => date 00:00. + + // Set field values accordingly in case they were used. + if (!bNeedZone) + lcl_setCombinedOffsetFieldValues( nZone2, fieldSetValue, + fieldValue, CalendarFieldIndex::ZONE_OFFSET, + CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS); + if (!bNeedDST) + lcl_setCombinedOffsetFieldValues( nDST2, fieldSetValue, + fieldValue, CalendarFieldIndex::DST_OFFSET, + CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS); + submitValues( nYear, nMonth, nDay, nHour, nMinute, nSecond, nMilliSecond, nZone2, nDST2); + DUMP_ICU_CAL_MSG(("%s\n","setValue() after Zone/DST glitch resubmit")); + DUMP_I18N_CAL_MSG(("%s\n","setValue() after Zone/DST glitch resubmit")); + + // Time zone transition => resubmit. + // TZ=America/St_Johns date <= 1935-03-30 + // -3:30:52 (!) instead of -3:30 + // if first submission included time zone -3:30 that would be wrong. + bool bResubmit = false; + sal_Int32 nZone3 = body->get( UCAL_ZONE_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nZone3 = nZone2; + if (nZone3 != nZone2) + { + bResubmit = true; + if (!bNeedZone) + lcl_setCombinedOffsetFieldValues( nZone3, fieldSetValue, + fieldValue, CalendarFieldIndex::ZONE_OFFSET, + CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS); + } + + // If the DST onset rule says to switch from 00:00 to 01:00 and + // we tried to set onsetDay 00:00 with DST, the result was + // onsetDay-1 23:00 and no DST, which is not what we want. So + // once again without DST, resulting in onsetDay 01:00 and DST. + // Yes, this seems to be weird, but logically correct. + // It doesn't even have to be on an onsetDay as the DST is + // factored in all days by ICU and there seems to be some + // unknown behavior. + // TZ=Asia/Tehran 1999-03-22 exposes this, for example. + sal_Int32 nDST3 = body->get( UCAL_DST_OFFSET, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) + nDST3 = nDST2; + if (nDST2 != nDST3 && !nDST3) + { + bResubmit = true; + if (!bNeedDST) + { + fieldSetValue[CalendarFieldIndex::DST_OFFSET] = + fieldValue[CalendarFieldIndex::DST_OFFSET] = 0; + fieldSetValue[CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS] = + fieldValue[CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS] = 0; + } + } + if (bResubmit) + { + submitValues( nYear, nMonth, nDay, nHour, nMinute, nSecond, nMilliSecond, nZone3, nDST3); + DUMP_ICU_CAL_MSG(("%s\n","setValue() after Zone/DST glitch 2nd resubmit")); + DUMP_I18N_CAL_MSG(("%s\n","setValue() after Zone/DST glitch 2nd resubmit")); + } + } + } +#if erDUMP_ICU_CALENDAR || erDUMP_I18N_CALENDAR + { + // force icu::Calendar to recalculate + UErrorCode status; + sal_Int32 nTmp = body->get( UCAL_DATE, status = U_ZERO_ERROR); + DUMP_ICU_CAL_MSG(("%s: %d\n","setValue() result day",nTmp)); + DUMP_I18N_CAL_MSG(("%s: %d\n","setValue() result day",nTmp)); + } +#endif +} + +void Calendar_gregorian::getValue() throw(RuntimeException) +{ + DUMP_ICU_CAL_MSG(("%s\n","getValue()")); + DUMP_I18N_CAL_MSG(("%s\n","getValue()")); + for (sal_Int16 fieldIndex = 0; fieldIndex < FIELD_INDEX_COUNT; fieldIndex++) + { + if (fieldIndex == CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS || + fieldIndex == CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS) + continue; // not ICU fields + + UErrorCode status; sal_Int32 value = body->get( fieldNameConverter( + fieldIndex), status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) throw ERROR; + + // Convert millisecond to minute for ZONE and DST and set remainder in + // second field. + if (fieldIndex == CalendarFieldIndex::ZONE_OFFSET) + { + sal_Int32 nMinutes = value / 60000; + sal_Int16 nMillis = static_cast<sal_Int16>( static_cast<sal_uInt16>( + abs( value - nMinutes * 60000))); + fieldValue[CalendarFieldIndex::ZONE_OFFSET] = static_cast<sal_Int16>( nMinutes); + fieldValue[CalendarFieldIndex::ZONE_OFFSET_SECOND_MILLIS] = nMillis; + } + else if (fieldIndex == CalendarFieldIndex::DST_OFFSET) + { + sal_Int32 nMinutes = value / 60000; + sal_Int16 nMillis = static_cast<sal_Int16>( static_cast<sal_uInt16>( + abs( value - nMinutes * 60000))); + fieldValue[CalendarFieldIndex::DST_OFFSET] = static_cast<sal_Int16>( nMinutes); + fieldValue[CalendarFieldIndex::DST_OFFSET_SECOND_MILLIS] = nMillis; + } + else + fieldValue[fieldIndex] = (sal_Int16) value; + + // offset 1 since the value for week start day SunDay is different between Calendar and Weekdays. + if ( fieldIndex == CalendarFieldIndex::DAY_OF_WEEK ) + fieldValue[fieldIndex]--; // UCAL_SUNDAY:/* == 1 */ ==> Weekdays::SUNDAY /* ==0 */ + } + mapFromGregorian(); + fieldSet = 0; +} + +sal_Int16 SAL_CALL +Calendar_gregorian::getValue( sal_Int16 fieldIndex ) throw(RuntimeException) +{ + if (fieldIndex < 0 || FIELD_INDEX_COUNT <= fieldIndex) + throw ERROR; + + if (fieldSet) { + setValue(); + getValue(); + } + + return fieldValue[fieldIndex]; +} + +void SAL_CALL +Calendar_gregorian::addValue( sal_Int16 fieldIndex, sal_Int32 value ) throw(RuntimeException) +{ + // since ZONE and DST could not be add, we don't need to convert value here + UErrorCode status; + body->add(fieldNameConverter(fieldIndex), value, status = U_ZERO_ERROR); + if ( !U_SUCCESS(status) ) throw ERROR; + getValue(); +} + +sal_Bool SAL_CALL +Calendar_gregorian::isValid() throw(RuntimeException) +{ + if (fieldSet) { + sal_Int32 tmp = fieldSet; + setValue(); + memcpy(fieldSetValue, fieldValue, sizeof(fieldSetValue)); + getValue(); + for ( sal_Int16 fieldIndex = 0; fieldIndex < FIELD_INDEX_COUNT; fieldIndex++ ) { + // compare only with fields that are set and reset fieldSet[] + if (tmp & (1 << fieldIndex)) { + if (fieldSetValue[fieldIndex] != fieldValue[fieldIndex]) + return sal_False; + } + } + } + return true; +} + +// NativeNumberMode has different meaning between Number and Calendar for Asian locales. +// Here is the mapping table +// calendar(q/y/m/d) zh_CN zh_TW ja ko +// NatNum1 NatNum1/1/7/7 NatNum1/1/7/7 NatNum1/1/4/4 NatNum1/1/7/7 +// NatNum2 NatNum2/2/8/8 NatNum2/2/8/8 NatNum2/2/5/5 NatNum2/2/8/8 +// NatNum3 NatNum3/3/3/3 NatNum3/3/3/3 NatNum3/3/3/3 NatNum3/3/3/3 +// NatNum4 NatNum9/9/11/11 + +static sal_Int16 SAL_CALL NatNumForCalendar(const com::sun::star::lang::Locale& aLocale, + sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode, sal_Int16 value ) +{ + sal_Bool isShort = ((nCalendarDisplayCode == CalendarDisplayCode::SHORT_YEAR || + nCalendarDisplayCode == CalendarDisplayCode::LONG_YEAR) && value >= 100) || + nCalendarDisplayCode == CalendarDisplayCode::SHORT_QUARTER || + nCalendarDisplayCode == CalendarDisplayCode::LONG_QUARTER; + sal_Bool isChinese = aLocale.Language.equalsAscii("zh"); + sal_Bool isJapanese = aLocale.Language.equalsAscii("ja"); + sal_Bool isKorean = aLocale.Language.equalsAscii("ko"); + + if (isChinese || isJapanese || isKorean) { + switch (nNativeNumberMode) { + case NativeNumberMode::NATNUM1: + if (!isShort) + nNativeNumberMode = isJapanese ? NativeNumberMode::NATNUM4 : NativeNumberMode::NATNUM7; + break; + case NativeNumberMode::NATNUM2: + if (!isShort) + nNativeNumberMode = isJapanese ? NativeNumberMode::NATNUM5 : NativeNumberMode::NATNUM8; + break; + case NativeNumberMode::NATNUM3: + break; + case NativeNumberMode::NATNUM4: + if (isKorean) + return isShort ? NativeNumberMode::NATNUM9 : NativeNumberMode::NATNUM11; + // fall through + default: return 0; + } + } + return nNativeNumberMode; +} + +static sal_Int32 SAL_CALL DisplayCode2FieldIndex(sal_Int32 nCalendarDisplayCode) +{ + switch( nCalendarDisplayCode ) { + case CalendarDisplayCode::SHORT_DAY: + case CalendarDisplayCode::LONG_DAY: + return CalendarFieldIndex::DAY_OF_MONTH; + case CalendarDisplayCode::SHORT_DAY_NAME: + case CalendarDisplayCode::LONG_DAY_NAME: + return CalendarFieldIndex::DAY_OF_WEEK; + case CalendarDisplayCode::SHORT_QUARTER: + case CalendarDisplayCode::LONG_QUARTER: + case CalendarDisplayCode::SHORT_MONTH: + case CalendarDisplayCode::LONG_MONTH: + case CalendarDisplayCode::SHORT_MONTH_NAME: + case CalendarDisplayCode::LONG_MONTH_NAME: + return CalendarFieldIndex::MONTH; + case CalendarDisplayCode::SHORT_YEAR: + case CalendarDisplayCode::LONG_YEAR: + return CalendarFieldIndex::YEAR; + case CalendarDisplayCode::SHORT_ERA: + case CalendarDisplayCode::LONG_ERA: + return CalendarFieldIndex::ERA; + case CalendarDisplayCode::SHORT_YEAR_AND_ERA: + case CalendarDisplayCode::LONG_YEAR_AND_ERA: + return CalendarFieldIndex::YEAR; + default: + return 0; + } +} + +sal_Int16 SAL_CALL +Calendar_gregorian::getFirstDayOfWeek() throw(RuntimeException) +{ + // UCAL_SUNDAY == 1, Weekdays::SUNDAY == 0 => offset -1 + // Check for underflow just in case we're called "out of sync". + return ::std::max( sal::static_int_cast<sal_Int16>(0), + sal::static_int_cast<sal_Int16>( static_cast<sal_Int16>( + body->getFirstDayOfWeek()) - 1)); +} + +void SAL_CALL +Calendar_gregorian::setFirstDayOfWeek( sal_Int16 day ) +throw(RuntimeException) +{ + // Weekdays::SUNDAY == 0, UCAL_SUNDAY == 1 => offset +1 + body->setFirstDayOfWeek( static_cast<UCalendarDaysOfWeek>( day + 1)); +} + +void SAL_CALL +Calendar_gregorian::setMinimumNumberOfDaysForFirstWeek( sal_Int16 days ) throw(RuntimeException) +{ + aCalendar.MinimumNumberOfDaysForFirstWeek = days; + body->setMinimalDaysInFirstWeek( static_cast<uint8_t>( days)); +} + +sal_Int16 SAL_CALL +Calendar_gregorian::getMinimumNumberOfDaysForFirstWeek() throw(RuntimeException) +{ + return aCalendar.MinimumNumberOfDaysForFirstWeek; +} + +sal_Int16 SAL_CALL +Calendar_gregorian::getNumberOfMonthsInYear() throw(RuntimeException) +{ + return (sal_Int16) aCalendar.Months.getLength(); +} + + +sal_Int16 SAL_CALL +Calendar_gregorian::getNumberOfDaysInWeek() throw(RuntimeException) +{ + return (sal_Int16) aCalendar.Days.getLength(); +} + + +Sequence< CalendarItem > SAL_CALL +Calendar_gregorian::getMonths() throw(RuntimeException) +{ + return aCalendar.Months; +} + + +Sequence< CalendarItem > SAL_CALL +Calendar_gregorian::getDays() throw(RuntimeException) +{ + return aCalendar.Days; +} + +OUString SAL_CALL +Calendar_gregorian::getDisplayName( sal_Int16 displayIndex, sal_Int16 idx, sal_Int16 nameType ) throw(RuntimeException) +{ + OUString aStr; + + switch( displayIndex ) { + case CalendarDisplayIndex::AM_PM:/* ==0 */ + if (idx == 0) aStr = LocaleData().getLocaleItem(aLocale).timeAM; + else if (idx == 1) aStr = LocaleData().getLocaleItem(aLocale).timePM; + else throw ERROR; + break; + case CalendarDisplayIndex::DAY: + if( idx >= aCalendar.Days.getLength() ) throw ERROR; + if (nameType == 0) aStr = aCalendar.Days[idx].AbbrevName; + else if (nameType == 1) aStr = aCalendar.Days[idx].FullName; + else throw ERROR; + break; + case CalendarDisplayIndex::MONTH: + if( idx >= aCalendar.Months.getLength() ) throw ERROR; + if (nameType == 0) aStr = aCalendar.Months[idx].AbbrevName; + else if (nameType == 1) aStr = aCalendar.Months[idx].FullName; + else throw ERROR; + break; + case CalendarDisplayIndex::ERA: + if( idx >= aCalendar.Eras.getLength() ) throw ERROR; + if (nameType == 0) aStr = aCalendar.Eras[idx].AbbrevName; + else if (nameType == 1) aStr = aCalendar.Eras[idx].FullName; + else throw ERROR; + break; + case CalendarDisplayIndex::YEAR: + break; + default: + throw ERROR; + } + return aStr; +} + +// Methods in XExtendedCalendar +OUString SAL_CALL +Calendar_gregorian::getDisplayString( sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode ) + throw (RuntimeException) +{ + sal_Int16 value = getValue(sal::static_int_cast<sal_Int16>( DisplayCode2FieldIndex(nCalendarDisplayCode) )); + OUString aOUStr; + + if (nCalendarDisplayCode == CalendarDisplayCode::SHORT_QUARTER || + nCalendarDisplayCode == CalendarDisplayCode::LONG_QUARTER) { + Sequence< OUString> xR = LocaleData().getReservedWord(aLocale); + sal_Int16 quarter = value / 3; + // Since this base class method may be called by derived calendar + // classes where a year consists of more than 12 months we need a check + // to not run out of bounds of reserved quarter words. Perhaps a more + // clean way (instead of dividing by 3) would be to first get the + // number of months, divide by 4 and then use that result to divide the + // actual month value. + if ( quarter > 3 ) + quarter = 3; + quarter = sal::static_int_cast<sal_Int16>( quarter + + ((nCalendarDisplayCode == CalendarDisplayCode::SHORT_QUARTER) ? + reservedWords::QUARTER1_ABBREVIATION : reservedWords::QUARTER1_WORD) ); + aOUStr = xR[quarter]; + } else { + // The "#100211# - checked" comments serve for detection of "use of + // sprintf is safe here" conditions. An sprintf encountered without + // having that comment triggers alarm ;-) + sal_Char aStr[10]; + switch( nCalendarDisplayCode ) { + case CalendarDisplayCode::SHORT_MONTH: + value += 1; // month is zero based + // fall thru + case CalendarDisplayCode::SHORT_DAY: + sprintf(aStr, "%d", value); // #100211# - checked + break; + case CalendarDisplayCode::LONG_YEAR: + if (aCalendar.Name.equalsAscii("gengou")) + sprintf(aStr, "%02d", value); // #100211# - checked + else + sprintf(aStr, "%d", value); // #100211# - checked + break; + case CalendarDisplayCode::LONG_MONTH: + value += 1; // month is zero based + sprintf(aStr, "%02d", value); // #100211# - checked + break; + case CalendarDisplayCode::SHORT_YEAR: + // Take last 2 digits, or only one if vallue<10, for example, + // in case of the Gengou calendar. + if (value < 100) + sprintf(aStr, "%d", value); // #100211# - checked + else + sprintf(aStr, "%02d", value % 100); // #100211# - checked + break; + case CalendarDisplayCode::LONG_DAY: + sprintf(aStr, "%02d", value); // #100211# - checked + break; + + case CalendarDisplayCode::SHORT_DAY_NAME: + return getDisplayName(CalendarDisplayIndex::DAY, value, 0); + case CalendarDisplayCode::LONG_DAY_NAME: + return getDisplayName(CalendarDisplayIndex::DAY, value, 1); + case CalendarDisplayCode::SHORT_MONTH_NAME: + return getDisplayName(CalendarDisplayIndex::MONTH, value, 0); + case CalendarDisplayCode::LONG_MONTH_NAME: + return getDisplayName(CalendarDisplayIndex::MONTH, value, 1); + case CalendarDisplayCode::SHORT_ERA: + return getDisplayName(CalendarDisplayIndex::ERA, value, 0); + case CalendarDisplayCode::LONG_ERA: + return getDisplayName(CalendarDisplayIndex::ERA, value, 1); + + case CalendarDisplayCode::SHORT_YEAR_AND_ERA: + return getDisplayString( CalendarDisplayCode::SHORT_ERA, nNativeNumberMode ) + + getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNativeNumberMode ); + + case CalendarDisplayCode::LONG_YEAR_AND_ERA: + return getDisplayString( CalendarDisplayCode::LONG_ERA, nNativeNumberMode ) + + getDisplayString( CalendarDisplayCode::LONG_YEAR, nNativeNumberMode ); + + default: + throw ERROR; + } + aOUStr = OUString::createFromAscii(aStr); + } + if (nNativeNumberMode > 0) { + // For Japanese calendar, first year calls GAN, see bug 111668 for detail. + if (eraArray == gengou_eraArray && value == 1 + && (nCalendarDisplayCode == CalendarDisplayCode::SHORT_YEAR || + nCalendarDisplayCode == CalendarDisplayCode::LONG_YEAR) + && (nNativeNumberMode == NativeNumberMode::NATNUM1 || + nNativeNumberMode == NativeNumberMode::NATNUM2)) { + static sal_Unicode gan = 0x5143; + return OUString(&gan, 1); + } + sal_Int16 nNatNum = NatNumForCalendar(aLocale, nCalendarDisplayCode, nNativeNumberMode, value); + if (nNatNum > 0) + return aNatNum.getNativeNumberString(aOUStr, aLocale, nNatNum); + } + return aOUStr; +} + +// Methods in XExtendedCalendar +OUString SAL_CALL +Calendar_buddhist::getDisplayString( sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode ) + throw (RuntimeException) +{ + // make year and era in different order for year before and after 0. + if ((nCalendarDisplayCode == CalendarDisplayCode::LONG_YEAR_AND_ERA || + nCalendarDisplayCode == CalendarDisplayCode::SHORT_YEAR_AND_ERA) && + getValue(CalendarFieldIndex::ERA) == 0) { + if (nCalendarDisplayCode == CalendarDisplayCode::LONG_YEAR_AND_ERA) + return getDisplayString( CalendarDisplayCode::SHORT_YEAR, nNativeNumberMode ) + + getDisplayString( CalendarDisplayCode::SHORT_ERA, nNativeNumberMode ); + else + return getDisplayString( CalendarDisplayCode::LONG_YEAR, nNativeNumberMode ) + + getDisplayString( CalendarDisplayCode::LONG_ERA, nNativeNumberMode ); + } + return Calendar_gregorian::getDisplayString(nCalendarDisplayCode, nNativeNumberMode); +} + +OUString SAL_CALL +Calendar_gregorian::getImplementationName(void) throw( RuntimeException ) +{ + return OUString::createFromAscii(cCalendar); +} + +sal_Bool SAL_CALL +Calendar_gregorian::supportsService(const rtl::OUString& rServiceName) throw( RuntimeException ) +{ + return !rServiceName.compareToAscii(cCalendar); +} + +Sequence< OUString > SAL_CALL +Calendar_gregorian::getSupportedServiceNames(void) throw( RuntimeException ) +{ + Sequence< OUString > aRet(1); + aRet[0] = OUString::createFromAscii(cCalendar); + return aRet; +} + diff --git a/i18npool/source/calendar/calendar_hijri.cxx b/i18npool/source/calendar/calendar_hijri.cxx new file mode 100644 index 000000000000..dcf651098574 --- /dev/null +++ b/i18npool/source/calendar/calendar_hijri.cxx @@ -0,0 +1,341 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_i18npool.hxx" + +#include <stdlib.h> +#include <math.h> + +#include "calendar_hijri.hxx" + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::i18n; +using namespace ::rtl; + +#define ERROR RuntimeException() + +#define GREGORIAN_CROSSOVER 2299161 + +// not used +//static UErrorCode status; // status is shared in all calls to Calendar, it has to be reset for each call. + +// radians per degree (pi/180) +const double Calendar_hijri::RadPerDeg = 0.01745329251994329577; + +// Synodic Period (mean time between 2 successive new moon: 29d, 12 hr, 44min, 3sec +const double Calendar_hijri::SynPeriod = 29.53058868; +const double Calendar_hijri::SynMonth = 365.25/29.53058868; // Solar days in a year/SynPeriod + +// Julian day on Jan 1, 1900 +const double Calendar_hijri::jd1900 = 2415020.75933; + +// Reference point: March 26, 2001 == 1422 Hijri == 1252 Synodial month from 1900 +const sal_Int32 Calendar_hijri::SynRef = 1252; +const sal_Int32 Calendar_hijri::GregRef = 1422; + +// Local time specific to Saudi Arabia +const double Calendar_hijri::SA_TimeZone = 3.0; + +const double Calendar_hijri::EveningPeriod = 6.0; + +const sal_Int32 Calendar_hijri::LeapYear[] = { + 2, 5, 7, 10, 13, 16, 18, 21, 24, 26, 29 +}; + +Calendar_hijri::Calendar_hijri() +{ + cCalendar = "com.sun.star.i18n.Calendar_hijri"; +} + +#define FIELDS ((1 << CalendarFieldIndex::ERA) | (1 << CalendarFieldIndex::YEAR) | (1 << CalendarFieldIndex::MONTH) | (1 << CalendarFieldIndex::DAY_OF_MONTH)) + +// map field value from hijri calendar to gregorian calendar +void Calendar_hijri::mapToGregorian() throw(RuntimeException) +{ + if (fieldSet & FIELDS) { + sal_Int32 day = (sal_Int32)fieldSetValue[CalendarFieldIndex::DAY_OF_MONTH]; + sal_Int32 month = (sal_Int32)fieldSetValue[CalendarFieldIndex::MONTH] + 1; + sal_Int32 year = (sal_Int32)fieldSetValue[CalendarFieldIndex::YEAR]; + if (fieldSetValue[CalendarFieldIndex::ERA] == 0) + year *= -1; + + ToGregorian(&day, &month, &year); + + fieldSetValue[CalendarFieldIndex::ERA] = year <= 0 ? 0 : 1; + fieldSetValue[CalendarFieldIndex::MONTH] = sal::static_int_cast<sal_Int16>(month - 1); + fieldSetValue[CalendarFieldIndex::DAY_OF_MONTH] = (sal_Int16) day; + fieldSetValue[CalendarFieldIndex::YEAR] = (sal_Int16) abs(year); + fieldSet |= FIELDS; + } +} + +// map field value from gregorian calendar to hijri calendar +void Calendar_hijri::mapFromGregorian() throw(RuntimeException) +{ + sal_Int32 month, day, year; + + day = (sal_Int32)fieldValue[CalendarFieldIndex::DAY_OF_MONTH]; + month = (sal_Int32)fieldValue[CalendarFieldIndex::MONTH] + 1; + year = (sal_Int32)fieldValue[CalendarFieldIndex::YEAR]; + if (fieldValue[CalendarFieldIndex::ERA] == 0) + year *= -1; + + // Get Hijri date + getHijri(&day, &month, &year); + + fieldValue[CalendarFieldIndex::DAY_OF_MONTH] = (sal_Int16)day; + fieldValue[CalendarFieldIndex::MONTH] = sal::static_int_cast<sal_Int16>(month - 1); + fieldValue[CalendarFieldIndex::YEAR] = (sal_Int16) abs(year); + fieldValue[CalendarFieldIndex::ERA] = (sal_Int16) year < 1 ? 0 : 1; +} + +// +// This function returns the Julian date/time of the Nth new moon since +// January 1900. The synodic month is passed as parameter. +// +// Adapted from "Astronomical Formulae for Calculators" by +// Jean Meeus, Third Edition, Willmann-Bell, 1985. +// +double +Calendar_hijri::NewMoon(sal_Int32 n) +{ + double jd, t, t2, t3, k, ma, sa, tf, xtra; + k = n; + t = k/1236.85; // Time in Julian centuries from 1900 January 0.5 + t2 = t * t; + t3 = t2 * t; + + // Mean time of phase + jd = jd1900 + + SynPeriod * k + - 0.0001178 * t2 + - 0.000000155 * t3 + + 0.00033 * sin(RadPerDeg * (166.56 + 132.87 * t - 0.009173 * t2)); + + // Sun's mean anomaly in radian + sa = RadPerDeg * (359.2242 + + 29.10535608 * k + - 0.0000333 * t2 + - 0.00000347 * t3); + + // Moon's mean anomaly + ma = RadPerDeg * (306.0253 + + 385.81691806 * k + + 0.0107306 * t2 + + 0.00001236 * t3); + + // Moon's argument of latitude + tf = RadPerDeg * 2.0 * (21.2964 + + 390.67050646 * k + - 0.0016528 * t2 + - 0.00000239 * t3); + + // should reduce to interval between 0 to 1.0 before calculating further + // Corrections for New Moon + xtra = (0.1734 - 0.000393 * t) * sin(sa) + + 0.0021 * sin(sa * 2) + - 0.4068 * sin(ma) + + 0.0161 * sin(2 * ma) + - 0.0004 * sin(3 * ma) + + 0.0104 * sin(tf) + - 0.0051 * sin(sa + ma) + - 0.0074 * sin(sa - ma) + + 0.0004 * sin(tf + sa) + - 0.0004 * sin(tf - sa) + - 0.0006 * sin(tf + ma) + + 0.0010 * sin(tf - ma) + + 0.0005 * sin(sa + 2 * ma); + + // convert from Ephemeris Time (ET) to (approximate) Universal Time (UT) + jd += xtra - (0.41 + 1.2053 * t + 0.4992 * t2)/1440; + + return (jd); +} + +// Get Hijri Date +void +Calendar_hijri::getHijri(sal_Int32 *day, sal_Int32 *month, sal_Int32 *year) +{ + double prevday; +// double dayfraction; + sal_Int32 syndiff; + sal_Int32 newsyn; + double newjd; + double julday; + sal_Int32 synmonth; + + // Get Julian Day from Gregorian + julday = getJulianDay(*day, *month, *year); + + // obtain approx. of how many Synodic months since the beginning of the year 1900 + synmonth = (sal_Int32)(0.5 + (julday - jd1900)/SynPeriod); + + newsyn = synmonth; + prevday = (sal_Int32)julday - 0.5; + + do { + newjd = NewMoon(newsyn); + + // Decrement syndonic months + newsyn--; + } while (newjd > prevday); + newsyn++; + + // difference from reference point + syndiff = newsyn - SynRef; + + // Round up the day + *day = (sal_Int32)(((sal_Int32)julday) - newjd + 0.5); + *month = (syndiff % 12) + 1; + + // currently not supported + //dayOfYear = (sal_Int32)(month * SynPeriod + day); + *year = GregRef + (sal_Int32)(syndiff / 12); + + // If month negative, consider it previous year + if (syndiff != 0 && *month <= 0) { + *month += 12; + (*year)--; + } + + // If Before Hijri subtract 1 + if (*year <= 0) (*year)--; +} + +void +Calendar_hijri::ToGregorian(sal_Int32 *day, sal_Int32 *month, sal_Int32 *year) +{ + sal_Int32 nmonth; +// double dayfraction; + double jday; +// sal_Int32 dayint; + + if ( *year < 0 ) (*year)++; + + // Number of month from reference point + nmonth = *month + *year * 12 - (GregRef * 12 + 1); + + // Add Synodic Reference point + nmonth += SynRef; + + // Get Julian days add time too + jday = NewMoon(nmonth) + *day; + + // Round-up + jday = (double)((sal_Int32)(jday + 0.5)); + + // Use algorithm from "Numerical Recipes in C" + getGregorianDay((sal_Int32)jday, day, month, year); + + // Julian -> Gregorian only works for non-negative year + if ( *year <= 0 ) { + *day = -1; + *month = -1; + *year = -1; + } +} + +/* this algorithm is taken from "Numerical Recipes in C", 2nd ed, pp 14-15. */ +/* this algorithm only valid for non-negative gregorian year */ +void +Calendar_hijri::getGregorianDay(sal_Int32 lJulianDay, sal_Int32 *pnDay, sal_Int32 *pnMonth, sal_Int32 *pnYear) +{ + /* working variables */ + long lFactorA, lFactorB, lFactorC, lFactorD, lFactorE; + long lAdjust; + + /* test whether to adjust for the Gregorian calendar crossover */ + if (lJulianDay >= GREGORIAN_CROSSOVER) { + /* calculate a small adjustment */ + lAdjust = (long) (((float) (lJulianDay - 1867216) - 0.25) / 36524.25); + + lFactorA = lJulianDay + 1 + lAdjust - ((long) (0.25 * lAdjust)); + + } else { + /* no adjustment needed */ + lFactorA = lJulianDay; + } + + lFactorB = lFactorA + 1524; + lFactorC = (long) (6680.0 + ((float) (lFactorB - 2439870) - 122.1) / 365.25); + lFactorD = (long) (365 * lFactorC + (0.25 * lFactorC)); + lFactorE = (long) ((lFactorB - lFactorD) / 30.6001); + + /* now, pull out the day number */ + *pnDay = lFactorB - lFactorD - (long) (30.6001 * lFactorE); + + /* ...and the month, adjusting it if necessary */ + *pnMonth = lFactorE - 1; + if (*pnMonth > 12) + (*pnMonth) -= 12; + + /* ...and similarly for the year */ + *pnYear = lFactorC - 4715; + if (*pnMonth > 2) + (*pnYear)--; + +// Negative year adjustments + if (*pnYear <= 0) + (*pnYear)--; +} + +double +Calendar_hijri::getJulianDay(sal_Int32 day, sal_Int32 month, sal_Int32 year) +{ + double jy, jm; + + if( year == 0 ) { + return -1.0; + } + + if( year == 1582 && month == 10 && day > 4 && day < 15 ) { + return -1.0; + } + + if( month > 2 ) { + jy = year; + jm = month + 1; + } else { + jy = year - 1; + jm = month + 13; + } + + sal_Int32 intgr = (sal_Int32)((sal_Int32)(365.25 * jy) + (sal_Int32)(30.6001 * jm) + day + 1720995 ); + + //check for switch to Gregorian calendar + double gregcal = 15 + 31 * ( 10 + 12 * 1582 ); + + if( day + 31 * (month + 12 * year) >= gregcal ) { + double ja; + ja = (sal_Int32)(0.01 * jy); + intgr += (sal_Int32)(2 - ja + (sal_Int32)(0.25 * ja)); + } + + return (double) intgr; +} diff --git a/i18npool/source/calendar/calendar_jewish.cxx b/i18npool/source/calendar/calendar_jewish.cxx new file mode 100644 index 000000000000..34ad13f1d384 --- /dev/null +++ b/i18npool/source/calendar/calendar_jewish.cxx @@ -0,0 +1,306 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_i18npool.hxx" + +#include <math.h> +#include <stdio.h> + +#include "calendar_jewish.hxx" + +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::i18n; +using namespace ::rtl; + +#define ERROR RuntimeException() + +// not used +//static UErrorCode status; // status is shared in all calls to Calendar, it has to be reset for each call. + +Calendar_jewish::Calendar_jewish() +{ + cCalendar = "com.sun.star.i18n.Calendar_jewish"; +} + +// The following C++ code is translated from the Lisp code in +// ``Calendrical Calculations'' by Nachum Dershowitz and Edward M. Reingold, +// Software---Practice & Experience, vol. 20, no. 9 (September, 1990), +// pp. 899--928. + +// This code is in the public domain, but any use of it +// should acknowledge its source. +// http://www.ntu.edu.sg/home/ayxyan/date1.txt + +// Hebrew dates + +const int HebrewEpoch = -1373429; // Absolute date of start of Hebrew calendar + +// True if year is an Hebrew leap year +sal_Bool HebrewLeapYear(sal_Int32 year) { + return ((((7 * year) + 1) % 19) < 7); +} + +// Last month of Hebrew year. +sal_Int32 LastMonthOfHebrewYear(sal_Int32 year) { + return (HebrewLeapYear(year)) ? 13 : 12; +} + +// Number of days elapsed from the Sunday prior to the start of the +// Hebrew calendar to the mean conjunction of Tishri of Hebrew year. +sal_Int32 HebrewCalendarElapsedDays(sal_Int32 year) { + sal_Int32 MonthsElapsed = + (235 * ((year - 1) / 19)) // Months in complete cycles so far. + + (12 * ((year - 1) % 19)) // Regular months in this cycle. + + (7 * ((year - 1) % 19) + 1) / 19; // Leap months this cycle + sal_Int32 PartsElapsed = 204 + 793 * (MonthsElapsed % 1080); + int HoursElapsed = + 5 + 12 * MonthsElapsed + 793 * (MonthsElapsed / 1080) + + PartsElapsed / 1080; + sal_Int32 ConjunctionDay = 1 + 29 * MonthsElapsed + HoursElapsed / 24; + sal_Int32 ConjunctionParts = 1080 * (HoursElapsed % 24) + PartsElapsed % 1080; + sal_Int32 AlternativeDay; + + if ((ConjunctionParts >= 19440) // If new moon is at or after midday, + || (((ConjunctionDay % 7) == 2) // ...or is on a Tuesday... + && (ConjunctionParts >= 9924) // at 9 hours, 204 parts or later... + && !(HebrewLeapYear(year))) // ...of a common year, + || (((ConjunctionDay % 7) == 1) // ...or is on a Monday at... + && (ConjunctionParts >= 16789) // 15 hours, 589 parts or later... + && (HebrewLeapYear(year - 1))))// at the end of a leap year + // Then postpone Rosh HaShanah one day + AlternativeDay = ConjunctionDay + 1; + else + AlternativeDay = ConjunctionDay; + + if (((AlternativeDay % 7) == 0)// If Rosh HaShanah would occur on Sunday, + || ((AlternativeDay % 7) == 3) // or Wednesday, + || ((AlternativeDay % 7) == 5)) // or Friday + // Then postpone it one (more) day + return (1+ AlternativeDay); + else + return AlternativeDay; +} + +// Number of days in Hebrew year. +sal_Int32 DaysInHebrewYear(sal_Int32 year) { + return ((HebrewCalendarElapsedDays(year + 1)) - + (HebrewCalendarElapsedDays(year))); +} + +// True if Heshvan is long in Hebrew year. +sal_Bool LongHeshvan(sal_Int32 year) { + return ((DaysInHebrewYear(year) % 10) == 5); +} + +// True if Kislev is short in Hebrew year. +sal_Bool ShortKislev(sal_Int32 year) { + return ((DaysInHebrewYear(year) % 10) == 3); +} + +// Last day of month in Hebrew year. +sal_Int32 LastDayOfHebrewMonth(sal_Int32 month, sal_Int32 year) { + if ((month == 2) + || (month == 4) + || (month == 6) + || ((month == 8) && !(LongHeshvan(year))) + || ((month == 9) && ShortKislev(year)) + || (month == 10) + || ((month == 12) && !(HebrewLeapYear(year))) + || (month == 13)) + return 29; + else + return 30; +} + + +class HebrewDate { +private: + sal_Int32 year; // 1... + sal_Int32 month; // 1..LastMonthOfHebrewYear(year) + sal_Int32 day; // 1..LastDayOfHebrewMonth(month, year) + +public: + HebrewDate(sal_Int32 m, sal_Int32 d, sal_Int32 y) { month = m; day = d; year = y; } + + HebrewDate(sal_Int32 d) { // Computes the Hebrew date from the absolute date. + year = (d + HebrewEpoch) / 366; // Approximation from below. + // Search forward for year from the approximation. + while (d >= HebrewDate(7,1,year + 1)) + year++; + // Search forward for month from either Tishri or Nisan. + if (d < HebrewDate(1, 1, year)) + month = 7; // Start at Tishri + else + month = 1; // Start at Nisan + while (d > HebrewDate(month, (LastDayOfHebrewMonth(month,year)), year)) + month++; + // Calculate the day by subtraction. + day = d - HebrewDate(month, 1, year) + 1; + } + + operator int() { // Computes the absolute date of Hebrew date. + sal_Int32 DayInYear = day; // Days so far this month. + if (month < 7) { // Before Tishri, so add days in prior months + // this year before and after Nisan. + sal_Int32 m = 7; + while (m <= (LastMonthOfHebrewYear(year))) { + DayInYear = DayInYear + LastDayOfHebrewMonth(m, year); + m++; + }; + m = 1; + while (m < month) { + DayInYear = DayInYear + LastDayOfHebrewMonth(m, year); + m++; + } + } + else { // Add days in prior months this year + sal_Int32 m = 7; + while (m < month) { + DayInYear = DayInYear + LastDayOfHebrewMonth(m, year); + m++; + } + } + return (DayInYear + + (HebrewCalendarElapsedDays(year)// Days in prior years. + + HebrewEpoch)); // Days elapsed before absolute date 1. + } + + sal_Int32 GetMonth() { return month; } + sal_Int32 GetDay() { return day; } + sal_Int32 GetYear() { return year; } + +}; + +// Gregorian dates + +int LastDayOfGregorianMonth(int month, int year) { +// Compute the last date of the month for the Gregorian calendar. + + switch (month) { + case 2: + if ((((year % 4) == 0) && ((year % 100) != 0)) + || ((year % 400) == 0)) + return 29; + else + return 28; + case 4: + case 6: + case 9: + case 11: return 30; + default: return 31; + } +} + +class GregorianDate { +private: + int year; // 1... + int month; // 1 == January, ..., 12 == December + int day; // 1..LastDayOfGregorianMonth(month, year) + +public: + GregorianDate(int m, int d, int y) { month = m; day = d; year = y; } + + GregorianDate(int d) { // Computes the Gregorian date from the absolute date. + // Search forward year by year from approximate year + year = d/366; + while (d >= GregorianDate(1,1,year+1)) + year++; + // Search forward month by month from January + month = 1; + while (d > GregorianDate(month, LastDayOfGregorianMonth(month,year), year)) + month++; + day = d - GregorianDate(month,1,year) + 1; + } + + operator int() { // Computes the absolute date from the Gregorian date. + int N = day; // days this month + for (int m = month - 1; m > 0; m--) // days in prior months this year + N = N + LastDayOfGregorianMonth(m, year); + return + (N // days this year + + 365 * (year - 1) // days in previous years ignoring leap days + + (year - 1)/4 // Julian leap days before this year... + - (year - 1)/100 // ...minus prior century years... + + (year - 1)/400); // ...plus prior years divisible by 400 + } + + int GetMonth() { return month; } + int GetDay() { return day; } + int GetYear() { return year; } + +}; + +// map field value from gregorian calendar to other calendar, it can be overwritten by derived class. +void Calendar_jewish::mapFromGregorian() throw(RuntimeException) +{ + int y = fieldValue[CalendarFieldIndex::YEAR]; + if (fieldValue[CalendarFieldIndex::ERA] == 0) + y = 1 - y; + GregorianDate Temp(fieldValue[CalendarFieldIndex::MONTH] + 1, fieldValue[CalendarFieldIndex::DAY_OF_MONTH], y); + HebrewDate hd(Temp); + + fieldValue[CalendarFieldIndex::ERA] = hd.GetYear() <= 0 ? 0 : 1; + fieldValue[CalendarFieldIndex::MONTH] = sal::static_int_cast<sal_Int16>( hd.GetMonth() - 1 ); + fieldValue[CalendarFieldIndex::DAY_OF_MONTH] = (sal_Int16)hd.GetDay(); + fieldValue[CalendarFieldIndex::YEAR] = (sal_Int16)(hd.GetYear() <= 0 ? 1 - hd.GetYear() : hd.GetYear()); +} + +#define FIELDS ((1 << CalendarFieldIndex::ERA) | (1 << CalendarFieldIndex::YEAR) | (1 << CalendarFieldIndex::MONTH) | (1 << CalendarFieldIndex::DAY_OF_MONTH)) +// map field value from other calendar to gregorian calendar, it should be implemented. +void Calendar_jewish::mapToGregorian() throw(RuntimeException) +{ + if (fieldSet & FIELDS) { + sal_Int16 y = fieldSetValue[CalendarFieldIndex::YEAR]; + if (fieldSetValue[CalendarFieldIndex::ERA] == 0) + y = 1 - y; + HebrewDate Temp(fieldSetValue[CalendarFieldIndex::MONTH] + 1, fieldSetValue[CalendarFieldIndex::DAY_OF_MONTH], y); + GregorianDate gd(Temp); + + fieldSetValue[CalendarFieldIndex::ERA] = gd.GetYear() <= 0 ? 0 : 1; + fieldSetValue[CalendarFieldIndex::MONTH] = sal::static_int_cast<sal_Int16>( gd.GetMonth() - 1 ); + fieldSetValue[CalendarFieldIndex::DAY_OF_MONTH] = (sal_Int16)gd.GetDay(); + fieldSetValue[CalendarFieldIndex::YEAR] = (sal_Int16)(gd.GetYear() <= 0 ? 1 - gd.GetYear() : gd.GetYear()); + fieldSet |= FIELDS; + } +} + +// Methods in XExtendedCalendar +OUString SAL_CALL +Calendar_jewish::getDisplayString( sal_Int32 nCalendarDisplayCode, sal_Int16 nNativeNumberMode ) + throw (RuntimeException) +{ + nNativeNumberMode = NativeNumberMode::NATNUM2; // make Hebrew number for Jewish calendar + + if (nCalendarDisplayCode == CalendarDisplayCode::SHORT_YEAR) { + sal_Int32 value = getValue(CalendarFieldIndex::YEAR) % 1000; // take last 3 digits + return aNatNum.getNativeNumberString(OUString::valueOf(value), aLocale, nNativeNumberMode ); + } + else + return Calendar_gregorian::getDisplayString(nCalendarDisplayCode, nNativeNumberMode ); +} diff --git a/i18npool/source/calendar/makefile.mk b/i18npool/source/calendar/makefile.mk new file mode 100644 index 000000000000..cce0e4950796 --- /dev/null +++ b/i18npool/source/calendar/makefile.mk @@ -0,0 +1,53 @@ +#************************************************************************* +#* +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +# +# Copyright 2000, 2010 Oracle and/or its affiliates. +# +# OpenOffice.org - a multi-platform office productivity suite +# +# This file is part of OpenOffice.org. +# +# OpenOffice.org is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License version 3 +# only, as published by the Free Software Foundation. +# +# OpenOffice.org is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Lesser General Public License version 3 for more details +# (a copy is included in the LICENSE file that accompanied this code). +# +# You should have received a copy of the GNU Lesser General Public License +# version 3 along with OpenOffice.org. If not, see +# <http://www.openoffice.org/license.html> +# for a copy of the LGPLv3 License. +# +#************************************************************************/ + +PRJ=..$/.. + +PRJNAME=i18npool +TARGET=calendar + +ENABLE_EXCEPTIONS=TRUE + +# --- Settings ----------------------------------------------------- + +.INCLUDE : settings.mk + +# --- Files -------------------------------------------------------- + +SLOFILES= \ + $(SLO)$/calendarImpl.obj \ + $(SLO)$/calendar_gregorian.obj \ + $(SLO)$/calendar_hijri.obj \ + $(SLO)$/calendar_jewish.obj +# + +# --- Targets ------------------------------------------------------ + +.INCLUDE : target.mk + + + |