gramps/gramps2/src/Utils.py

#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2000-2006  Donald N. Allingham
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

# $Id$

#-------------------------------------------------------------------------
#
# Standard python modules
#
#-------------------------------------------------------------------------
import os
import sys
import locale
import random
import time

from gettext import gettext as _

try:
    set()
except:
    from sets import Set as set

#-------------------------------------------------------------------------
#
# GNOME/GTK
#
#-------------------------------------------------------------------------
import gtk
import gtk.gdk

#-------------------------------------------------------------------------
#
# Gramps modules
#
#-------------------------------------------------------------------------
import const
import Mime
import NameDisplay
import RelLib
import Errors
from QuestionDialog import WarningDialog

#-------------------------------------------------------------------------
#
# Integer to String  mappings for constants
#
#-------------------------------------------------------------------------
gender = {
    RelLib.Person.MALE    : _("male"),
    RelLib.Person.FEMALE  : _("female"),
    RelLib.Person.UNKNOWN : _("unknown"),
    }
def format_gender( type):
    return gender.get(type[0],_("Invalid"))

child_relations = {
    RelLib.ChildRef.CHILD_NONE      : _("None"),
    RelLib.ChildRef.CHILD_BIRTH     : _("Birth"),
    RelLib.ChildRef.CHILD_ADOPTED   : _("Adopted"),
    RelLib.ChildRef.CHILD_STEPCHILD : _("Stepchild"),
    RelLib.ChildRef.CHILD_SPONSORED : _("Sponsored"),
    RelLib.ChildRef.CHILD_FOSTER    : _("Foster"),
    RelLib.ChildRef.CHILD_UNKNOWN   : _("Unknown"),
    RelLib.ChildRef.CHILD_CUSTOM    : _("Custom"),
    }
def format_child_relation( type):
    if type[0] == RelLib.ChildRef.CHILD_CUSTOM:
        return type[1]
    return child_relations.get(type[0],_("Invalid id %d ('%s')")%type)

confidence = {
    RelLib.SourceRef.CONF_VERY_HIGH : _("Very High"),
    RelLib.SourceRef.CONF_HIGH      : _("High"),
    RelLib.SourceRef.CONF_NORMAL    : _("Normal"),
    RelLib.SourceRef.CONF_LOW       : _("Low"),
    RelLib.SourceRef.CONF_VERY_LOW  : _("Very Low"),
   }
def format_confidence( type):
    return confidence.get(type[0],_("Invalid id %d ('%s')")%type)

family_events = {
    RelLib.Event.UNKNOWN    : _("Unknown"),
    RelLib.Event.CUSTOM     : _("Custom"),
    RelLib.Event.MARRIAGE   : _("Marriage"),
    RelLib.Event.MARR_SETTL : _("Marriage Settlement"),
    RelLib.Event.MARR_LIC   : _("Marriage License"),
    RelLib.Event.MARR_CONTR : _("Marriage Contract"),
    RelLib.Event.MARR_BANNS : _("Marriage Banns"),
    RelLib.Event.ENGAGEMENT : _("Engagement"),
    RelLib.Event.DIVORCE    : _("Divorce"),
    RelLib.Event.DIV_FILING : _("Divorce Filing"),
    RelLib.Event.ANNULMENT  : _("Annulment"),
    RelLib.Event.MARR_ALT   : _("Alternate Marriage"),
    }
def format_family_event( type):
    if type[0] == RelLib.Event.CUSTOM:
        return type[1]
    return family_events.get(type[0],_("Invalid id %d ('%s')")%type)

personal_events = {
    RelLib.Event.UNKNOWN         : _("Unknown"),
    RelLib.Event.CUSTOM          : _("Custom"),
    RelLib.Event.ADOPT           : _("Adopted"),
    RelLib.Event.BIRTH           : _("Birth"),
    RelLib.Event.DEATH           : _("Death"),
    RelLib.Event.ADULT_CHRISTEN  : _("Adult Christening"),
    RelLib.Event.BAPTISM         : _("Baptism"),
    RelLib.Event.BAR_MITZVAH     : _("Bar Mitzvah"),
    RelLib.Event.BAS_MITZVAH     : _("Bas Mitzvah"),
    RelLib.Event.BLESS           : _("Blessing"),
    RelLib.Event.BURIAL          : _("Burial"),
    RelLib.Event.CAUSE_DEATH     : _("Cause Of Death"),
    RelLib.Event.CENSUS          : _("Census"),
    RelLib.Event.CHRISTEN        : _("Christening"),
    RelLib.Event.CONFIRMATION    : _("Confirmation"),
    RelLib.Event.CREMATION       : _("Cremation"),
    RelLib.Event.DEGREE          : _("Degree"),
    RelLib.Event.DIV_FILING      : _("Divorce Filing"),
    RelLib.Event.EDUCATION       : _("Education"),
    RelLib.Event.ELECTED         : _("Elected"),
    RelLib.Event.EMIGRATION      : _("Emigration"),
    RelLib.Event.FIRST_COMMUN    : _("First Communion"),
    RelLib.Event.IMMIGRATION     : _("Immigration"),
    RelLib.Event.GRADUATION      : _("Graduation"),
    RelLib.Event.MED_INFO        : _("Medical Information"),
    RelLib.Event.MILITARY_SERV   : _("Military Service"), 
    RelLib.Event.NATURALIZATION  : _("Naturalization"),
    RelLib.Event.NOB_TITLE       : _("Nobility Title"),
    RelLib.Event.NUM_MARRIAGES   : _("Number of Marriages"),
    RelLib.Event.OCCUPATION      : _("Occupation"),
    RelLib.Event.ORDINATION      : _("Ordination"),
    RelLib.Event.PROBATE         : _("Probate"),
    RelLib.Event.PROPERTY        : _("Property"),
    RelLib.Event.RELIGION        : _("Religion"),
    RelLib.Event.RESIDENCE       : _("Residence"),
    RelLib.Event.RETIREMENT      : _("Retirement"),
    RelLib.Event.WILL            : _("Will")
    }
