Updated for calendar handling

svn: r1234

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,

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"

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"

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.

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)

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 "