gramps/src/DataViews/GeoView.py

# -*- python -*-
# -*- coding: utf-8 -*-
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2007-2008  Serge Noiraud
# Copyright (C) 2008  Benny Malengier
#
# 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$

"""
Geo View
"""

#-------------------------------------------------------------------------
#
# Python modules
#
#-------------------------------------------------------------------------
from gettext import gettext as _
import os
import urlparse
import const
import operator

#-------------------------------------------------------------------------
#
# GTK/Gnome modules
#
#-------------------------------------------------------------------------
import gtk

#-------------------------------------------------------------------------
#
# Gramps Modules
#
#-------------------------------------------------------------------------
import gen.lib
import PageView
import Utils
import Config
from const import TEMP_DIR
from BasicUtils import name_displayer as _nd
from PlaceUtils import conv_lat_lon

#-------------------------------------------------------------------------
#
# Web interfaces
#
#-------------------------------------------------------------------------

NOWEB  = 0
WEBKIT = 1
MOZIL  = 2

WebKit = NOWEB
try:
    import webkit
    WebKit = WEBKIT
except:
    pass

if WebKit == NOWEB:
    try:
        import gtkmozembed
        WebKit = MOZIL
    except:
        pass

#no interfaces present, raise Error so that options for GeoView do not show
if WebKit == NOWEB :
    Config.set(Config.GEOVIEW, False)
    raise ImportError, 'No GTK html plugin found'

#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
# I think we should set the two following variable in const.py
# They are used only with gtkmozembed.
MOZEMBED_PATH = TEMP_DIR
MOZEMBED_SUBPATH = Utils.get_empty_tempdir('mozembed_gramps')
GEOVIEW_SUBPATH = Utils.get_empty_tempdir('geoview')
NB_MARKERS_PER_PAGE = 200

#-------------------------------------------------------------------------
#
# Renderer
#
#-------------------------------------------------------------------------
class Renderer():
    """
    Renderer renders the webpage. Several backend implementations are 
    possible
    """
    def __init__(self):
        self.window = None
        self.fct = None

    def get_window(self):
        """
        Returns a container class with the widget that contains browser
        window
        """
        return self.window

    def get_uri(self):
        """
        Get the current url
        """
        raise NotImplementedError

    def show_all(self):
        """
        show all in the main window.
        """
        self.window.show_all()

    def open(self, url):
        """
        open the webpage at url
        """
        raise NotImplementedError

    def refresh(self):
        """
        We need to reload the page.
        """
        raise NotImplementedError

    def go_back(self):
        """
        Go to the previous page.
        """
        self.window.go_back()

    def can_go_back(self):
        """
        is the browser able to go backward ?
        """
        return self.window.can_go_back()

    def go_forward(self):
        """
        Go to the next page.
        """
        self.window.go_forward()

    def can_go_forward(self):
        """
        is the browser able to go forward ?
        """
        return self.window.can_go_forward()

    def execute_script(self, url):
        """
        execute javascript in the current html page
        """
        raise NotImplementedError

    def page_loaded(self):
        """
        The page is completely loaded.
        """
        raise NotImplementedError

    def set_button_sensitivity(self):
        """
        We must set the back and forward button in the HtmlView class.
        """
        self.fct()

#-------------------------------------------------------------------------
#
# Renderer with WebKit
#
#-------------------------------------------------------------------------
class RendererWebkit(Renderer):
    """
    Implementation of Renderer with Webkit
    """
    def __init__(self):
        Renderer.__init__(self)
        self.window = webkit.WebView()
        self.browser = WEBKIT
        self.frame = self.window.get_main_frame()
        self.frame.connect("load-done", self.page_loaded)

    def page_loaded(self, obj, status):
        """
        We just loaded one page in the browser.
        Set the button sensitivity 
        """
        self.set_button_sensitivity()

    def open(self, url):
        """
        We need to load the page in the browser.
        """
        self.window.open(url)

    def refresh(self):
        """
        We need to reload the page in the browser.
        """
        self.window.reload()

    def execute_script(self, url):
        """
        We need to execute a javascript function into the browser
        """
        self.window.execute_script(url)

    def get_uri(self):
        """
        What is the uri loaded in the browser ?
        """
        return self.window.get_main_frame().get_uri()

class RendererMozilla(Renderer):
    """
    Implementation of Renderer with gtkmozembed
    """
    def __init__(self):
        Renderer.__init__(self)
        if hasattr(gtkmozembed, 'set_profile_path'):
            set_profile_path = gtkmozembed.set_profile_path
        else:
            set_profile_path = gtkmozembed.gtk_moz_embed_set_profile_path
        set_profile_path(MOZEMBED_PATH, MOZEMBED_SUBPATH)
        self.__set_mozembed_proxy()
        self.window = gtkmozembed.MozEmbed()
        self.browser = MOZIL
        self.handler = self.window.connect("net-stop", self.page_loaded)

    def page_loaded(self, obj):
        """
        We just loaded one page in the browser.
        Set the button sensitivity 
        """
        self.set_button_sensitivity()

    def open(self, url):
        """
        We need to load the page in the browser.
        """
        self.window.load_url(url)

    def execute_script(self, url):
        """
        We need to execute a javascript function into the browser
        """
        self.window.load_url(url)

    def get_uri(self):
        """
        What is the uri loaded in the browser ?
        """
        return self.window.get_location()

    def refresh(self):
        """
        We need to reload the page in the browser.
        """
        self.window.reload(0)

    def __set_mozembed_proxy(self):
        """
        Try to see if we have some proxy environment variable.
        http_proxy in our case.
        The standard format is : http://[user:password@]proxy:port/
        """
        try:
            proxy = os.environ['http_proxy']
            if proxy:
                host_port = None
                prefs = open(MOZEMBED_SUBPATH+"/prefs.js", "w+")
                parts = urlparse.urlparse(proxy)
                if not parts[0] or parts[0] == 'http':
                    host_port = parts[1]
                    hport = host_port.split(':')
                    host = hport[0].strip()
                    if host:
                        try:
                            port = int(hport[1])
                        except:
                            user = host
                            uprox = hport[1].split('@')
                            password = uprox[0]
                            host = uprox[1]
                            port = int(hport[2])

                if port and host:
                    port = str(port)
                    prefs.write('user_pref("network.proxy')
                    prefs.write('.type", 1);\r\n')
                    prefs.write('user_pref("network.proxy')
                    prefs.write('.http", "'+host+'");\r\n')
                    prefs.write('user_pref("network.proxy')
                    prefs.write('.http_port", '+port+');\r\n')
                    prefs.write('user_pref("network.proxy')
                    prefs.write('.no_proxies_on",')
                    prefs.write(' "127.0.0.1,localhost,localhost')
                    prefs.write('.localdomain");\r\n')
                    prefs.write('user_pref("network.proxy')
                    prefs.write('.share_proxy_settings", true);\r\n')
                    prefs.write('user_pref("network.http')
                    prefs.write('.proxy.pipelining", true);\r\n')
                    prefs.write('user_pref("network.http')
                    prefs.write('.proxy.keep-alive", true);\r\n')
                    prefs.write('user_pref("network.http')
                    prefs.write('.proxy.version", 1.1);\r\n')
                    prefs.write('user_pref("network.http')
                    prefs.write('.sendRefererHeader, 0);\r\n')
                prefs.close()
        except:
            try: # trying to remove pref.js in case of proxy change.
                os.remove(MOZEMBED_SUBPATH+"/prefs.js")
            except:
                pass
            pass   # We don't use a proxy or the http_proxy variable is not set.