def format_personal_event( type):
    if type[0] == RelLib.Event.CUSTOM:
        return type[1]
    return personal_events.get(type[0],_("Invalid id %d ('%s')")%type)

def format_event( type):
    if type[0] == RelLib.Event.CUSTOM:
        return type[1]
    val = personal_events.get(type[0])
    if not val:
        val = family_events.get(type[0],_("Invalid id %d ('%s')")%type)
    return val

personal_attributes = {
    RelLib.Attribute.UNKNOWN     : _("Unknown"),
    RelLib.Attribute.CUSTOM      : _("Custom"),
    RelLib.Attribute.CASTE       : _("Caste"),
    RelLib.Attribute.DESCRIPTION : _("Description"),
    RelLib.Attribute.ID          : _("Identification Number"),
    RelLib.Attribute.NATIONAL    : _("National Origin"),
    RelLib.Attribute.NUM_CHILD   : _("Number of Children"),
    RelLib.Attribute.SSN         : _("Social Security Number"),
    }
def format_personal_attribute( type):
    if type[0] == RelLib.Attribute.CUSTOM:
        return type[1]
    return personal_attributes.get(type[0],_("Invalid id %d ('%s')")%type)

family_attributes = {
    RelLib.Attribute.UNKNOWN     : _("Unknown"),
    RelLib.Attribute.CUSTOM      : _("Custom"),
    RelLib.Attribute.NUM_CHILD   : _("Number of Children"),
    }
def format_family_attribute( type):
    if type[0] == RelLib.Attribute.CUSTOM:
        return type[1]
    return family_attributes.get(type[0],_("Invalid id %d ('%s')")%type)

def format_attribute( type):
    if type[0] == RelLib.Attribute.CUSTOM:
        return type[1]
    val = personal_attributes.get(type[0])
    if not val:
        val = family_attributes.get(type[0],_("Invalid id %d ('%s')")%type)
    return val

family_relations = {
    RelLib.Family.MARRIED     : _("Married"),
    RelLib.Family.UNMARRIED   : _("Unmarried"),
    RelLib.Family.CIVIL_UNION : _("Civil Union"),
    RelLib.Family.UNKNOWN     : _("Unknown"),
    RelLib.Family.CUSTOM      : _("Other"),
    }
def format_family_relation( type):
    if type[0] == RelLib.Family.CUSTOM:
        return type[1]
    return family_relations.get(type[0],_("Invalid id %d ('%s')")%type)

family_rel_descriptions = {
    RelLib.Family.MARRIED     : _("A legal or common-law relationship "
                                  "between a husband and wife"),
    RelLib.Family.UNMARRIED   : _("No legal or common-law relationship "
                                  "between man and woman"),
    RelLib.Family.CIVIL_UNION : _("An established relationship between "
                                  "members of the same sex"),
    RelLib.Family.UNKNOWN     : _("Unknown relationship between a man "
                                  "and woman"),
    RelLib.Family.CUSTOM      : _("An unspecified relationship "
                                  "a man and woman"),
    }

name_types = {
    RelLib.Name.UNKNOWN : _("Unknown"),
    RelLib.Name.CUSTOM  : _("Custom"),
    RelLib.Name.AKA     : _("Also Known As"),
    RelLib.Name.BIRTH   : _("Birth Name"),
    RelLib.Name.MARRIED : _("Married Name"),
    }
def format_name_type( type):
    if type[0] == RelLib.Name.CUSTOM:
        return type[1]
    return name_types.get(type[0],_("Invalid id %d ('%s')")%type)

web_types = {
    RelLib.Url.UNKNOWN    : _("Unknown"),
    RelLib.Url.CUSTOM     : _("Custom"),
    RelLib.Url.EMAIL      : _("E-mail"),
    RelLib.Url.WEB_HOME   : _("Web Home"),
    RelLib.Url.WEB_SEARCH : _("Web Search"),
    RelLib.Url.WEB_FTP    : _("FTP"),
    }
def format_web_type( type):
    if type[0] == RelLib.Url.CUSTOM:
        return type[1]
    return web_types.get(type[0],_("Invalid id %d ('%s')")%type)

source_media_types = {
    RelLib.RepoRef.UNKNOWN    : _("Unknown"),
    RelLib.RepoRef.CUSTOM     : _("Custom"),
    RelLib.RepoRef.AUDIO      : _("Audio"),
    RelLib.RepoRef.BOOK       : _("Book"),
    RelLib.RepoRef.CARD       : _("Card"),
    RelLib.RepoRef.ELECTRONIC : _("Electronic"),
    RelLib.RepoRef.FICHE      : _("Fiche"),
    RelLib.RepoRef.FILM       : _("Film"),
    RelLib.RepoRef.MAGAZINE   : _("Magazine"),
    RelLib.RepoRef.MANUSCRIPT : _("Manuscript"),
    RelLib.RepoRef.MAP        : _("Map"),
    RelLib.RepoRef.NEWSPAPER  : _("Newspaper"),
    RelLib.RepoRef.PHOTO      : _("Photo"),
    RelLib.RepoRef.TOMBSTONE  : _("Tombstone"),
    RelLib.RepoRef.VIDEO      : _("Video"),
    }
