diff --git a/gramps2/NEWS b/gramps2/NEWS index b4976c73f..c4d60f739 100644 --- a/gramps2/NEWS +++ b/gramps2/NEWS @@ -1,3 +1,11 @@ +Version 0.9.0-pre8 +* Improved support for calendar formats +* Improved UTF-8 support +* Tabs for person list based off name first letter of the surname. Dynamically + created +* More features implemented +* Many bug fixes + Version 0.7.3 * New Russian (Alex Roitman) and Danish (Lars Lundin) translations. GRAMPS now supports English, Italian, German, French, Spanish, @@ -359,4 +367,4 @@ Version 0.1.2 * Fixed a bug in the relationship calculator that caused a traceback when the person selected was a direct ancestor of the active person. * Added the suffix field to the alternate name entry on the Edit Person - form. \ No newline at end of file + form. diff --git a/gramps2/configure b/gramps2/configure index 67071b2c2..ed0fe4c85 100755 --- a/gramps2/configure +++ b/gramps2/configure @@ -1567,7 +1567,7 @@ INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s" -RELEASE=pre7 +RELEASE=pre8 VERSIONSTRING=$VERSION if test x"$RELEASE" != "x" diff --git a/gramps2/configure.in b/gramps2/configure.in index 10a9f8fc7..eaa602596 100644 --- a/gramps2/configure.in +++ b/gramps2/configure.in @@ -2,7 +2,7 @@ dnl Process this file with autoconf to produce a configure script. dnl May need to run automake && aclocal first AC_INIT(src/gramps.py) AM_INIT_AUTOMAKE(gramps, 0.9.0) -RELEASE=pre7 +RELEASE=pre8 VERSIONSTRING=$VERSION if test x"$RELEASE" != "x" diff --git a/gramps2/example/gramps/data.gramps b/gramps2/example/gramps/data.gramps index 3f2d5ce4b..773b7b992 100644 Binary files a/gramps2/example/gramps/data.gramps and b/gramps2/example/gramps/data.gramps differ diff --git a/gramps2/gramps.spec b/gramps2/gramps.spec index 611bfd939..8d07d779a 100644 --- a/gramps2/gramps.spec +++ b/gramps2/gramps.spec @@ -1,5 +1,5 @@ %define ver 0.9.0 -%define rel pre7 +%define rel pre8 %define prefix /usr Summary: Genealogical Research and Analysis Management Programming System. diff --git a/gramps2/src/Calendar.py b/gramps2/src/Calendar.py index 274c5d5bb..57ffbf526 100644 --- a/gramps2/src/Calendar.py +++ b/gramps2/src/Calendar.py @@ -28,6 +28,10 @@ web site at http://www.scottlee.com __author__ = "Donald N. Allingham" __version__ = "$Revision$" +import math +from intl import gettext as _ +import Date + _FR_SDN_OFFSET = 2375474 _FR_DAYS_PER_4_YEARS = 1461 _FR_DAYS_PER_MONTH = 30 @@ -53,9 +57,7 @@ _SUNDAY = 0 _MONDAY = 1 _TUESDAY = 2 _WEDNESDAY= 3 -#_THURSDAY = 4 _FRIDAY = 5 -#_SATURDAY = 6 _NOON = (18 * _HALAKIM_PER_HOUR) _AM3_11_20 = ((9 * _HALAKIM_PER_HOUR) + 204) @@ -76,12 +78,716 @@ yearOffset = [ 136, 148, 160, 173, 185, 197, 210, 222 ] +#------------------------------------------------------------------------- +# +# Calendar - base calendar +# +#------------------------------------------------------------------------- +class Calendar: + + months = [ + _("January"), _("February"), _("March"), _("April"), + _("May"), _("June"), _("July"), _("August"), + _("September"), _("October"), _("November"), _("December")] + + def __init__(self,source=None): + if source: + self.set_sdn(source.get_sdn()) + + def month(self,val): + try: + return Calendar.months[val-1] + except: + return "Illegal Month" + + def get_name(self): + return "ERROR" + + def check(self): + return 0 + + def format(self,year,month,day,mode): + return self.display(year,month,day,year) + + def display(self,year,month,day,mode): + d = '' + if year==Date.UNDEF: + if month == Date.UNDEF: + d = "" + elif day == Date.UNDEF: + d = self.month(month) + else: + d = "%02d %s" % (day,self.month(month)) + elif month == Date.UNDEF: + d = str(year) + elif day == Date.UNDEF: + d = "%s %d" % (self.month(month),year) + else: + d = "%02d %s %d" % (day,self.month(month),year) + if mode == Date.SingleDate.about: + d = _("about") + ' ' + d + elif mode == Date.SingleDate.before: + d = _("before") + ' ' + d + elif mode == Date.SingleDate.after: + d = _("after") + ' ' + d + return d + + def set_sdn(self,val): + return (0,0,0) + + def get_sdn(self,y,m,d): + return 0 + +#------------------------------------------------------------------------- +# +# Hebrew calendar +# +#------------------------------------------------------------------------- +class Hebrew(Calendar): + """Jewish Calendar""" + + HALAKIM_PER_HOUR = 1080 + HALAKIM_PER_DAY = 25920 + HALAKIM_PER_LUNAR_CYCLE = ((29 * HALAKIM_PER_DAY) + 13753) + HALAKIM_PER_METONIC_CYCLE = (HALAKIM_PER_LUNAR_CYCLE * (12 * 19 + 7)) + + SDN_OFFSET = 347997 + NEW_MOON_OF_CREATION = 31524 + + SUNDAY = 0 + MONDAY = 1 + TUESDAY = 2 + WEDNESDAY= 3 + FRIDAY = 5 + + NOON = (18 * _HALAKIM_PER_HOUR) + AM3_11_20 = ((9 * _HALAKIM_PER_HOUR) + 204) + AM9_32_43 = ((15 * _HALAKIM_PER_HOUR) + 589) + + monthsPerYear = [ + 12, 12, 13, 12, 12, 13, 12, 13, 12, + 12, 13, 12, 12, 13, 12, 12, 13, 12, 13 + ] + + yearOffset = [ + 0, 12, 24, 37, 49, 61, 74, 86, 99, 111, 123, + 136, 148, 160, 173, 185, 197, 210, 222 + ] + + months = [ + "Tishri", "Heshvan", "Kislev", "Tevet", "Shevat", "AdarI", + "AdarII", "Nisan", "Iyyar", "Sivan", "Tammuz", "Av", + "Elul",] + + + def month(self,val): + try: + return Hebrew.months[val-1] + except: + return "Illegal Month" + + def Tishri1(self,metonicYear, moladDay, moladHalakim): + + tishri1 = moladDay + dow = tishri1 % 7 + leapYear = metonicYear in [ 2, 5, 7, 10, 13, 16, 18] + lastWasLeapYear = metonicYear in [ 3, 6, 8, 11, 14, 17, 0] + + # Apply rules 2, 3 and 4. + if ((moladHalakim >= NOON) or + ((not leapYear) and dow == TUESDAY and moladHalakim >= AM3_11_20) or + (lastWasLeapYear and dow == MONDAY and moladHalakim >= AM9_32_43)) : + tishri1 = tishri1 + 1 + dow = dow + 1 + if dow == 7: + dow = 0 + + # Apply rule 1 after the others because it can cause an additional + # delay of one day + + if dow == _WEDNESDAY or dow == FRIDAY or dow == SUNDAY: + tishri1 = tishri1 + 1 + + return tishri1 + + def MoladOfMetonicCycle(self,metonicCycle): + + # Start with the time of the first molad after creation. + + r1 = NEW_MOON_OF_CREATION; + + # Calculate metonicCycle * HALAKIM_PER_METONIC_CYCLE. The upper 32 + # bits of the result will be in r2 and the lower 16 bits will be + # in r1. + + r1 = r1 + (metonicCycle * (HALAKIM_PER_METONIC_CYCLE & 0xFFFF)) + r2 = r1 >> 16 + r2 = r2 + (metonicCycle * ((HALAKIM_PER_METONIC_CYCLE >> 16) & 0xFFFF)) + + # Calculate r2r1 / HALAKIM_PER_DAY. The remainder will be in r1, the + # upper 16 bits of the quotient will be in d2 and the lower 16 bits + # will be in d1. + + d2 = r2 / HALAKIM_PER_DAY + r2 = r2 - (d2 * HALAKIM_PER_DAY) + r1 = (r2 << 16) | (r1 & 0xFFFF) + d1 = r1 / HALAKIM_PER_DAY + r1 = r1 - ( d1 * HALAKIM_PER_DAY) + + MoladDay = (d2 << 16) | d1 + MoladHalakim = r1 + + return (MoladDay,MoladHalakim) + + def FindTishriMolad(self,inputDay): + + # Estimate the metonic cycle number. Note that this may be an under + # estimate because there are 6939.6896 days in a metonic cycle not + # 6940, but it will never be an over estimate. The loop below will + # correct for any error in this estimate. */ + + metonicCycle = (inputDay + 310) / 6940 + + # Calculate the time of the starting molad for this metonic cycle. */ + + (moladDay, moladHalakim) = MoladOfMetonicCycle(metonicCycle) + + # If the above was an under estimate, increment the cycle number until + # the correct one is found. For modern dates this loop is about 98.6% + # likely to not execute, even once, because the above estimate is + # really quite close. + + while moladDay < (inputDay - 6940 + 310): + metonicCycle = metonicCycle + 1 + moladHalakim = moladHalakim + HALAKIM_PER_METONIC_CYCLE + moladDay = moladDay + ( moladHalakim / HALAKIM_PER_DAY) + moladHalakim = moladHalakim % HALAKIM_PER_DAY + + # Find the molad of Tishri closest to this date. + + for metonicYear in range(0,18): + if moladDay > inputDay - 74: + break + + moladHalakim = moladHalakim + \ + (HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear]) + moladDay = moladDay + (moladHalakim / HALAKIM_PER_DAY) + moladHalakim = moladHalakim % HALAKIM_PER_DAY + else: + metonicYear = metonicYear + 1 + return (metonicCycle, metonicYear, moladDay, moladHalakim) + + def FindStartOfYear(self,year): + + pMetonicCycle = (year - 1) / 19; + pMetonicYear = (year - 1) % 19; + (pMoladDay, pMoladHalakim) = MoladOfMetonicCycle(pMetonicCycle) + + pMoladHalakim = pMoladHalakim + (HALAKIM_PER_LUNAR_CYCLE * yearOffset[pMetonicYear]) + pMoladDay = pMoladDay + (pMoladHalakim / HALAKIM_PER_DAY) + pMoladHalakim = pMoladHalakim % HALAKIM_PER_DAY + + pTishri1 = Tishri1(pMetonicYear, pMoladDay, pMoladHalakim); + + return (pMetonicCycle, pMetonicYear, pMoladDay, pMoladHalakim, pTishri1) + + def set_sdn(self,sdn): + """Converts an SDN number to a Julian calendar date""" + + if sdn <= SDN_OFFSET : + return (0,0,0) + + inputDay = sdn - SDN_OFFSET + + (metonicCycle, metonicYear, day, halakim) = FindTishriMolad(inputDay) + tishri1 = Tishri1(metonicYear, day, halakim); + + if inputDay >= tishri1: + # It found Tishri 1 at the start of the year + + pYear = (metonicCycle * 19) + metonicYear + 1 + if inputDay < tishri1 + 59: + if inputDay < tishri1 + 30: + pMonth = 1 + pDay = inputDay - tishri1 + 1 + else: + pMonth = 2 + pDay = inputDay - tishri1 - 29 + return (pYear, pMonth, pDay) + + # We need the length of the year to figure this out, so find + # Tishri 1 of the next year. */ + + halakim = halakim + (HALAKIM_PER_LUNAR_CYCLE * monthsPerYear[metonicYear]) + day = day + (halakim / HALAKIM_PER_DAY) + halakim = halakim % HALAKIM_PER_DAY; + tishri1After = Tishri1((metonicYear + 1) % 19, day, halakim); + else: + # It found Tishri 1 at the end of the year. + + pYear = metonicCycle * 19 + metonicYear + if inputDay >= tishri1 - 177: + # It is one of the last 6 months of the year. + if inputDay > tishri1 - 30: + pMonth = 13 + pDay = inputDay - tishri1 + 30 + elif inputDay > tishri1 - 60: + pMonth = 12 + pDay = inputDay - tishri1 + 60 + elif inputDay > tishri1 - 89: + pMonth = 11 + pDay = inputDay - tishri1 + 89 + elif inputDay > tishri1 - 119: + pMonth = 10 + pDay = inputDay - tishri1 + 119 + elif inputDay > tishri1 - 148: + pMonth = 9 + pDay = inputDay - tishri1 + 148 + else: + pMonth = 8 + pDay = inputDay - tishri1 + 178 + return (pYear,pMonth,pDay) + else: + if monthsPerYear[(pYear - 1) % 19] == 13: + pMonth = 7 + pDay = inputDay - tishri1 + 207 + if pDay > 0: + return (pYear,pMonth,pDay) + pMonth = pMonth - 1 + pDay = pDay + 30 + if pDay > 0: + return (pYear,pMonth,pDay) + pMonth = pMonth - 1 + pDay = pDay + 30 + else: + pMonth = 6 + pDay = inputDay - tishri1 + 207 + if pDay > 0: + return (pYear,pMonth,pDay) + pMonth = pMonth - 1 + pDay = pDay + 30 + + if pDay > 0: + return (pYear,pMonth,pDay) + pMonth = pMonth - 1 + pDay = pDay + 29 + if pDay > 0: + return (pYear,pMonth,pDay) + + # We need the length of the year to figure this out, so find + # Tishri 1 of this year. */ + tishri1After = tishri1; + (metonicCycle,metonicYear,day,halakim) = FindTishriMolad(day-365) + tishri1 = Tishri1(metonicYear, day, halakim) + + yearLength = tishri1After - tishri1; + day = inputDay - tishri1 - 29; + if yearLength == 355 or yearLength == 385 : + # Heshvan has 30 days + if day <= 30: + pMonth = 2 + pDay = day + return (pYear,pMonth,pDay) + day = day - 30 + else: + # Heshvan has 29 days + if day <= 29: + pMonth = 2 + pDay = day + return (pYear,pMonth,pDay) + + day = day - 29 + + # It has to be Kislev + return (pYear,3,day) + + def get_sdn(self,year, month, day): + """Converts a Jewish calendar date to an SDN number""" + if year <= 0 or day <= 0 or day > 30 : + return 0 + + if month == 1 or month == 2: + # It is Tishri or Heshvan - don't need the year length. + (metonicCycle,metonicYear,moladDay,moladHalakim,tishri1) = FindStartOfYear(year) + if month == 1: + sdn = tishri1 + day - 1 + else: + sdn = tishri1 + day + 29 + elif month == 3: + # It is Kislev - must find the year length. + + # Find the start of the year. + (metonicCycle,metonicYear,moladDay,moladHalakim,tishri1) = FindStartOfYear(year) + + # Find the end of the year. + moladHalakim = moladHalakim + (HALAKIM_PER_LUNAR_CYCLE*monthsPerYear[metonicYear]) + moladDay = moladDay + (moladHalakim / HALAKIM_PER_DAY) + moladHalakim = moladHalakim % HALAKIM_PER_DAY + tishri1After = Tishri1((metonicYear + 1) % 19, moladDay, moladHalakim) + + yearLength = tishri1After - tishri1 + + if yearLength == 355 or yearLength == 385: + sdn = tishri1 + day + 59 + else: + sdn = tishri1 + day + 58 + elif month == 4 or month == 5 or month == 6: + # It is Tevet, Shevat or Adar I - don't need the year length + + (metonicCycle,metonicYear,moladDay,moladHalakim,tishri1After) = FindStartOfYear(year+1) + + if monthsPerYear[(year - 1) % 19] == 12: + lengthOfAdarIAndII = 29 + else: + lengthOfAdarIAndII = 59 + + if month == 4: + sdn = tishri1After + day - lengthOfAdarIAndII - 237 + elif month == 5: + sdn = tishri1After + day - lengthOfAdarIAndII - 208 + else: + sdn = tishri1After + day - lengthOfAdarIAndII - 178 + else: + # It is Adar II or later - don't need the year length. + (metonicCycle,metonicYear,moladDay,moladHalakim,tishri1After) = FindStartOfYear(year+1) + + if month == 7: + sdn = tishri1After + day - 207 + elif month == 8: + sdn = tishri1After + day - 178 + elif month == 9: + sdn = tishri1After + day - 148 + elif month == 10: + sdn = tishri1After + day - 119 + elif month == 11: + sdn = tishri1After + day - 89 + elif month == 12: + sdn = tishri1After + day - 60 + elif month == 13: + sdn = tishri1After + day - 30 + else: + return 0 + return sdn + SDN_OFFSET + +#------------------------------------------------------------------------- +# +# Persian +# +#------------------------------------------------------------------------- +class Persian(Calendar): + """Persian Calendar""" + + PERSIAN_EPOCH = 1948320.5; + + def get_sdn(self,year, month, day): + if year >= 0: + epbase = year - 474 + else: + epbase = year - 473 + + epyear = 474 + epbase % 2820 + + if month <= 7: + v1 = (month - 1) * 31 + else: + v1 = ((month - 1) * 30) + 6 + v2 = math.floor(((epyear * 682) - 110) / 2816) + v3 = (epyear - 1) * 365 + day + v4 = math.floor(epbase / 2820) * 1029983 + + return int(math.ceil(v1 + v2 + v3 + v4 + PERSIAN_EPOCH - 1)) + + def set_sdn(self,sdn): + sdn = math.floor(sdn) + 0.5 + + depoch = sdn - persian_to_sdn(475, 1, 1) + cycle = math.floor(depoch / 1029983) + cyear = depoch % 1029983 + if cyear == 1029982: + ycycle = 2820 + else: + aux1 = math.floor(cyear / 366) + aux2 = cyear % 366 + ycycle = math.floor(((2134 * aux1) + (2816 * aux2) + 2815) / 1028522) + aux1 + 1; + + year = ycycle + (2820 * cycle) + 474 + if year <= 0: + year = year - 1; + + yday = sdn - persian_to_sdn(year, 1, 1) + 1 + if yday < 186: + month = math.ceil(yday / 31) + else: + month = math.ceil((yday - 6) / 30) + day = (sdn - persian_to_sdn(year, month, 1)) + 1 + return (int(year), int(month), int(day)) + +#------------------------------------------------------------------------- +# +# FrenchRepublic +# +#------------------------------------------------------------------------- +class FrenchRepublic(Calendar): + """French Republic Calendar""" + + SDN_OFFSET = 2375474 + DAYS_PER_4_YEARS = 1461 + DAYS_PER_MONTH = 30 + FIRST_VALID = 2375840 + LAST_VALID = 2380952 + + def get_sdn(self,y,m,d): + """Converts a French Republican Calendar date to an SDN number""" + if (y < 1 or y > 14 or m < 1 or m > 13 or d < 1 or d > 30): + return 0 + return (y*DAYS_PER_4_YEARS)/4+(m-1)*DAYS_PER_MONTH+d+SDN_OFFSET + + def set_sdn(self,sdn): + """Converts an SDN number to a French Republican Calendar date""" + if (sdn < FIRST_VALID or sdn > LAST_VALID) : + return (0,0,0) + temp = (sdn-SDN_OFFSET)*4 - 1 + year = temp/DAYS_PER_4_YEARS + dayOfYear = (temp%DAYS_PER_4_YEARS)/4 + month = (dayOfYear/DAYS_PER_MONTH)+1 + day = (dayOfYear%DAYS_PER_MONTH)+1 + return (year,month,day) + +#------------------------------------------------------------------------- +# +# Gregorian +# +#------------------------------------------------------------------------- +class Gregorian(Calendar): + """Gregorian Calendar""" + + SDN_OFFSET = 32045 + DAYS_PER_5_MONTHS = 153 + DAYS_PER_4_YEARS = 1461 + DAYS_PER_400_YEARS = 146097 + + def get_sdn(self,sdn): + """Converts an SDN number to a gregorial date""" + if sdn <= 0: + return (0,0,0) + + temp = (sdn + SDN_OFFSET) * 4 - 1 + + # Calculate the century (year/100) + century = temp / DAYS_PER_400_YEARS + + # Calculate the year and day of year (1 <= dayOfYear <= 366) + + temp = ((temp % DAYS_PER_400_YEARS) / 4) * 4 + 3 + year = (century * 100) + (temp / DAYS_PER_4_YEARS) + dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1 + + # Calculate the month and day of month + temp = dayOfYear * 5 - 3 + month = temp / DAYS_PER_5_MONTHS + day = (temp % DAYS_PER_5_MONTHS) / 5 + 1 + + # Convert to the normal beginning of the year + if month < 10 : + month = month + 3 + else: + year = year + 1 + month = month - 9 + + # Adjust to the B.C./A.D. type numbering + + year = year - 4800 + if year <= 0: + year = year - 1 + + return (year,month,day) + + def set_sdn(self,iyear,imonth,iday): + """Converts a gregorian date to an SDN number""" + # check for invalid dates + if iyear==0 or iyear<-4714 or imonth<=0 or imonth>12 or iday<=0 or iday>31: + return 0 + + # check for dates before SDN 1 (Nov 25, 4714 B.C.) + if iyear == -4714: + if imonth < 11 or imonth == 11 and iday < 25: + return 0 + + if iyear < 0: + year = iyear + 4801 + else: + year = iyear + 4800 + + # Adjust the start of the year + + if imonth > 2: + month = imonth - 3 + else: + month = imonth + 9 + year = year - 1 + + return( ((year / 100) * DAYS_PER_400_YEARS) / 4 + + ((year % 100) * DAYS_PER_4_YEARS) / 4 + + (month * DAYS_PER_5_MONTHS + 2) / 5 + + iday + - SDN_OFFSET ); + +#------------------------------------------------------------------------- +# +# Julian +# +#------------------------------------------------------------------------- +class Julian(Calendar): + """Julian calendar""" + + SDN_OFFSET = 32083 + DAYS_PER_5_MONTHS = 153 + DAYS_PER_4_YEARS = 1461 + + def get_sdn(self,sdn): + """Converts an SDN number to a Julian date""" + if sdn <= 0 : + return (0,0,0) + + temp = (sdn + SDN_OFFSET) * 4 - 1 + + # Calculate the year and day of year (1 <= dayOfYear <= 366) + year = temp / DAYS_PER_4_YEARS + dayOfYear = (temp % DAYS_PER_4_YEARS) / 4 + 1 + + # Calculate the month and day of month + temp = dayOfYear * 5 - 3; + month = temp / DAYS_PER_5_MONTHS; + day = (temp % DAYS_PER_5_MONTHS) / 5 + 1; + + # Convert to the normal beginning of the year + if month < 10: + month = month + 3 + else: + year = year + 1 + month = month - 9 + + # Adjust to the B.C./A.D. type numbering + year = year - 4800 + if year <= 0: + year = year - 1 + + return (year,month,day) + + def set_sdn(self,iyear,imonth,iday): + """Converts a Julian calendar date to an SDN number""" + + # check for invalid dates + if iyear==0 or iyear<-4713 or imonth<=0 or imonth>12 or iday<=0 or iday>31: + return 0 + + # check for dates before SDN 1 (Jan 2, 4713 B.C.) + if iyear == -4713: + if imonth == 1 and iday == 1: + return 0 + + # Make year always a positive number + if iyear < 0: + year = iyear + 4801 + else: + year = iyear + 4800 + + # Adjust the start of the year + if imonth > 2: + month = imonth - 3 + else: + month = imonth + 9 + year = year - 1 + + return (year*DAYS_PER_4_YEARS)/4 + (month*DAYS_PER_5_MONTHS+2)/5 + iday - SDN_OFFSET + +#------------------------------------------------------------------------- +# +# Islamic +# +#------------------------------------------------------------------------- +class Islamic(Calendar): + """Islamic calendar""" + + ISLAMIC_EPOCH = 1948439.5 + + def set_sdn(self,year, month, day): + v1 = math.ceil(29.5 * (month - 1)) + v2 = (year - 1) * 354 + v3 = math.floor((3 + (11 *year)) / 30) + + return int(math.ceil((day + v1 + v2 + v3 + _ISLAMIC_EPOCH) - 1)) + + def get_sdn(self,sdn): + sdn = math.floor(sdn) + 0.5 + year = int(math.floor(((30*(sdn-_ISLAMIC_EPOCH))+10646)/10631)) + month = int(min(12, math.ceil((sdn-(29+islamic_to_sdn(year,1,1)))/29.5) + 1)) + day = int((sdn - islamic_to_sdn(year,month,1)) + 1) + return (year,month,day) + #------------------------------------------------------------------------- # # Tasks # #------------------------------------------------------------------------- +def sdn_to_julian(sdn): + """Converts an SDN number to a Julian date""" + if sdn <= 0 : + return (0,0,0) + + temp = (sdn + _J_SDN_OFFSET) * 4 - 1 + + # Calculate the year and day of year (1 <= dayOfYear <= 366) + year = temp / _J_DAYS_PER_4_YEARS + dayOfYear = (temp % _J_DAYS_PER_4_YEARS) / 4 + 1 + + # Calculate the month and day of month + temp = dayOfYear * 5 - 3; + month = temp / _J_DAYS_PER_5_MONTHS; + day = (temp % _J_DAYS_PER_5_MONTHS) / 5 + 1; + + # Convert to the normal beginning of the year + if month < 10: + month = month + 3 + else: + year = year + 1 + month = month - 9 + + # Adjust to the B.C./A.D. type numbering + year = year - 4800 + if year <= 0: + year = year - 1 + + return (year,month,day) + +def julian_to_sdn(iyear,imonth,iday): + """Converts a Julian calendar date to an SDN number""" + + # check for invalid dates + if iyear==0 or iyear<-4713 or imonth<=0 or imonth>12 or iday<=0 or iday>31: + return 0 + + # check for dates before SDN 1 (Jan 2, 4713 B.C.) + if iyear == -4713: + if imonth == 1 and iday == 1: + return 0 + + # Make year always a positive number + if iyear < 0: + year = iyear + 4801 + else: + year = iyear + 4800 + + # Adjust the start of the year + if imonth > 2: + month = imonth - 3 + else: + month = imonth + 9 + year = year - 1 + + return (year*_J_DAYS_PER_4_YEARS)/4 + (month*_J_DAYS_PER_5_MONTHS+2)/5 + iday - _J_SDN_OFFSET + def french_to_sdn(y,m,d): """Converts a French Republican Calendar date to an SDN number""" if (y < 1 or y > 14 or m < 1 or m > 13 or d < 1 or d > 30): @@ -165,64 +871,6 @@ def gregorian_to_sdn(iyear,imonth,iday): + iday - _GR_SDN_OFFSET ); - -def sdn_to_julian(sdn): - """Converts an SDN number to a Julian date""" - if sdn <= 0 : - return (0,0,0) - - temp = (sdn + _J_SDN_OFFSET) * 4 - 1 - - # Calculate the year and day of year (1 <= dayOfYear <= 366) - year = temp / _J_DAYS_PER_4_YEARS - dayOfYear = (temp % _J_DAYS_PER_4_YEARS) / 4 + 1 - - # Calculate the month and day of month - temp = dayOfYear * 5 - 3; - month = temp / _J_DAYS_PER_5_MONTHS; - day = (temp % _J_DAYS_PER_5_MONTHS) / 5 + 1; - - # Convert to the normal beginning of the year - if month < 10: - month = month + 3 - else: - year = year + 1 - month = month - 9 - - # Adjust to the B.C./A.D. type numbering - year = year - 4800 - if year <= 0: - year = year - 1 - - return (year,month,day) - -def julian_to_sdn(iyear,imonth,iday): - """Converts a Julian calendar date to an SDN number""" - - # check for invalid dates - if iyear==0 or iyear<-4713 or imonth<=0 or imonth>12 or iday<=0 or iday>31: - return 0 - - # check for dates before SDN 1 (Jan 2, 4713 B.C.) - if iyear == -4713: - if imonth == 1 and iday == 1: - return 0 - - # Make year always a positive number - if iyear < 0: - year = iyear + 4801 - else: - year = iyear + 4800 - - # Adjust the start of the year - if imonth > 2: - month = imonth - 3 - else: - month = imonth + 9 - year = year - 1 - - return (year*_J_DAYS_PER_4_YEARS)/4 + (month*_J_DAYS_PER_5_MONTHS+2)/5 + iday - _J_SDN_OFFSET - def Tishri1(metonicYear, moladDay, moladHalakim): tishri1 = moladDay @@ -511,3 +1159,12 @@ def jewish_to_sdn(year, month, day): else: return 0 return sdn + _H_SDN_OFFSET + +if __name__ == "__main__": + + e = Gregorian() + print e.format(1992,12,2,Date.SingleDate.exact) + print e.format(2002,1,28,Date.SingleDate.about) + + f = Hebrew() + print f.format(1992,12,2,Date.SingleDate.exact) diff --git a/gramps2/src/const.py b/gramps2/src/const.py index 4f4f115c3..239e290dd 100644 --- a/gramps2/src/const.py +++ b/gramps2/src/const.py @@ -100,7 +100,7 @@ startup = 1 # #------------------------------------------------------------------------- progName = "GRAMPS" -version = "0.9.0-pre7" +version = "0.9.0-pre8" copyright = "© 2001-2002 Donald N. Allingham" authors = ["Donald N. Allingham", "David Hampton","Donald A. Peterson"] comments = _("GRAMPS (Genealogical Research and Analysis "