#-------------------------------------------------------------------------
#
# HtmlView
#
#-------------------------------------------------------------------------
class HtmlView(PageView.PageView):
    """
    HtmlView is a view showing a top widget with controls, and a bottom part
    with an embedded webbrowser showing a given URL
    """

    def __init__(self, dbstate, uistate, title=_('HtmlView')):
        PageView.PageView.__init__(self, title, dbstate, uistate)
        self.dbstate = dbstate
        self.external_url = False
        self.need_to_resize = False
        self.back_action = None
        self.forward_action = None
        self.renderer = None
        self.urlfield = ""
        self.htmlfile = ""
        self.table = ""
        self.bootstrap_handler = None
        self.box = None

    def build_widget(self):
        """
        Builds the interface and returns a gtk.Container type that
        contains the interface. This containter will be inserted into
        a gtk.Notebook page.
        """
        global WebKit
        self.box = gtk.VBox(False, 4)
        #top widget at the top
        self.box.pack_start(self.top_widget(), False, False, 0 )
        #web page under it in a scrolled window
        self.table = gtk.Table(1, 1, False)
        frame = gtk.ScrolledWindow(None, None)
        frame.set_shadow_type(gtk.SHADOW_NONE)
        frame.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        frame.add_with_viewport(self.table)
        self.bootstrap_handler = self.box.connect("size-request", 
                                 self.init_parent_signals_for_map)
        self.table.get_parent().set_shadow_type(gtk.SHADOW_NONE)
        self.table.set_row_spacings(1)
        self.table.set_col_spacings(0)
        if   (WebKit == WEBKIT) :
            # We use webkit
            self.renderer = RendererWebkit()
        elif (WebKit == MOZIL) :
            # We use gtkmozembed
            self.renderer = RendererMozilla()
        self.table.add(self.renderer.get_window())
        self.box.pack_start(frame, True, True, 0)
        # this is used to activate the back and forward button
        # from the renderer class.
        self.renderer.fct = self.set_button_sensitivity
        self.renderer.show_all()
        #load a welcome html page
        urlhelp = self.create_start_page()
        self.open(urlhelp)
        return self.box

    def top_widget(self):
        """
        The default class gives a widget where user can type an url
        """
        hbox = gtk.HBox(False, 4)
        self.urlfield = gtk.Entry()
        self.urlfield.set_text("http://gramps-project.org")
        self.urlfield.connect('activate', self._on_activate)
        hbox.pack_start(self.urlfield, True, True, 4)
        button = gtk.Button(stock=gtk.STOCK_APPLY)
        button.connect('clicked', self._on_activate)
        hbox.pack_start(button, False, False, 4)
        return hbox

    def set_button_sensitivity(self):
        """
        Set the backward and forward button in accordance to the browser.
        """
        self.forward_action.set_sensitive(self.renderer.can_go_forward())
        self.back_action.set_sensitive(self.renderer.can_go_back())
        
    def open(self, url):
        """
        open an url
        """
        self.renderer.open(url)

    def go_back(self, button):
        """
        Go to the previous loaded url.
        """
        self.renderer.go_back()
        self.set_button_sensitivity()
        self.external_uri()

    def go_forward(self, button):
        """
        Go to the next loaded url.
        """
        self.renderer.go_forward()
        self.set_button_sensitivity()
        self.external_uri()

    def refresh(self, button):
        """
        Force to reload the page.
        """
        self.renderer.refresh()

    def external_uri(self):
        """
        used to resize or not resize depending on external or local file.
        """
        uri = self.renderer.get_uri()
        if self.external_url:
            self.external_url = False
            self.need_to_resize = True
        else:
            try:
                if uri.find(self.htmlfile) == -1:
                    # external web page or start_page
                    self.need_to_resize = True
                else:
                    self.need_to_resize = False
            except:
                pass

    def _on_activate(self, nobject):
        """
        Here when we activate the url button.
        """
        url = self.urlfield.get_text()
        if url.find('://') == -1:
            url = 'http://'+ url
        self.external_url = True
        self.open(url)
        
    def build_tree(self):
        """
        Rebuilds the current display. Called from ViewManager
        """
        pass #htmlview is build on click and startup

    def get_stock(self):
        """
        Returns the name of the stock icon to use for the display.
        This assumes that this icon has already been registered with
        GNOME as a stock icon.
        """
        return 'gramps-geo'

    def ui_definition(self):
        """
        Specifies the UIManager XML code that defines the menus and buttons
        associated with the interface.
        """
        return '''<ui>
          <toolbar name="ToolBar">
            <placeholder name="CommonNavigation">
              <toolitem action="Back"/>  
              <toolitem action="Forward"/>  
              <toolitem action="Refresh"/>
            </placeholder>
          </toolbar>
        </ui>'''

    def define_actions(self):
        """
        Required define_actions function for PageView. Builds the action
        group information required. 
        """
        HtmlView._define_actions_fw_bw(self)

    def _define_actions_fw_bw(self):
        """
        prepare the forward and backward buttons.
        add the Backward action to handle the Backward button
        accel doesn't work in webkit and gtkmozembed !
        we must do that ...
        """
        self.back_action = gtk.ActionGroup(self.title + '/Back')
        self.back_action.add_actions([
            ('Back', gtk.STOCK_GO_BACK, _("_Back"), 
             "<ALT>Left", _("Go to the previous page in the history"), 
             self.go_back)
            ])
        self._add_action_group(self.back_action)
        # add the Forward action to handle the Forward button
        self.forward_action = gtk.ActionGroup(self.title + '/Forward')
        self.forward_action.add_actions([
            ('Forward', gtk.STOCK_GO_FORWARD, _("_Forward"), 
             "<ALT>Right", _("Go to the next page in the history"), 
             self.go_forward)
            ])
        self._add_action_group(self.forward_action)
        # add the Refresh action to handle the Refresh button
        self._add_action('Refresh', gtk.STOCK_REFRESH, _("_Refresh"), 
                          callback=self.refresh,
                          accel="<Ctl>R",
                          tip=_("Stop and reload the page."))

    def init_parent_signals_for_map(self, widget, event):
        """
        Required to properly bootstrap the signal handlers.
        This handler is connected by build_widget.
        After the outside ViewManager has placed this widget we are
        able to access the parent container.
        """
        pass

    def create_start_page(self):
        """
        This command creates a default start page, and returns the URL of this
        page.
        """
        tmpdir = GEOVIEW_SUBPATH
        data = """
        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" \
                 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
        <html xmlns="http://www.w3.org/1999/xhtml"  >
         <head>
          <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
          <title>%(title)s</title>
         </head>
         <body >
           <H4>%(content)s</H4>
         </body>
        </html>
        """ % { 'height' : 600,
                'title'  : _('Start page for the Html View'),
                'content': _('Type a webpage address at the top, and hit'
                             ' the execute button to load a webpage in this'
                             ' page\n<br>\n'
                             'For example: <b>http://gramps-project.org</p>')
        }
        filename = os.path.join(tmpdir, 'startpage')
        ufd = file(filename, "w+")
        ufd.write(data)
        ufd.close()
        return 'file://'+filename