def format_source_media_type( type):
    if type[0] == RelLib.RepoRef.CUSTOM:
        return type[1]
    return source_media_types.get(type[0],_("Invalid id %d ('%s')")%type)

event_roles = {
    RelLib.EventRef.UNKNOWN   : _("Unknown"),
    RelLib.EventRef.CUSTOM    : _("Custom"),
    RelLib.EventRef.PRIMARY   : _("Primary"),
    RelLib.EventRef.CLERGY    : _("Clergy"),
    RelLib.EventRef.CELEBRANT : _("Celebrant"),
    RelLib.EventRef.AIDE      : _("Aide"),
    RelLib.EventRef.BRIDE     : _("Bride"),
    RelLib.EventRef.GROOM     : _("Groom"),
    RelLib.EventRef.WITNESS   : _("Witness"),
    }
def format_personal_event_role( type):
    if type[0] == RelLib.EventRef.CUSTOM:
        return type[1]
    return event_roles.get(type[0],_("Invalid id %d ('%s')")%type)

family_event_roles = {
    RelLib.EventRef.UNKNOWN   : _("Unknown"),
    RelLib.EventRef.CUSTOM    : _("Custom"),
    RelLib.EventRef.FAMILY    : _("Family"),
    }
def format_family_event_role( type):
    if type[0] == RelLib.EventRef.CUSTOM:
        return type[1]
    return family_event_roles.get(type[0],_("Invalid id %d ('%s')")%type)

def format_event_role( type):
    if type[0] == RelLib.EventRef.CUSTOM:
        return type[1]
    val = event_roles.get(type[0])
    if not val:
        val = family_event_roles.get(type[0],_("Invalid id %d ('%s')")%type)
    return val

repository_types = {
    RelLib.Repository.UNKNOWN    : _("Unknown"),
    RelLib.Repository.CUSTOM     : _("Custom"),
    RelLib.Repository.LIBRARY    : _("Library"),
    RelLib.Repository.CEMETERY   : _("Cemetery"),
    RelLib.Repository.CHURCH     : _("Church"),
    RelLib.Repository.ARCHIVE    : _("Archive"),
    RelLib.Repository.ALBUM      : _("Album"),
    RelLib.Repository.WEBSITE    : _("Web site"),
    RelLib.Repository.BOOKSTORE  : _("Bookstore"),
    RelLib.Repository.COLLECTION : _("Collection"),
    RelLib.Repository.SAFE       : _("Safe"),
    }
def format_repository_type( type):
    if type[0] == RelLib.Repository.CUSTOM:
        return type[1]
    return repository_types.get(type[0],_("Invalid id %d ('%s')")%type)


marker_types = {
    RelLib.PrimaryObject.MARKER_NONE        : "",
    RelLib.PrimaryObject.MARKER_CUSTOM      : _("Custom"),
    RelLib.PrimaryObject.MARKER_COMPLETE    : _("Information is complete"),
    RelLib.PrimaryObject.MARKER_TODO        : _("TODO"),
}
def format_marker_type( type):
    if type[0] == RelLib.PrimaryObject.MARKER_CUSTOM:
        return type[1]
    return marker_types.get(type[0],_("Invalid id %d ('%s')")%type)

#-------------------------------------------------------------------------
#
# Integer to GEDCOM tag mappings for constants
#
#-------------------------------------------------------------------------
familyConstantEvents = {
    RelLib.Event.ANNULMENT  : "ANUL",
    RelLib.Event.DIV_FILING : "DIVF",
    RelLib.Event.DIVORCE    : "DIV",
    RelLib.Event.ENGAGEMENT : "ENGA",
    RelLib.Event.MARR_BANNS : "MARB",
    RelLib.Event.MARR_CONTR : "MARC",
    RelLib.Event.MARR_LIC   : "MARL",
    RelLib.Event.MARR_SETTL : "MARS",
    RelLib.Event.MARRIAGE   : "MARR"
    }

personalConstantEvents = {
    RelLib.Event.ADOPT            : "ADOP",
    RelLib.Event.ADULT_CHRISTEN   : "CHRA",
    RelLib.Event.BIRTH            : "BIRT",
    RelLib.Event.DEATH            : "DEAT",
    RelLib.Event.BAPTISM          : "BAPM",
    RelLib.Event.BAR_MITZVAH      : "BARM",
    RelLib.Event.BAS_MITZVAH      : "BASM",
    RelLib.Event.BLESS            : "BLES",
    RelLib.Event.BURIAL           : "BURI",
    RelLib.Event.CAUSE_DEATH      : "CAUS",
    RelLib.Event.ORDINATION       : "ORDI",
    RelLib.Event.CENSUS           : "CENS",
    RelLib.Event.CHRISTEN         : "CHR" ,
    RelLib.Event.CONFIRMATION     : "CONF",
    RelLib.Event.CREMATION        : "CREM",
    RelLib.Event.DEGREE           : "_DEG", 
    RelLib.Event.DIV_FILING       : "DIVF",
    RelLib.Event.EDUCATION        : "EDUC",
    RelLib.Event.ELECTED          : "",
    RelLib.Event.EMIGRATION       : "EMIG",
    RelLib.Event.FIRST_COMMUN     : "FCOM",
    RelLib.Event.GRADUATION       : "GRAD",
    RelLib.Event.MED_INFO         : "_MDCL", 
    RelLib.Event.MILITARY_SERV    : "_MILT", 
    RelLib.Event.NATURALIZATION   : "NATU",
    RelLib.Event.NOB_TITLE        : "TITL",
    RelLib.Event.NUM_MARRIAGES    : "NMR",
    RelLib.Event.IMMIGRATION      : "IMMI",
    RelLib.Event.OCCUPATION       : "OCCU",
    RelLib.Event.PROBATE          : "PROB",
    RelLib.Event.PROPERTY         : "PROP",
    RelLib.Event.RELIGION         : "RELI",
    RelLib.Event.RESIDENCE        : "RESI", 
    RelLib.Event.RETIREMENT       : "RETI",
    RelLib.Event.WILL             : "WILL",
    }

familyConstantAttributes = {
    RelLib.Attribute.NUM_CHILD   : "NCHI",
    }

personalConstantAttributes = {
    RelLib.Attribute.CASTE       : "CAST",
    RelLib.Attribute.DESCRIPTION : "DSCR",
    RelLib.Attribute.ID          : "IDNO",
    RelLib.Attribute.NATIONAL    : "NATI",
    RelLib.Attribute.NUM_CHILD   : "NCHI",
    RelLib.Attribute.SSN         : "SSN",
    }

#-------------------------------------------------------------------------
#
# modified flag
#
#-------------------------------------------------------------------------
_history_brokenFlag = 0

def history_broken():
    global _history_brokenFlag
    _history_brokenFlag = 1

data_recover_msg = _('The data can only be recovered by Undo operation '
            'or by quitting with abandoning changes.')

def fix_encoding(value):
    if type(value) != unicode:
        try:
            return unicode(value)
        except:
            codeset = locale.getpreferredencoding()
            if codeset == 'UTF-8':
                codeset = 'latin1'
            return unicode(value,codeset)
    else:
        return value

def xml_lang():
    (loc,enc) = locale.getlocale()
    if loc == None:
        return ""
    else:
        return loc.replace('_','-')

#-------------------------------------------------------------------------
#
# force_unicode
#
#-------------------------------------------------------------------------

def force_unicode(n):
    if type(n) != unicode:
        return (unicode(n).lower(),unicode(n))
    else:
        return (n.lower(),n)

#-------------------------------------------------------------------------
#
# Clears the modified flag.  Should be called after data is saved.
#
#-------------------------------------------------------------------------
def clearHistory_broken():
    global _history_brokenFlag
    _history_brokenFlag = 0

def wasHistory_broken():
    return _history_brokenFlag

#-------------------------------------------------------------------------
#
# Short hand function to return either the person's name, or an empty
# string if the person is None
#
#-------------------------------------------------------------------------

def family_name(family,db):
    """Builds a name for the family from the parents names"""
    father_handle = family.get_father_handle()
    mother_handle = family.get_mother_handle()
    father = db.get_person_from_handle(father_handle)
    mother = db.get_person_from_handle(mother_handle)
    if father and mother:
        fname = NameDisplay.displayer.display(father)
        mname = NameDisplay.displayer.display(mother)
        name = _("%(father)s and %(mother)s") % {
                    "father" : fname,
                    "mother" : mname}
    elif father:
        name = NameDisplay.displayer.display(father)
    elif mother:
        name = NameDisplay.displayer.display(mother)
    else:
        name = _("unknown")
    return name

def family_upper_name(family,db):
    """Builds a name for the family from the parents names"""
    father_handle = family.get_father_handle()
    mother_handle = family.get_mother_handle()
    father = db.get_person_from_handle(father_handle)
    mother = db.get_person_from_handle(mother_handle)
    if father and mother:
        fname = father.get_primary_name().get_upper_name()
        mname = mother.get_primary_name().get_upper_name()
        name = _("%s and %s") % (fname,mname)
    elif father:
        name = father.get_primary_name().get_upper_name()
    else:
        name = mother.get_primary_name().get_upper_name()
    return name
        

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def destroy_passed_object(obj):
    obj.destroy()
    while gtk.events_pending():
        gtk.main_iteration()

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def get_detail_text(obj,priv=1):
    if obj.get_note() != "":
        details = "%s" % _("Note")
    else:
        details = ""
    if len(obj.get_source_references()) > 0:
        if details == "":
            details = _("Source")
        else:
            details = "%s, %s" % (details,_("Source"))
    if priv and obj.get_privacy() == 1:
        if details == "":
            details = _("Private")
        else:
            details = "%s, %s" % (details,_("Private"))
    return details

#-------------------------------------------------------------------------
#
# 
#
#-------------------------------------------------------------------------
def redraw_list(dlist,clist,func):
    clist.clear()
    
    index = 0
    for obj in dlist:
        col = 0
        node = clist.append()
        for data in func(obj):
            clist.set_value(node,col,data)
            col = col + 1
        index = index + 1
    return index

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def delete_selected(obj,list):
    sel = obj.get_selection()
    model,node = sel.get_selected()
    if node:
        index = model.get_path(node)[0]
        del list[index]
    return 1

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def add_menuitem(menu,msg,obj,func):
    item = gtk.MenuItem(msg)
    item.set_data('o',obj)
    item.connect("activate",func)
    item.show()
    menu.append(item)

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def view_photo(photo):
    mime_type = photo.get_mime_type()
    try:
        data = Mime.get_application(mime_type)
        prog = data[0]
    except:
        return
    launch(prog,photo.get_path())