#-------------------------------------------------------------------------
#
# GeoView
#
#-------------------------------------------------------------------------
class GeoView(HtmlView):
    """
    The view used to render html pages.
    """

    def __init__(self, dbstate, uistate):
        HtmlView.__init__(self, dbstate, uistate, title=_('GeoView'))
        self.usedmap = "openstreetmap"
        self.displaytype = "person"
        self.nbmarkers = 0
        self.without = 0
        self.nbpages = 0
        self.yearinmarker = []
        self.mustcenter = False
        self.centerlat = 0.0
        self.centerlon = 0.0
        self.setattr = True
        self.latit = 0.0
        self.longt = 0.0
        self.maxlat = 0.0
        self.maxlon = 0.0
        self.height = 0.0
        self.width = 0.0
        self.zoom = 1
        self.minyear = 1
        self.maxyear = 1
        self.maxgen = 1
        self.mapview = None
        self.yearint = 0
        self.centered = True
        self.center = True
        self.place_list = []
        self.htmlfile = ""
        self.places = []
        self.sort = []
        self.without_coord_file = []
        self.place_without_coordinates = []
        self.minlat = float(0.0)
        self.maxlat = float(0.0)
        self.minlon = float(0.0)
        self.key_active_changed = None
 
    def top_widget(self):
        """
        The top widget to use, for GeoView, none
        """
        return gtk.Label()

    def on_delete(self):
        """
        We need to suppress temporary files here.
        """
        pass

    def init_parent_signals_for_map(self, widget, event):
        """
        Required to properly bootstrap the signal handlers.
        This handler is connected by build_widget.
        After the outside ViewManager has placed this widget we are
        able to access the parent container.
        """
        self.box.disconnect(self.bootstrap_handler)
        self.box.parent.connect("size-allocate", self.size_request_for_map)
        self.size_request_for_map(widget.parent, event)

    def size_request_for_map(self, widget, event, data=None):
        """
        We need to resize the map
        """
        gws = widget.get_allocation()
        self.width = gws.width
        self.height = gws.height
        #uri = self.renderer.get_uri()
        self.external_uri()
        if self.need_to_resize != True:
            try:
                self.geo_places(self.displaytype)
            except:
                pass

    def set_active(self):
        """
        Here when we enter in this view.
        """
        self.key_active_changed = self.dbstate.connect('active-changed',
                                                       self.goto_active_person)

    def set_inactive(self):
        """
        Here when we go to another view.
        """
        HtmlView.set_inactive(self)
        self.dbstate.disconnect(self.key_active_changed)

    def get_stock(self):
        """
        Returns the name of the stock icon to use for the display.
        This assumes that this icon has already been registered with
        GNOME as a stock icon.
        """
        return 'gramps-geo'

    def change_map(self, usedmap):
        """
        Ask to the browser to change the current map.
        """
        self.renderer.execute_script(
            "javascript:mapstraction.swap(map,'"+usedmap+"')")

    def ui_definition(self):
        """
        Specifies the UIManager XML code that defines the menus and buttons
        associated with the interface.
        """
        if Config.get(Config.GEOVIEW_GOOGLEMAPS):
            alternate_map = "GoogleMaps"
        elif Config.get(Config.GEOVIEW_OPENLAYERS):
            alternate_map = "OpenLayersMaps"
        elif Config.get(Config.GEOVIEW_YAHOO):
            alternate_map = "YahooMaps"
        elif Config.get(Config.GEOVIEW_MICROSOFT):
            alternate_map = "MicrosoftMaps"
        return '''<ui>
          <toolbar name="ToolBar">
            <placeholder name="CommonNavigation">
              <toolitem action="Back"/>  
              <toolitem action="Forward"/>  
              <toolitem action="Refresh"/>
            </placeholder>
            <placeholder name="CommonEdit">
              <toolitem action="OpenStreetMap"/>
              <toolitem action="%s"/>
              <separator/>
              <toolitem action="PersonMaps"/>
              <toolitem action="FamilyMaps"/>
              <toolitem action="EventMaps"/>
              <toolitem action="AllPlacesMaps"/>
            </placeholder>
          </toolbar>
        </ui>'''  % alternate_map

    def define_actions(self):
        """
        Required define_actions function for PageView. Builds the action
        group information required. 
        """
        HtmlView._define_actions_fw_bw(self)
        self.forward_action.set_sensitive(False)
        self.back_action.set_sensitive(False)
        self._add_action('OpenStreetMap', 'gramps-openstreetmap', 
                         _('_OpenStreetMap'),
                         callback=self.select_openstreetmap_map,
                         tip=_("Select OpenStreetMap Maps"))
        if Config.get(Config.GEOVIEW_GOOGLEMAPS):
            self._add_action('GoogleMaps', 'gramps-alternate-map',
                             _('_Google Maps'),
                             callback=self.select_google_map,
                             tip=_("Select Google Maps."))
        elif Config.get(Config.GEOVIEW_OPENLAYERS):
            self._add_action('OpenLayersMaps', 'gramps-alternate-map',
                             _('_OpenLayers Maps'),
                             callback=self.select_openlayers_map,
                             tip=_("Select OpenLayers Maps."))
        elif Config.get(Config.GEOVIEW_YAHOO):
            self._add_action('YahooMaps', 'gramps-alternate-map', 
                             _('_Yahoo! Maps'),
                             callback=self.select_yahoo_map,
                             tip=_("Select Yahoo Maps."))
        elif Config.get(Config.GEOVIEW_MICROSOFT):
            self._add_action('MicrosoftMaps', 'gramps-alternate-map',
                             _('_Microsoft Maps'),
                             callback=self.select_microsoft_map,
                             tip=_("Select Microsoft Maps"))
        self._add_action('AllPlacesMaps', gtk.STOCK_HOME, _('_All Places'),
	    callback=self.all_places,
	    tip=_("Attempt to view all places in the family tree."))
        self._add_action('PersonMaps', 'gramps-person', _('_Person'),
            callback=self.person_places,
            tip=_("Attempt to view all the places where the selected people lived."))
        self._add_action('FamilyMaps', 'gramps-parents-add', _('_Family'),
            callback=self.family_places,
            tip=_("Attempt to view places of the selected people's family."))
        self._add_action('EventMaps', 'gramps-event', _('_Event'),
            callback=self.event_places,
            tip=_("Attempt to view places connected to all events."))

    def goto_active_person(self, handle=None):
        """
        Here when the GeoView page is loaded
        """
        self.geo_places(self.displaytype)

    def all_places(self, hanle=None):
        """
        Specifies the place for the home person to display with mapstraction.
        """
        self.displaytype = "places"
        self.geo_places(self.displaytype)

    def person_places(self, handle=None):
        """
        Specifies the person places.
        """
        self.displaytype = "person"
        self.geo_places(self.displaytype)

    def family_places(self, hanle=None):
        """
        Specifies the family places to display with mapstraction.
        """
        self.displaytype = "family"
        self.geo_places(self.displaytype)

    def event_places(self, hanle=None):
        """
        Specifies all event places to display with mapstraction.
        """
        self.displaytype = "event"
        self.geo_places(self.displaytype)

    def geo_places(self, displaytype):
        """
        Specifies the places to display with mapstraction.
        """
        self.external_url = False
        self.nbmarkers = 0
        self.without = 0
        self.createmapstraction(displaytype)
        self.open("file://"+self.htmlfile)

    def select_openstreetmap_map(self,handle):
        """
        Specifies openstreetmap is the default map
        """
        self.usedmap = "openstreetmap"        
        self.change_map("openstreetmap")

    def select_openlayers_map(self,handle):
        """
        Specifies openstreetmap is the default map
        """
        self.usedmap = "openlayers"        
        self.change_map("openlayers")

    def select_google_map(self,handle):
        """
        Specifies google is the default map
        """
        self.usedmap = "google"        
        self.change_map("google")

    def select_yahoo_map(self,handle):
        """
        Specifies yahoo map is the default map
        """
        self.usedmap = "yahoo"        
        self.change_map("yahoo")

    def select_microsoft_map(self,handle):
        """
        Specifies microsoft is the default map
        """
        self.usedmap = "microsoft"        
        self.change_map("microsoft")

    def createpageforplaceswithoutcoord(self):
        """
        This command creates a page with the list of all places without coordinates
        page.
        """
        data = """
        <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" \
                 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
        <html xmlns="http://www.w3.org/1999/xhtml"  >
         <head>
          <meta http-equiv="content-type" content="text/html; charset=utf-8"/>
          <title>%(title)s</title>
         </head>
         <body >
           <H4>%(content)s</H4>
        """ % { 'title'  : _('List of places without coordinates'),
                'content': _('Here is the list of all places in the family tree'
                             ' for which we have no coordinates.<br>'
                             ' This means no longitude or latitude.<p>')
        }
        end = """
          </table>
         </body>
        </html>
        """
        ufd = open(self.without_coord_file, "w+")
        ufd.write(data)
        self.places = sorted(self.place_without_coordinates)
        i = 1
        ufd.write("<table border=1 ><th width=10%>NB</th>")
        ufd.write("<th width=20%>Gramps ID</th><th>Place</th>")
        for place in self.places:
            ufd.write("<tr><td>%d</td><td>%s</td><td>%s</td>"
                     % ( i, place[0], place[1] ))
            i += 1
        ufd.write(end)
        ufd.close()

    def createmapstractionpostheader(self, h3mess, h4mess,
                                     maxpages, curpage, ftype):
        """
        This is needed to add infos to the header.
        This can't be in createmapstractionheader because we need
        to know something which is known only after some work.
        """
        self.maxgen = Config.get(Config.GENERATION_DEPTH)
        if self.maxyear == 0:
            self.maxyear = 2100
        if self.minyear == 9999:
            self.minyear = 1500
        period = (self.maxyear-self.minyear)
        intvl = (period/self.maxgen)
        modulo = intvl - ( intvl % 10 )
        if modulo == 0:
            modulo = 10
        self.minyear = ( self.minyear - ( self.minyear % 10 ) )
        self.maxyear = ( self.maxyear - ( self.maxyear % 10 ) )
        self.yearint = (self.maxyear-self.minyear)/self.maxgen
        self.yearint = ( self.yearint - ( self.yearint % modulo ) )
        if self.yearint == 0:
            self.yearint = 10
        self.mapview.write("       var step = %s;\n" % self.yearint)
        self.mapview.write("  </script>\n")
        self.mapview.write(" </head>\n")
        self.mapview.write(" <body >\n")
        if maxpages > 1:
            message = _("There are %d markers to display. They are split up "
                        "over %d pages of %d markers : " % (self.nbmarkers, 
                                            maxpages, NB_MARKERS_PER_PAGE))
            self.mapview.write(" <div id='pages' font=-4 >%s<br>\n" % message)
            if curpage != 1:
                priorfile = GEOVIEW_SUBPATH+"/GeoV-%c-%05d.html" % \
                            (ftype, curpage-1)
                self.mapview.write("<a href='%s' >--</a>" % priorfile)
            else:
                self.mapview.write(" --")
            for page in range(1, maxpages+1, 1):
                if page == curpage:
                    self.mapview.write(" %d" % page)
                else:
                    if ( page < curpage + 11 ) and ( page > curpage - 11 ):
                        nextfile = GEOVIEW_SUBPATH+"/GeoV-%c-%05d.html" % \
                                   (ftype, page)
                        self.mapview.write(" <a href='%s' >%d</a>" % \
                                           (nextfile, page))
            if curpage != maxpages:
                nextfile = GEOVIEW_SUBPATH+"/GeoV-%c-%05d.html" % \
                                           (ftype, curpage+1)
                self.mapview.write(" <a href='%s' >++</a>" % nextfile)
            else:
                self.mapview.write(" ++")
            self.mapview.write("\n</div>\n")
            if self.without != 0:
                self.without_coord_file = GEOVIEW_SUBPATH+"/without_coord.html"
                self.mapview.write("<div id='coord' font=-4 >You have ")
                self.mapview.write("<a href=\"%s\" >%d<a>" % \
                                   ( self.without_coord_file, self.without ) )
                self.mapview.write(" places without coordinates</div>\n" )
                self.createpageforplaceswithoutcoord()
        if self.displaytype != "places":
            self.mapview.write(" <Div id='btns' font=-4 >\n")
            self.mapview.write("  <form method='POST'>\n")
            self.mapview.write("  <input type='radio' ")
            self.mapview.write("name='years' value='All' checked\n")
            self.mapview.write("   onchange=\"selectmarkers")
            self.mapview.write("(\'All\')\"/>%s\n" % _("All"))
            for year in range(self.minyear, self.maxyear+self.yearint,
                              self.yearint):
                self.mapview.write("  <input type='radio' ")
                self.mapview.write("name='years' value=\'%s\'\n" %year)
                self.mapview.write("   onchange=\"selectmarkers")
                self.mapview.write("(\'%s\')\"/>%s\n" % ( year, year ))
            self.mapview.write("  </form></Div>\n")
        self.mapview.write("<H3>%s</H3>" % h3mess)
        if h4mess:
            self.mapview.write("<H4>%s</H4>" % h4mess)

    def createmapstractionheader(self, filename):
        """
        Create the html header of the page.
        """
        self.mapview = open(filename, "w+")
        self.mapview.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD")
        self.mapview.write(" XHTML 1.0 Strict//EN\" \n")
        self.mapview.write("   \"http://www.w3.org/TR/xhtml1/DTD/")
        self.mapview.write("xhtml1-strict.dtd\">\n")
        self.mapview.write("<html xmlns=\"http://www.w3.org/1999/xhtml\" >\n")
        self.mapview.write(" <head>\n")
        self.mapview.write("  <meta http-equiv=\"content-type\" ")
        self.mapview.write("content=\"text/html; charset=utf-8\"/>\n")
        self.mapview.write("  <title>Geo Maps Java Script ")
        self.mapview.write("API for Gramps</title>\n")
        self.mapview.write("  <meta http-equiv=\"Content-Script-Type\" ")
        self.mapview.write("content=\"text/javascript\">\n")
        self.mapview.write("  <script type=\"text/javascript\"\n" )
        self.mapview.write("          src=\"file://"+const.ROOT_DIR+"/")
        self.mapview.write("mapstraction/mapstraction.js\">\n")
        self.mapview.write("  </script>\n")
        if self.usedmap == "microsoft":
            self.mapview.write("  <script type=\"text/javascript\"\n")
            self.mapview.write("          src=\"http://dev.virtualearth.net/")
            self.mapview.write("mapcontrol/mapcontrol.ashx?v=6\">\n")
            self.mapview.write("  </script>\n")
        elif self.usedmap == "yahoo":
            self.mapview.write("  <script type=\"text/javascript\"\n")
            self.mapview.write("          src=\"http://api.maps.yahoo.com/")
            self.mapview.write("ajaxymap?v=3.0&appid=MapstractionDemo\" ")
            self.mapview.write("type=\"text/javascript\">\n")
            self.mapview.write("  </script>\n")
        elif self.usedmap == "openlayers":
            self.mapview.write("  <script type=\"text/javascript\"\n")
            self.mapview.write("          src=\"http://openlayers.org/")
            self.mapview.write("api/OpenLayers.js\">\n")
            self.mapview.write("  </script>\n")
        else: # openstreetmap and google
            self.mapview.write("  <script id=\"googleapiimport\" \n")
            self.mapview.write("          src=\"http://maps.google.com/")
            self.mapview.write("maps?file=api&v=2\"\n")
            self.mapview.write("          type=\"text/javascript\">\n")
            self.mapview.write("  </script>\n")
        self.mapview.write("  <script>\n")
        self.mapview.write("       var gmarkers = [];\n")
        self.mapview.write("       var min = 0;\n")
        self.mapview.write("       var selectedmarkers = 'All';\n")
        self.mapview.write("       // shows or hide markers of a ")
        self.mapview.write("particular category\n")
        self.mapview.write("       function selectmarkers(year) {\n")
        self.mapview.write("         selectedmarkers = year;\n")
        self.mapview.write("         for (var i=0; i<gmarkers.length; i++) {\n")
        self.mapview.write("           val = gmarkers[i].getAttribute")
        self.mapview.write("(\"year\");\n")
        self.mapview.write("           min = parseInt(year);\n")
        self.mapview.write("           max = min + step;\n")
        self.mapview.write("           if ( selectedmarkers == \"All\" ) ")
        self.mapview.write("{ min = 0; max = 9999; }\n")
        self.mapview.write("           gmarkers[i].hide();\n")
        if   self.usedmap == "microsoft":
            self.mapview.write("")
        elif self.usedmap == "yahoo":
            self.mapview.write("")
        elif self.usedmap == "openlayers":
            self.mapview.write("")
        else: # openstreetmap and google
            self.mapview.write("           gmarkers[i].map.")
            self.mapview.write("closeInfoWindow();\n")
        self.mapview.write("           years = val.split(' ');\n")
        self.mapview.write("           for ( j=0; j < years.length; j++) {\n")
        self.mapview.write("               if ( years[j] >= min ) {\n")
        self.mapview.write("                   if ( years[j] < max ) {\n")
        self.mapview.write("                       gmarkers[i].show();\n")
        self.mapview.write("                   }\n")
        self.mapview.write("               }\n")
        self.mapview.write("           }\n")
        self.mapview.write("         }\n")
        self.mapview.write("       }\n")

    def createmapstractiontrailer(self):
        """
        Add the last directives for the html page
        """
        self.mapview.write(" </body>\n")
        self.mapview.write("</html>\n")
        self.mapview.close()

    def create_pages(self, ptype, h3mess, h4mess):
        """
        Do we need to create a multi-pages document ?
        Do we have too many markers ?
        """
        nbmarkers = 0
        self.nbpages = 0
        pages = ( self.nbmarkers / NB_MARKERS_PER_PAGE ) + 1
        if (nbmarkers % NB_MARKERS_PER_PAGE) == 0:
            try:
                self.createmapstractiontrailer()
            except:
                pass
        # Select the center of the map and the zoom
        self.centered = False
        if ptype == 2:
            # Sort by year for events
            self.sort = sorted(self.place_list, key=operator.itemgetter(7))
        else:
            # Sort by place
            self.sort = sorted(self.place_list)
        if self.minlon < 0.0:
            signminlon = 1
        else:
            signminlon = 0
        if self.maxlon < 0.0:
            signmaxlon = 1
        else:
            signmaxlon = 0
        if self.minlat < 0.0:
            signminlat = 1
        else:
            signminlat = 0
        if self.maxlat < 0.0:
            signmaxlat = 1
        else:
            signmaxlat = 0
        if signminlon == signmaxlon: 
            maxlong = abs(abs(self.minlon)-abs(self.maxlon))
        else:
            maxlong = abs(abs(self.minlon)+abs(self.maxlon))
        if signminlat == signmaxlat:
            maxlat = abs(abs(self.minlat)-abs(self.maxlat))
        else:
            maxlat = abs(abs(self.minlat)+abs(self.maxlat))
        # Calculate the zoom. all places must be displayed on the map.
        zoomlat = 2
        if maxlat < 80.0 :
            zoomlat = 3
        if maxlat < 40.0 :
            zoomlat = 4
        if maxlat < 20.0 :
            zoomlat = 5
        if maxlat < 10.0 :
            zoomlat = 6
        if maxlat < 3.0 :
            zoomlat = 7
        if maxlat < 2.0 :
            zoomlat = 8
        if maxlat < 1.0 :
            zoomlat = 9
        if maxlat < 0.5 :
            zoomlat = 10
        if maxlat < 0.2 :
            zoomlat = 11
        if maxlat < 0.1 :
            zoomlat = 12
        zoomlong = 2
        if maxlong < 120.0 :
            zoomlong = 3
        if maxlong < 60.0 :
            zoomlong = 4
        if maxlong < 30.0 :
            zoomlong = 5
        if maxlong < 15.0 :
            zoomlong = 6
        if maxlong < 7.0 :
            zoomlong = 7
        if maxlong < 4.0 :
            zoomlong = 8
        if maxlong < 2.0 :
            zoomlong = 9
        if maxlong < 1.0 :
            zoomlong = 10
        if maxlong < 0.5 :
            zoomlong = 11
        if maxlong < 0.2 :
            zoomlong = 12
        if maxlong < 0.1 :
            zoomlong = 13
        if zoomlat < zoomlong:
            self.zoom = zoomlat
        else:
            self.zoom = zoomlong
        self.zoom -= 1
        if self.zoom < 2:
            self.zoom = 2
        # We center the map on a point at the center of all markers
        self.centerlat = maxlat/2
        self.centerlon = maxlong/2
        latit = 0.0
        longt = 0.0
        for mark in self.sort:
            cent = int(mark[6])
            if cent:
                self.centered = True

                if ( signminlat == signmaxlat ):
                    if signminlat == 1: 
                        latit = self.minlat+self.centerlat
                    else:
                        latit = self.maxlat-self.centerlat
                elif self.maxlat > self.centerlat:
                    latit = self.maxlat-self.centerlat
                else:
                    latit = self.minlat+self.centerlat

                if ( signminlon == signmaxlon ):
                    if signminlon == 1: 
                        longt = self.minlon+self.centerlon
                    else:
                        longt = self.maxlon-self.centerlon
                elif self.maxlon > self.centerlon:
                    longt = self.maxlon-self.centerlon
                else:
                    longt = self.minlon+self.centerlon
                # all maps: 0.0 for longitude and latitude means no location.
                if latit == 0.0 and longt == 0.0:
                    latit = 0.00000001
                    longt = 0.00000001

        self.mustcenter = False
        if latit != 0.0 or longt != 0.0:
            self.latit = latit
            self.longt = longt
            self.mustcenter = True
        for page in range(0, pages, 1):
            self.nbpages += 1
            if   ptype == 1:
                ftype = "P"
            elif ptype == 2:
                ftype = "E"
            elif ptype == 3:
                ftype = "F"
            elif ptype == 4:
                ftype = "I"
            else:
                ftype = "X"
            filename = GEOVIEW_SUBPATH+"/GeoV-%c-%05d.html" % \
                       (ftype, self.nbpages)
            if self.nbpages == 1:
                self.htmlfile = filename
            self.createmapstractionheader(filename)
            self.createmapstractionpostheader(h3mess, h4mess, 
                                              pages, self.nbpages, ftype)
            first = ( self.nbpages - 1 ) * NB_MARKERS_PER_PAGE 
            last = ( self.nbpages * NB_MARKERS_PER_PAGE ) - 1
            self.create_markers(ptype, first, last)
            self.createmapstractiontrailer()
            if self.nbpages == 1:
                self.open(self.htmlfile)

    def createmapstraction(self, displaytype):
        """
        Which kind of map are we going to create ?
        """
        if displaytype == "places":
            self.createmapstractionplaces(self.dbstate)
        elif displaytype == "family":
            self.createmapstractionfamily(self.dbstate)
        elif displaytype == "person":
            self.createmapstractionperson(self.dbstate)
        elif displaytype == "event":
            self.createmapstractionevents(self.dbstate)
        else:
            self.createmapstractionheader(GEOVIEW_SUBPATH+"/error.html")
            self.createmapnotimplemented()
            self.createmapstractiontrailer()

    def append_to_places_without_coord(self, gid, place):
        """
        Create a list of places without coordinates
        """
        self.place_without_coordinates.append([gid, place])
        self.without += 1

    def append_to_places_list(self, place, evttype, name, lat, 
                              longit, descr, center, year):
        """
        Create a list of places with coordinates
        """
        self.place_list.append([place, name, evttype, lat,
                                longit, descr, int(center), year])
        self.nbmarkers += 1

        tfa = float(lat)
        tfb = float(longit)
        if year is not None:
            tfc = int(year)
            if tfc != 0:
                if tfc < self.minyear:
                    self.minyear = tfc
                if tfc > self.maxyear:
                    self.maxyear = tfc

        if tfa < 0.0:
            tfa = tfa - 0.00000001
        else:
            tfa = tfa + 0.00000001
        if tfb < 0.0:
            tfb = tfb - 0.00000001
        else:
            tfb = tfb + 0.00000001

        if self.minlat == 0.0:
            self.minlat = tfa
        if tfa < self.minlat:
            if tfa < 0.0:
                self.minlat = tfa

        if self.maxlat == 0.0:
            self.maxlat = tfa
        if tfa > self.maxlat:
            if tfa > 0.0:
                self.maxlat = tfa

        if self.minlon == 0.0:
            self.minlon = tfb
        if tfb < self.minlon:
            if tfb < 0.0:
                self.minlon = tfb

        if self.maxlon == 0.0:
            self.maxlon = tfb
        if tfb > self.maxlon:
            if tfb > 0.0:
                self.maxlon = tfb

    def isyearnotinmarker(self, allyears, yeartosearch):
        """
        This function is used to find if a year is in a list
        """
        ret = 1
        for year in allyears:
            if yeartosearch == year:
                ret = 0
        return ret

    def create_markers(self, format, firstm, lastm):
        """
        This function create all markers for the specified person.
        """
        margin = 10
        self.mapview.write("  <div id=\"map\" style=\"width: %dpx; " % \
                           ( self.width - margin*4 ))
        self.mapview.write("height: %dpx\"></div>\n" % ( self.height * 0.74 ))
        self.mapview.write("  <script type=\"text/javascript\">\n")
        self.mapview.write("   var mapstraction = new Mapstraction")
        self.mapview.write("('map','%s');\n" % self.usedmap)
        self.mapview.write("   mapstraction.addControls(")
        self.mapview.write("{ pan: true, zoom: 'large', ")
        self.mapview.write("overview: true, scale: true, map_type: true });\n")
        last = ""
        indm = 0
        divclose = True
        self.yearinmarker = []
        ininterval = False
        self.setattr = True
        if self.mustcenter:
            self.centered = True
            self.mapview.write("var point = new LatLonPoint")
            self.mapview.write("(%s,%s);" % (self.latit, self.longt))
            self.mapview.write("mapstraction.setCenterAndZoom")
            self.mapview.write("(point, %s);" % self.zoom)
            self.setattr = False
        for mark in self.sort:
            if ( indm >= firstm ) and ( indm <= lastm ):
                ininterval = True
            if ininterval:
                if last != mark[0]:
                    if not divclose:
                        if ininterval:
                            self.mapview.write("</div>\");")
                            divclose = True
                        years = ""
                        if mark[2]:
                            for year in self.yearinmarker:
                                years += "%d " % year
                        years += "end"
                        self.mapview.write("my_marker.setAttribute")
                        self.mapview.write("('year','%s');" % years)
                        self.yearinmarker = []
                        self.mapview.write("mapstraction.addMarker(my_marker);")
                    indm += 1
                    if ( indm > lastm ):
                        if (indm % NB_MARKERS_PER_PAGE) == 0:
                            ininterval = False
                    last = mark[0]
                    if ( indm >= firstm ) and ( indm <= lastm ):
                        self.mapview.write("\nvar point = new LatLonPoint")
                        self.mapview.write("(%s,%s);" % (mark[3], mark[4]))
                        self.mapview.write("my_marker = new Marker(point);")
                        self.mapview.write("gmarkers[%d]=my_marker;" % \
                                           (( indm - 1 ) % NB_MARKERS_PER_PAGE))
                        self.mapview.write("my_marker.setLabel")
                        self.mapview.write("(\"%s\");" % mark[0])
                        self.yearinmarker.append(mark[7])
                        divclose = False
                        self.mapview.write("my_marker.setInfoBubble(\"<div ")
                        self.mapview.write("style='white-space:nowrap;' >")
                        if format == 1:
                            self.mapview.write("%s<br>____________<br>" % \
                                               mark[0])
                            self.mapview.write("<br>%s" % mark[5])
                        elif format == 2:
                            self.mapview.write("%s____________<br>" % mark[1])
                            self.mapview.write("<br>%s - %s" % (mark[7],
                                                                mark[5]))
                        elif format == 3:
                            self.mapview.write("%s<br>____________<br>" % \
                                               mark[0])
                            self.mapview.write("<br>%s - %s" % (mark[7],
                                                                mark[5]))
                        elif format == 4:
                            self.mapview.write("%s<br>____________<br>" % \
                                               mark[0])
                            self.mapview.write("<br>%s - %s" % (mark[7],
                                                                mark[5]))
                else: # This marker already exists. add info.
                    self.mapview.write("<br>%s - %s" % (mark[7], mark[5]))
                    if self.isyearnotinmarker(self.yearinmarker, mark[7]):
                        self.yearinmarker.append(mark[7])
            else:
                indm += 1
        if self.nbmarkers > 0 and ininterval:
            years = ""
            if mark[2]:
                for year in self.yearinmarker:
                    years += "%d " % year
            years += "end"
            self.mapview.write("</div>\");")
            self.mapview.write("my_marker.setAttribute('year','%s');" % years)
            self.mapview.write("mapstraction.addMarker(my_marker);")
        if self.nbmarkers == 0:
            # We have no valid geographic point to center the map.
            # So you'll see the street where I live.
            # I think another place should be better :
            #          Where is the place where the gramps project began ?
            #
            # I think we should put here all gramps developpers.
            # not only me ...
            #
            longitude = 0.0
            latitude = 0.0
            self.mapview.write("\nvar point = new LatLonPoint")
            self.mapview.write("(%s,%s);\n" % (latitude, longitude))
            self.mapview.write("   mapstraction.setCenterAndZoom")
            self.mapview.write("(point, %d);\n" % 2)
            self.mapview.write("   my_marker = new Marker(point);\n")
            self.mapview.write("   my_marker.setLabel")
            self.mapview.write("(\"%s\");\n" % _("No location."))
            self.mapview.write("   my_marker.setInfoBubble(\"<div ")
            self.mapview.write("style='white-space:nowrap;' >")
            self.mapview.write(_("You have no places in your family tree "
                                 " with coordinates."))
            self.mapview.write("<br>")
            self.mapview.write(_("You are looking at the default map."))
            self.mapview.write("</div>\");\n")
            self.mapview.write("   mapstraction.addMarker(my_marker);")
        self.mapview.write("\n  </script>\n")

    def createpersonmarkers(self, dbstate, person, comment):
        """
        This function create all markers for the specified person.
        """
        latitude = ""
        longitude = ""
        if person:
            birth_ref = person.get_birth_ref()
            if birth_ref:
                birth = dbstate.db.get_event_from_handle(birth_ref.ref)
                birthdate = birth.get_date_object()
                birthyear = birthdate.get_year()
                bplace_handle = birth.get_place_handle()
                if bplace_handle:
                    place = dbstate.db.get_place_from_handle(bplace_handle)
                    longitude = place.get_longitude()
                    latitude = place.get_latitude()
                    latitude, longitude = conv_lat_lon(latitude,
                                                       longitude, "D.D8")
                    if comment:
                        descr1 = _("%(comment)s : birth place.") % {
                                            'comment': comment}
                    else:
                        descr1 = _("birth place.")
                    descr = place.get_title()
                    # place.get_longitude and place.get_latitude return
                    # one string. We have coordinates when the two values
                    # contains non null string.
                    if ( longitude and latitude ):
                        self.append_to_places_list(descr,
                                                   gen.lib.EventType.BIRTH, 
                                                   _nd.display(person),
                                                   latitude, longitude,
                                                   descr1, int(self.center),
                                                   birthyear)
                        self.center = False
                    else:
                        self.append_to_places_without_coord(place.gramps_id,
                                                            descr)
            latitude = ""
            longitude = ""
            death_ref = person.get_death_ref()
            if death_ref:
                death = dbstate.db.get_event_from_handle(death_ref.ref)
                deathdate = death.get_date_object()
                deathyear = deathdate.get_year()
                dplace_handle = death.get_place_handle()
                if dplace_handle:
                    place = dbstate.db.get_place_from_handle(dplace_handle)
                    longitude = place.get_longitude()
                    latitude = place.get_latitude()
                    latitude, longitude = conv_lat_lon(latitude,
                                                       longitude, "D.D8")
                    descr = place.get_title()
                    if comment:
                        descr1 = _("%(comment)s : death place.") % {
                                            'comment': comment} 
                    else:
                        descr1 = _("death place.")
                    # place.get_longitude and place.get_latitude return
                    # one string. We have coordinates when the two values
                    # contains non null string.
                    if ( longitude and latitude ):
                        self.append_to_places_list(descr,
                                                   gen.lib.EventType.DEATH,
                                                   _nd.display(person),
                                                   latitude, longitude,
                                                   descr1, int(self.center),
                                                   deathyear)
                        self.center = False
                    else:
                        self.append_to_places_without_coord(place.gramps_id,
                                                            descr)

    def createmapstractionplaces(self, dbstate):
        """
        This function create the marker for each place in the database
        which has a lat/lon.
        """
        self.place_list = []
        self.place_without_coordinates = []
        self.minlat = float(0.0)
        self.maxlat = float(0.0)
        self.minlon = float(0.0)
        self.maxlon = float(0.0)
        self.minyear = int(9999)
        self.maxyear = int(0)
        latitude = ""
        longitude = ""
        self.center = True
        for place_handle in dbstate.db.get_place_handles():
            place = dbstate.db.get_place_from_handle( place_handle)
            if place:
                descr = place.get_title()
                descr1 = _("Id : %s") % place.gramps_id
                longitude = place.get_longitude()
                latitude = place.get_latitude()
                latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
                # place.get_longitude and place.get_latitude return
                # one string. We have coordinates when the two values
                # contains non null string.
                if ( longitude and latitude ):
                    self.append_to_places_list(descr, None,
                                               "",
                                               latitude, longitude,
                                               descr1, self.center, None)
                    self.center = False
                else:
                    self.append_to_places_without_coord(place.gramps_id,
                                                              descr)
        if self.center:
            mess = _("Cannot center the map. No location with coordinates.")
        else:
            mess = ""
        self.create_pages(1,
                          _("All places in the family tree with coordinates."),
                          mess)

    def createmapstractionevents(self, dbstate):
        """
        This function create one marker for each place associated with an event in the database
        which has a lat/lon.
        """
        self.place_list = []
        self.place_without_coordinates = []
        self.minlat = float(0.0)
        self.maxlat = float(0.0)
        self.minlon = float(0.0)
        self.maxlon = float(0.0)
        self.minyear = int(9999)
        self.maxyear = int(0)
        latitude = ""
        longitude = ""
        self.center = True
        for event_handle in dbstate.db.get_event_handles():
            event = dbstate.db.get_event_from_handle( event_handle)
            if event:
                pl_id = event.get_place_handle()
                eventdate = event.get_date_object()
                eventyear = eventdate.get_year()
                descr1 = _("Id : %(id)s (%(year)s)") % {
                                'id' : event.gramps_id,
                                'year' : eventyear}
                if pl_id:
                    place = dbstate.db.get_place_from_handle(pl_id)
                    longitude = place.get_longitude()
                    latitude = place.get_latitude()
                    latitude, longitude = conv_lat_lon(latitude, longitude, 
                                                       "D.D8")
                    city = place.get_main_location().get_city()
                    country = place.get_main_location().get_country()
                    descr2 = "%s; %s" % (city, country)
                    # place.get_longitude and place.get_latitude return
                    # one string. We have coordinates when the two values
                    # contains non null string.
                    if ( longitude and latitude ):
                        person_list = [dbstate.db.get_person_from_handle(ref_handle)
                            for (ref_type, ref_handle) in \
                                dbstate.db.find_backlink_handles(event_handle)
                                    if ref_type == 'Person' 
                                      ]
                        if person_list:
                            descr = "<br>"
                            for person in person_list:
                                descr = ("%(description)s%(name)s<br>") % {
                                            'description' : descr, 
                                            'name' : _nd.display(person)}
                            descr = ("%(eventtype)s; %(place)s%(description)s"
                                     ) % { 'eventtype': gen.lib.EventType(
                                                            event.get_type()),
                                            'place': place.get_title(), 
                                            'description': descr}
                        else:
                            descr = ("%(eventtype)s; %(place)s<br>") % {
                                            'eventtype': gen.lib.EventType(
                                                            event.get_type()),
                                            'place': place.get_title()}
                        self.append_to_places_list(descr1, descr,
                                                   descr,
                                                   latitude, longitude,
                                                   descr2, self.center,
                                                   eventyear)
                        self.center = False
                    else:
                        descr = place.get_title()
                        self.append_to_places_without_coord(place.gramps_id,
                                                            descr)
        if self.center:
            mess = _("Cannot center the map. No location with coordinates.")
        else:
            mess = ""
        self.create_pages(2, _("All events in the family tree with coordinates."
                             ), mess)

    def createmapstractionfamily(self, dbstate):
        """
        This function create all markers for each people of a family
        in the database which has a lat/lon.
        """
        self.place_list = []
        self.place_without_coordinates = []
        self.minlat = float(0.0)
        self.maxlat = float(0.0)
        self.minlon = float(0.0)
        self.maxlon = float(0.0)
        self.minyear = int(9999)
        self.maxyear = int(0)
        self.center = True
        person = None
        if dbstate.active:
            person = dbstate.active
        if person is not None:
            family_list = person.get_family_handle_list()
            if len(family_list) > 0:
                fhandle = family_list[0] # first is primary
                fam = dbstate.db.get_family_from_handle(fhandle)
                father_handle = fam.get_father_handle()
                father = dbstate.db.get_person_from_handle(father_handle)
                if father:
                    comment = _("Id : Father : %s") % father.gramps_id
                    self.createpersonmarkers(dbstate, father, comment)
                mother_handle = fam.get_mother_handle()
                mother = dbstate.db.get_person_from_handle(mother_handle)
                if mother:
                    comment = _("Id : Mother : %s") % mother.gramps_id
                    self.createpersonmarkers(dbstate, mother, comment)
                index = 0
                child_ref_list = fam.get_child_ref_list()
                if child_ref_list:
                    for child_ref in child_ref_list:
                        child = dbstate.db.get_person_from_handle(child_ref.ref)
                        if child:
                            index += 1
                            comment = _("Id : Child : %(id)s %(index)d") % {
                                            'id' : child.gramps_id,
                                            'index': index}
                            self.createpersonmarkers(dbstate, child, comment)
        if self.center:
            mess = _("Cannot center the map. No location with coordinates.")
            if person is not None:
                self.create_pages(3, _("The active person's family members "
                                       "have no places with coordinates."), 
                                    mess)
            else:
                self.create_pages(3, _("No active person set."), mess)
        else:
            mess = ""
            self.create_pages(3,
                              ( _("All %(name)s people's family places in the "
                                  "family tree with coordinates.") % {
                                     'name' :_nd.display(person) }),
                                mess)

    def createmapstractionperson(self, dbstate):
        """
        This function create all markers for each people's event
        in the database which has a lat/lon.
        """
        self.place_list = []
        self.place_without_coordinates = []
        self.minlat = float(0.0)
        self.maxlat = float(0.0)
        self.minlon = float(0.0)
        self.maxlon = float(0.0)
        self.minyear = int(9999)
        self.maxyear = int(0)
        latitude = ""
        longitude = ""
        person = None
        if dbstate.active:
            person = dbstate.active
        self.center = True
        if person is not None:
            # For each event, if we have a place, set a marker.
            for event_ref in person.get_event_ref_list():
                if not event_ref:
                    continue
                if event_ref.role != gen.lib.EventRoleType.PRIMARY:
                    # Only match primaries, no witnesses
                    continue
                event = dbstate.db.get_event_from_handle(event_ref.ref)
                eventdate = event.get_date_object()
                eventyear = eventdate.get_year()
                place_handle = event.get_place_handle()
                if place_handle:
                    place = dbstate.db.get_place_from_handle(place_handle)
                    longitude = place.get_longitude()
                    latitude = place.get_latitude()
                    latitude, longitude = conv_lat_lon(latitude,
                                                       longitude, "D.D8")
                    descr = place.get_title()
                    evt = gen.lib.EventType(event.get_type())
                    descr1 = _("%(eventtype)s : %(name)s") % {
                                    'eventtype': evt,
                                    'name': _nd.display(person)}
                    # place.get_longitude and place.get_latitude return
                    # one string. We have coordinates when the two values
                    # contains non null string.
                    if ( longitude and latitude ):
                        self.append_to_places_list(descr, evt,
                                                   _nd.display(person),
                                                   latitude, longitude,
                                                   descr1, self.center, 
                                                   eventyear)
                        self.center = False
                    else:
                        self.append_to_places_without_coord(
                                                        place.gramps_id, descr)
        if self.center:
            mess = _("Cannot center the map. No location with coordinates.")
            if person is not None:
                self.create_pages(4, 
                _("The active person has no places with coordinates."), mess)
            else:
                self.create_pages(4, _("No active person set."), mess)
        else:
            mess = ""
            self.create_pages(4, ( _("All event places for %s.") % 
                                        _nd.display(person) ), mess)

    def createmapnotimplemented(self):
        """
        This function is used to inform the user this work is not implemented.
        """
        self.mapview.write("  <H1>%s </H1>" % _("Not yet implemented ..."))