def find_file( filename):
    # try the filename we got
    try:
        fname = filename
        if os.path.isfile( filename):
            return( filename)
    except:
        pass
    
    # Build list of elternate encodings
    encodings = [sys.getfilesystemencoding(), locale.getpreferredencoding(), 'UTF-8', 'ISO-8859-1']
    encodings = list(set(encodings))
    for enc in encodings:
        try:
            fname = filename.encode(enc)
            if os.path.isfile( fname):
                return fname
        except:
            pass

    # not found
    return ''

def find_folder( filename):
    # try the filename we got
    try:
        fname = filename
        if os.path.isdir( filename):
            return( filename)
    except:
        pass
    
    # Build list of elternate encodings
    try:
        encodings = [sys.getfilesystemencoding(), locale.getpreferredencoding(),
                     'UTF-8', 'ISO-8859-1']
    except:
        encodings = [sys.getfilesystemencoding(), 'UTF-8', 'ISO-8859-1']
    encodings = list(set(encodings))
    for enc in encodings:
        try:
            fname = filename.encode(enc)
            if os.path.isdir( fname):
                return fname
        except:
            pass

    # not found
    return ''

#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def build_string_optmenu(mapping, start_val):
    index = 0
    start_index = 0
    keys = mapping.keys()
    keys.sort()
    myMenu = gtk.Menu()

    for key in keys:
        if key == "default":
            menuitem = gtk.MenuItem(_("default"))
        else:
            menuitem = gtk.MenuItem(key)
        menuitem.set_data("d", mapping[key])
        menuitem.set_data("l", key)
        menuitem.show()
        myMenu.append(menuitem)
        if key == start_val:
            start_index = index
        index = index + 1
    
    if start_index:
        myMenu.set_active(start_index)
    return myMenu


#-------------------------------------------------------------------------
#
#
#
#-------------------------------------------------------------------------
def build_columns(tree,list):
    cnum = 0
    for name in list:
        renderer = gtk.CellRendererText()
        renderer.set_fixed_height_from_font(1)
        column = gtk.TreeViewColumn(name[0],renderer,text=cnum)
        column.set_min_width(name[1])
        if name[2] >= 0:
            column.set_sort_column_id(name[2])
        if name[0] == '':
            column.set_clickable(True)
            column.set_visible(False)
        cnum = cnum + 1
        tree.append_column(column)

#-------------------------------------------------------------------------
#
#  Iterate over ancestors.
#
#-------------------------------------------------------------------------
def for_each_ancestor(db, start, func, data):
    """
    Recursively iterate (breadth-first) over ancestors of
    people listed in start.
    Call func(data,pid) for the Id of each person encountered.
    Exit and return 1, as soon as func returns true.
    Return 0 otherwise.
    """
    todo = start
    doneIds = {}
    while len(todo):
        p_handle = todo.pop()
        p = db.get_person_from_handle(p_handle)
        # Don't process the same handle twice.  This can happen
        # if there is a cycle in the database, or if the
        # initial list contains X and some of X's ancestors.
        if doneIds.has_key(p_handle):
            continue
        doneIds[p_handle] = 1
        if func(data,p_handle):
            return 1
        for fam_handle, mrel, frel in p.get_parent_family_handle_list():
            fam = db.get_family_from_handle(fam_handle)
            if fam:
                f_handle = fam.get_father_handle()
                m_handle = fam.get_mother_handle()
                if f_handle: todo.append(f_handle)
                if m_handle: todo.append(m_handle)
    return 0

def title(n):
    return '<span weight="bold" size="larger">%s</span>' % n

def set_title_label(xmlobj,t):
    title_label = xmlobj.get_widget('title')
    title_label.set_text('<span weight="bold" size="larger">%s</span>' % t)
    title_label.set_use_markup(True)

def set_titles(window,title,t,msg=None):
    if title:
        title.set_text('<span weight="bold" size="larger">%s</span>' % t)
        title.set_use_markup(True)
    if msg:
        window.set_title('%s - GRAMPS' % msg)
    else:
        window.set_title('%s - GRAMPS' % t)
    window.set_icon_from_file(const.icon)

def gfloat(val):
    """Converts to floating number, taking care of possible locale differences.
    
    Useful for reading float values from text entry fields 
    while under non-English locale.
    """

    try:
        return float(val)
    except:
        try:
            return float(val.replace('.',','))
        except:
            return float(val.replace(',','.'))
    return 0.0

def gformat(val):
    """Performs ('%.3f' % val) formatting with the resulting string always 
    using dot ('.') as a decimal point.
    
    Useful for writing float values into XML when under non-English locale.
    """

    decimal_point = locale.localeconv()['decimal_point']
    return_val = "%.3f" % val
    return return_val.replace(decimal_point,'.')

def search_for(name):
    name = name.split()[0]
    for i in os.environ['PATH'].split(':'):
        fname = os.path.join(i,name)
        if os.access(fname,os.X_OK) and not os.path.isdir(fname):
            return 1
    return 0
                  
#-------------------------------------------------------------------------
#
#  Change label appearance
#
#-------------------------------------------------------------------------
def bold_label(label,widget=None):
    if label.__class__ == gtk.Label:
        text = unicode(label.get_text())
        text = text.replace('<i>','')
        text = text.replace('</i>','')
        label.set_text("<b>%s</b>" % text )
        label.set_use_markup(True)
    else:
        clist = label.get_children()
        text = unicode(clist[1].get_text())
        text = text.replace('<i>','')
        text = text.replace('</i>','')
        clist[0].show()
        clist[1].set_text("<b>%s</b>" % text )
        clist[1].set_use_markup(True)
    if widget:
        widget.window.set_cursor(None)
        
def unbold_label(label,widget=None):
    if label.__class__ == gtk.Label:
        text = unicode(label.get_text())
        text = text.replace('<b>','')
        text = text.replace('</b>','')
        text = text.replace('<i>','')
        text = text.replace('</i>','')
        label.set_text(text)
        label.set_use_markup(False)
    else:
        clist = label.get_children()
        text = unicode(clist[1].get_text())
        text = text.replace('<b>','')
        text = text.replace('</b>','')
        text = text.replace('<i>','')
        text = text.replace('</i>','')
        clist[0].hide()
        clist[1].set_text(text)
        clist[1].set_use_markup(False)
    if widget:
        widget.window.set_cursor(None)

def temp_label(label,widget=None):
    if label.__class__ == gtk.Label:
        text = unicode(label.get_text())
        text = text.replace('<b>','')
        text = text.replace('</b>','')
        label.set_text("<i>%s</i>" % text )
        label.set_use_markup(True)
    else:
        clist = label.get_children()
        text = unicode(clist[1].get_text())
        text = text.replace('<b>','')
        text = text.replace('</b>','')
        clist[0].hide()
        clist[1].set_text("<i>%s</i>" % text )
        clist[1].set_use_markup(True)
    if widget:
        widget.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))

#-------------------------------------------------------------------------
#
# create_id
#
#-------------------------------------------------------------------------
rand = random.Random(time.time())

def create_id():
    return "%08x%08x" % ( int(time.time()*10000),
                          rand.randint(0,sys.maxint))

def probably_alive(person,db,current_year=None,limit=0):
    """Returns true if the person may be alive.

    This works by a process of emlimination. If we can't find a good
    reason to believe that someone is dead then we assume they must
    be alive.

    """

    if not current_year:
        time_struct = time.localtime(time.time())
        current_year = time_struct[0]

    death_year = None
    # If the recorded death year is before current year then
    # things are simple.
    if person.death_ref:
        death = db.get_event_from_handle(person.death_ref.ref)
        if death.get_date_object().get_start_date() != RelLib.Date.EMPTY:
            death_year = death.get_date_object().get_year()
            if death_year - limit < current_year:
                return False

    # Look for Cause Of Death, Burial or Cremation events.
    # These are fairly good indications that someone's not alive.
    for ev_ref in person.event_ref_list:
        ev = db.get_event_from_handle(ev_ref.ref)
        if ev and ev.get_type()[0] in [RelLib.Event.CAUSE_DEATH, RelLib.Event.BURIAL,
                                       RelLib.Event.CREMATION]:
            if not death_year:
                death_year = ev.get_date_object().get_year()
            if ev.get_date_object().get_start_date() != RelLib.Date.EMPTY:
                if ev.get_date_object().get_year() - limit < current_year:
                    return False
        # For any other event of this person, check whether it happened
        # too long ago. If so then the person is likely dead now.
        elif ev and too_old(ev.get_date_object(),current_year):
            return False

    birth_year = None
    # If they were born within 100 years before current year then
    # assume they are alive (we already know they are not dead).
    if person.birth_ref:
        birth = db.get_event_from_handle(person.birth_ref.ref)
        if birth.get_date_object().get_start_date() != RelLib.Date.EMPTY:
            if not birth_year:
                birth_year = birth.get_date_object().get_year()
            # Check whether the birth event is too old because the
            # code above did not look at birth, only at other events
            if too_old(birth.get_date_object(),current_year):
                return False
            if not_too_old(birth.get_date_object(),current_year):
                return True
    
    if not birth_year and death_year:
        if death_year > current_year + 110:
            # person died more tha 110 after current year
            return False
            
    # Neither birth nor death events are available.  Try looking
    # for descendants that were born more than a lifespan ago.

    min_generation = 13

    def descendants_too_old (person, years):
        for family_handle in person.get_family_handle_list():
            family = db.get_family_from_handle(family_handle)
            
            for child_handle in family.get_child_handle_list():
                child = db.get_person_from_handle(child_handle)
                if child.birth_ref:
                    child_birth = db.get_event_from_handle(child.birth_ref.ref)
                    dobj = child_birth.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        d = RelLib.Date(dobj)
                        val = d.get_start_date()
                        val = d.get_year() - years
                        d.set_year(val)
                        if not not_too_old (d,current_year):
                            return True

                if child.death_ref:
                    child_death = db.get_event_from_handle(child.death_ref.ref)
                    dobj = child_death.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        if not not_too_old (dobj,current_year):
                            return True

                if descendants_too_old (child, years + min_generation):
                    return True
                
        return False

    # If there are descendants that are too old for the person to have
    # been alive in the current year then they must be dead.

    try:
        if descendants_too_old (person, min_generation):
            return False
    except RuntimeError:
        raise Errors.DatabaseError(
            _("Database error: %s is defined as his or her own ancestor") %
            NameDisplay.displayer.display(person))

    average_generation_gap = 20

    def ancestors_too_old (person, year):
        family_handle = person.get_main_parents_family_handle()
        
        if family_handle:                
            family = db.get_family_from_handle(family_handle)
            father_handle = family.get_father_handle()
            if father_handle:
                father = db.get_person_from_handle(father_handle)
                if father.birth_ref:
                    father_birth = db.get_event_from_handle(father.birth_ref.ref)
                    dobj = father_birth.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        if not not_too_old (dobj,year - average_generation_gap):
                            #print father.get_primary_name().get_name(), " father of ", person.get_primary_name().get_name(), " is too old by birth. birth year ", dobj.get_year(), " test year ", year - average_generation_gap
                            return True
                        #else:
                            #print father.get_primary_name().get_name(), " father of ", person.get_primary_name().get_name(), " is NOT too old by birth. birth year ", dobj.get_year(), " test year ", year - average_generation_gap


                if father.death_ref:
                    father_death = db.get_event_from_handle(father.death_ref.ref)
                    dobj = father_death.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        if dobj.get_year() < year - average_generation_gap:
                            #print father.get_primary_name().get_name(), " father of ", person.get_primary_name().get_name(), " is too old by death."
                            return True

                if ancestors_too_old (father, year - average_generation_gap):
                    return True

            mother_handle = family.get_mother_handle()
            if mother_handle:
                mother = db.get_person_from_handle(mother_handle)
                if mother.birth_ref:
                    mother_birth = db.get_event_from_handle(mother.birth_ref.ref)
                    dobj = mother_birth.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        if not not_too_old (dobj,year - average_generation_gap):
                            #print mother.get_primary_name().get_name(), " mother of ", person.get_primary_name().get_name(), " is too old by birth. birth year ", dobj.get_year(), " test year ", year - average_generation_gap
                            return True
                        #else:
                            #print mother.get_primary_name().get_name(), " mother of ", person.get_primary_name().get_name(), " is NOT too old by birth. birth year ", dobj.get_year(), " test year ", year - average_generation_gap


                if mother.death_ref:
                    mother_death = db.get_event_from_handle(mother.death_ref.ref)
                    dobj = mother_death.get_date_object()
                    if dobj.get_start_date() != RelLib.Date.EMPTY:
                        if dobj.get_year() < year - average_generation_gap:
                            #print mother.get_primary_name().get_name(), " mother of ", person.get_primary_name().get_name(), " is too old by death."
                            return True

                if ancestors_too_old (mother, year - average_generation_gap):
                    return True

        return False

    # If there are ancestors that would be too old in the current year
    # then assume our person must be dead too.
    if ancestors_too_old (person, current_year):
        #print person.get_primary_name().get_name(), " is dead because ancestors are too old."
        return False

    # If we can't find any reason to believe that they are dead we
    # must assume they are alive.
    #print person.get_primary_name().get_name(), " is probably alive."
    return True

def not_too_old(date,current_year=None):
    if not current_year:
        time_struct = time.localtime(time.time())
        current_year = time_struct[0]
    year = date.get_year()
    if year > current_year:
        return False
    return (year != 0 and current_year - year < 110)

def too_old(date,current_year=None):
    if current_year:
        the_current_year = current_year
    else:
        time_struct = time.localtime(time.time())
        the_current_year = time_struct[0]
    year = date.get_year()
    if year > the_current_year:
        return True
    return (year != 0 and the_current_year - year > 150)

#-------------------------------------------------------------------------
#
# 
#
#-------------------------------------------------------------------------
def get_source_referents(source_handle,db):
    """
    Find objects that refer the source.

    This function finds all primary objects that refer (directly or through
    secondary child-objects) to a given source handle in a given database.
    """

    # Persons
    person_list = [ handle \
            for handle in db.get_person_handles(sort_handles=False) \
            if db.get_person_from_handle(handle).has_source_reference(source_handle)
    ]

    # Families
    family_list = [ handle for handle in db.get_family_handles() \
            if db.get_family_from_handle(handle).has_source_reference(source_handle)
    ]

    # Events
    event_list = [ handle for handle in db.get_event_handles() \
            if db.get_event_from_handle(handle).has_source_reference(source_handle)
    ]

    # Places
    place_list = [ handle for handle in db.get_place_handles() \
            if db.get_place_from_handle(handle).has_source_reference(source_handle)
    ]

    # Sources
    source_list = [ handle for handle in db.get_source_handles() \
            if db.get_source_from_handle(handle).has_source_reference(source_handle)
    ]

    # Media Objects
    media_list = [ handle for handle in db.get_media_object_handles() \
            if db.get_object_from_handle(handle).has_source_reference(source_handle)
    ]

    return (person_list,family_list,event_list,
                place_list,source_list,media_list)

def get_media_referents(media_handle,db):
    """
    Find objects that refer the media object.

    This function finds all primary objects that refer
    to a given media handle in a given database.
    """

    # Persons
    person_list = [ handle \
            for handle in db.get_person_handles(sort_handles=False) \
            if media_handle in \
                    [photo.get_reference_handle() for photo \
                    in db.get_person_from_handle(handle).get_media_list()]
    ]

    # Families
    family_list = [ handle for handle in db.get_family_handles() \
            if media_handle in \
                    [photo.get_reference_handle() for photo \
                    in db.get_family_from_handle(handle).get_media_list()]
    ]

    # Events
    event_list = [ handle for handle in db.get_event_handles() \
            if media_handle in \
                    [photo.get_reference_handle() for photo \
                    in db.get_event_from_handle(handle).get_media_list()]
    ]

    # Places
    place_list = [ handle for handle in db.get_place_handles() \
            if media_handle in \
                    [photo.get_reference_handle() for photo \
                    in db.get_place_from_handle(handle).get_media_list()]
    ]

    # Sources
    source_list = [ handle for handle in db.get_source_handles() \
            if media_handle in \
                    [photo.get_reference_handle() for photo \
                    in db.get_source_from_handle(handle).get_media_list()]
    ]

    return (person_list,family_list,event_list,place_list,source_list)


#-------------------------------------------------------------------------
#
# 
#
#-------------------------------------------------------------------------
_NEW_NAME_PATTERN = '%sUntitled_%d.%s'

def get_new_filename(ext,folder='~/'):
    ix = 1
    while os.path.isfile(os.path.expanduser(_NEW_NAME_PATTERN % (folder,ix,ext) )):
        ix = ix + 1
    return os.path.expanduser(_NEW_NAME_PATTERN % (folder,ix,ext))

def get_type_converter(val):
    """
    Returns function that converts strings into the type of val.
    """
    val_type = type(val)
    if val_type in (str,unicode):
        return unicode
    elif val_type == int:
        return int
    elif val_type == float:
        return float
    elif val_type in (list,tuple):
        return list

def type_name(val):
    """
    Returns the name the type of val.
    
    Only numbers and strings are supported.
    The rest becomes strings (unicode).
    """
    val_type = type(val)
    if val_type == int:
        return 'int'
    elif val_type == float:
        return 'float'
    elif val_type in (str,unicode):
        return 'unicode'
    return 'unicode'

def get_type_converter_by_name(val_str):
    """
    Returns function that converts strings into the type given by val_str.
    
    Only numbers and strings are supported.
    The rest becomes strings (unicode).
    """
    if val_str == 'int':
        return int
    elif val_str == 'float':
        return float
    elif val_str in ('str','unicode'):
        return unicode
    return unicode

def relative_path(original, base):
    if not os.path.exists(original) or  not os.path.isdir(base):
        return original

    base_list = (os.path.abspath(base)).split(os.sep)
    target_list = (os.path.abspath(original)).split(os.sep)

    # Starting from the filepath root, work out how much of the filepath is
    # shared by base and target.

    for i in range(min(len(base_list), len(target_list))):
        if base_list[i] <> target_list[i]: break
    else:
        i+=1
    rel_list = [os.pardir] * (len(base_list)-i) + target_list[i:]
    return os.path.join(*rel_list)

class ProgressMeter:
    """
    Progress meter class for GRAMPS.
    """
    def __init__(self,title,header=''):
        """
        Specify the title and the current pass header.
        """
        self.ptop = gtk.Dialog()
        self.ptop.connect('delete_event',self.warn)
        self.ptop.set_has_separator(False)
        self.ptop.set_title(title)
        self.ptop.set_border_width(12)
        self.ptop.vbox.set_spacing(10)
        lbl = gtk.Label('<span size="larger" weight="bold">%s</span>' % title)
        lbl.set_use_markup(True)
        self.lbl = gtk.Label(header)
        self.lbl.set_use_markup(True)
        self.ptop.vbox.add(lbl)
        self.ptop.vbox.add(self.lbl)
        self.ptop.vbox.set_border_width(24)
        self.pbar = gtk.ProgressBar()

        self.ptop.set_size_request(350,125)
        self.ptop.vbox.add(self.pbar)
        self.ptop.show_all()
        if header == '':
            self.lbl.hide()

    def set_pass(self,header,total):
        """
        Reset for another pass. Provide a new header and define number
        of steps to be used.
        """
        if header == '':
            self.lbl.hide()
        else:
            self.lbl.show()
        self.pbar_max = total
        self.pbar_index = 0.0
        self.lbl.set_text(header)
        self.pbar.set_fraction(0.0)
        while gtk.events_pending():
            gtk.main_iteration()

    def step(self):
        """Click the progress bar over to the next value.  Be paranoid
        and insure that it doesn't go over 100%."""
        self.pbar_index = self.pbar_index + 1.0
        if (self.pbar_index > self.pbar_max):
            self.pbar_index = self.pbar_max

        val = self.pbar_index/self.pbar_max
        
        self.pbar.set_text("%d of %d (%.1f%%)" % (self.pbar_index,self.pbar_max,(val*100)))
        self.pbar.set_fraction(val)
        while gtk.events_pending():
            gtk.main_iteration()

    def warn(self,*obj):
        WarningDialog(
            _("Attempt to force closing the dialog"),
            _("Please do not force closing this important dialog."),
            self.ptop)
        return True

    def close(self):
        """
        Close the progress meter
        """
        self.ptop.destroy()

def launch(prog_str,path):

    subval = {
        '%F'   : path,
        '%f'   : path,
        '%u'   : path,
        '%U'   : path,
        '%n'   : path,
        '%N'   : path,
        }
    
    prog_data = prog_str.split()
    prog = prog_data[0]
    prog_list = []
    need_path = True

    if len(prog_data) > 1:
        for item in prog_data:
            if subval.has_key(item):
                need_path = False
                value = subval[item]
            else:
                value = item
            prog_list.append(value)
    else:
        prog_list = [prog_data[0]]

    if need_path:
        prog_list.append(path)
    os.spawnvpe(os.P_NOWAIT, prog, prog_list, os.environ)