1629 lines
64 KiB
Python
1629 lines
64 KiB
Python
# -*- 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$
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Python modules
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
from gettext import gettext as _
|
|
from cgi import escape
|
|
import math
|
|
import os
|
|
import tempfile
|
|
import urlparse
|
|
import const
|
|
import gobject
|
|
import threading
|
|
import time
|
|
import operator
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# GTK/Gnome modules
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
import gtk
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Set up logging
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
import logging
|
|
LOG = logging.getLogger(".GeoView")
|
|
#LOG.setLevel(logging.DEBUG)
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# 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'
|
|
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Gramps Modules
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# 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):
|
|
raise NotImplementedError
|
|
|
|
def show_all(self):
|
|
self.window.show_all()
|
|
|
|
def open(self, url):
|
|
""" open the webpage at url
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def refresh(self):
|
|
raise NotImplementedError
|
|
|
|
def go_back(self):
|
|
self.window.go_back();
|
|
|
|
def can_go_back(self):
|
|
return self.window.can_go_back()
|
|
|
|
def go_forward(self):
|
|
self.window.go_forward();
|
|
|
|
def can_go_forward(self):
|
|
return self.window.can_go_forward()
|
|
|
|
def execute_script(self, url):
|
|
""" execute script in the current html page
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def page_loaded(self):
|
|
raise NotImplementedError
|
|
|
|
def page_begin_load(self):
|
|
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)
|
|
self.window.connect("load-started", self.page_begin_load)
|
|
self.window.connect("hovering-over-link", self.hover_link_cb)
|
|
#self.window.connect("navigation-requested", self.navigation)
|
|
self.window.connect("load-progress-changed", self.load_progress)
|
|
#self.window.connect("script-alert", self.script_alert_cb)
|
|
#self.window.connect("script-confirm", self.script_confirm_cb)
|
|
#self.window.connect("script-prompt", self.script_prompt_cb)
|
|
|
|
def page_loaded(self,obj,status):
|
|
self.set_button_sensitivity()
|
|
|
|
def page_begin_load(self,view,frame):
|
|
if frame is self.frame:
|
|
LOG.debug("load-started : %s" % self.get_uri())
|
|
pass
|
|
|
|
def navigation(self,view,frame,networkrequest):
|
|
LOG.debug("navigation-requested : %s" % frame.get_uri())
|
|
return 1
|
|
|
|
def load_progress(self,view,percent):
|
|
#LOG.debug(_("load-progress-changed : load %s : %s%%") % (view.get_main_frame().get_uri(), percent))
|
|
pass
|
|
|
|
def hover_link_cb(self,view,title,url):
|
|
if view and url:
|
|
LOG.debug("hovering-over-link : %s - %s" % (title, url))
|
|
|
|
def script_confirm_cb(self, view, frame, message, isConfirmed):
|
|
LOG.debug("script confirm")
|
|
pass
|
|
|
|
def window_event_cb(self, view, event, message, fromwindow):
|
|
LOG.debug("event!", event, view, message )
|
|
LOG.debug(event.get_event_type() )
|
|
return True
|
|
|
|
def script_prompt_cb(self, view, frame, message, default, text):
|
|
LOG.debug("script prompt")
|
|
pass
|
|
|
|
def open(self, url):
|
|
self.window.open(url)
|
|
|
|
def refresh(self):
|
|
self.window.reload();
|
|
|
|
def execute_script(self,url):
|
|
self.window.execute_script(url);
|
|
|
|
def get_uri(self):
|
|
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)
|
|
self.handler = self.window.connect("net-start", self.page_begin_load)
|
|
|
|
def page_loaded(self,obj):
|
|
self.set_button_sensitivity()
|
|
|
|
def page_begin_load(self,obj):
|
|
LOG.debug("Loading - %s" % self.get_uri())
|
|
pass
|
|
|
|
def open(self, url):
|
|
self.window.load_url(url)
|
|
|
|
def execute_script(self,url):
|
|
self.window.load_url(url);
|
|
|
|
def get_uri(self):
|
|
return self.window.get_location()
|
|
|
|
def refresh(self):
|
|
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]
|
|
t = host_port.split(':')
|
|
host = t[0].strip()
|
|
if host:
|
|
try:
|
|
port = int(t[1])
|
|
except:
|
|
user = host
|
|
u = t[1].split('@')
|
|
password = u[0]
|
|
host = u[1]
|
|
port = int(t[2])
|
|
|
|
if port and host:
|
|
port = str(port)
|
|
prefs.write('user_pref("network.proxy.type", 1);\r\n')
|
|
prefs.write('user_pref("network.proxy.http", "'+host+'");\r\n')
|
|
prefs.write('user_pref("network.proxy.http_port", '+port+');\r\n')
|
|
prefs.write('user_pref("network.proxy.no_proxies_on", '\
|
|
'"127.0.0.1,localhost,localhost.localdomain");\r\n')
|
|
prefs.write('user_pref("network.proxy.share_proxy_settings", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.pipelining", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.keep-alive", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.version", 1.1);\r\n')
|
|
prefs.write('user_pref("network.http.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
|
|
|
|
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):
|
|
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):
|
|
self.renderer.go_back();
|
|
self.set_button_sensitivity()
|
|
self.external_uri()
|
|
|
|
def go_forward(self, button):
|
|
self.renderer.go_forward();
|
|
self.set_button_sensitivity()
|
|
self.external_uri()
|
|
|
|
def refresh(self,button):
|
|
self.renderer.refresh();
|
|
|
|
def external_uri(self):
|
|
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, object):
|
|
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):
|
|
# 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 an 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')
|
|
fd = file(filename,"w+")
|
|
fd.write(data)
|
|
fd.close()
|
|
return 'file://'+filename
|
|
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# GeoView
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class GeoView(HtmlView):
|
|
|
|
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
|
|
|
|
# We use the top_widget method defined in HtmlView.
|
|
#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):
|
|
v = widget.get_allocation()
|
|
self.width = v.width
|
|
self.height = v.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):
|
|
self.key_active_changed = self.dbstate.connect('active-changed',
|
|
self.goto_active_person)
|
|
|
|
def set_inactive(self):
|
|
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):
|
|
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):
|
|
self.geo_places(self.displaytype)
|
|
|
|
def all_places(self,handle=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,handle=None):
|
|
"""
|
|
Specifies the family places to display with mapstraction.
|
|
"""
|
|
self.displaytype = "family"
|
|
self.geo_places(self.displaytype)
|
|
|
|
def event_places(self,handle=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=None):
|
|
self.change_map("openstreetmap")
|
|
|
|
def select_openlayers_map(self,handle=None):
|
|
self.change_map("openlayers")
|
|
|
|
def select_google_map(self,handle=None):
|
|
self.change_map("google")
|
|
|
|
def select_yahoo_map(self,handle=None):
|
|
self.change_map("yahoo")
|
|
|
|
def select_microsoft_map(self,handle=None):
|
|
self.change_map("microsoft")
|
|
|
|
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/
|
|
This function is only used with gtkmozembed.
|
|
"""
|
|
try:
|
|
proxy = os.environ['http_proxy']
|
|
data = ""
|
|
if proxy:
|
|
prefs = open(MOZEMBED_PATH+MOZEMBED_SUBPATH+"/prefs.js","w")
|
|
host_port = None
|
|
parts = urlparse.urlparse(proxy)
|
|
if not parts[0] or parts[0] == 'http':
|
|
host_port = parts[1]
|
|
t = host_port.split(':')
|
|
host = t[0].strip()
|
|
if host:
|
|
try:
|
|
port = int(t[1])
|
|
except:
|
|
user = host
|
|
u = t[1].split('@')
|
|
password = u[0]
|
|
host = u[1]
|
|
port = int(t[2])
|
|
|
|
if port and host:
|
|
port = str(port)
|
|
prefs.write('user_pref("network.proxy.type", 1);\r\n')
|
|
prefs.write('user_pref("network.proxy.http", "'+host+'");\r\n')
|
|
prefs.write('user_pref("network.proxy.http_port", '+port+');\r\n')
|
|
prefs.write('user_pref("network.proxy.no_proxies_on", "127.0.0.1,localhost,localhost.localdomain");\r\n')
|
|
prefs.write('user_pref("network.proxy.share_proxy_settings", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.pipelining", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.keep-alive", true);\r\n')
|
|
prefs.write('user_pref("network.http.proxy.version", 1.1);\r\n')
|
|
prefs.write('user_pref("network.http.sendRefererHeader, 0);\r\n')
|
|
prefs.close()
|
|
except:
|
|
try: # trying to remove pref.js in case of proxy change.
|
|
os.remove(MOZEMBED_PATH+MOZEMBED_SUBPATH+"/prefs.js")
|
|
except:
|
|
pass
|
|
pass # We don't use a proxy or the http_proxy variable is not set.
|
|
|
|
def create_page_for_places_without_coordinates(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>
|
|
"""
|
|
fd = open(self.without_coord_file,"w+")
|
|
fd.write(data)
|
|
self.places = sorted(self.place_without_coordinates)
|
|
i = 1
|
|
fd.write("<table border=1 ><th width=10%>NB</th><th width=20%>Gramps ID</th><th>Place</th>")
|
|
for place in self.places:
|
|
fd.write("<tr><td>%d</td><td>%s</td><td>%s</td>" % ( i, place[0], place[1] ))
|
|
i += 1
|
|
fd.write(end)
|
|
fd.close()
|
|
|
|
def createMapstractionPostHeader(self,h3mess,h4mess,maxpages,curpage,ftype):
|
|
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 <a href=\"%s\" >%d<a>" % ( self.without_coord_file, self.without ) )
|
|
self.mapview.write(" places without coordinates<a href=\"gramps://place:P0005\" >test</a></div>\n" )
|
|
self.create_page_for_places_without_coordinates()
|
|
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' name='years' value='All' checked\n")
|
|
self.mapview.write(" onchange=\"selectmarkers(\'All\')\"/>All\n")
|
|
for year in range(self.minyear,self.maxyear+self.yearint,self.yearint):
|
|
self.mapview.write(" <input type='radio' name='years' value=\'%s\'\n" %year)
|
|
self.mapview.write(" onchange=\"selectmarkers(\'%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):
|
|
self.mapview = open(filename,"w+")
|
|
self.mapview.write("<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \n")
|
|
self.mapview.write(" \"http://www.w3.org/TR/xhtml1/DTD/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\" content=\"text/html; charset=utf-8\"/>\n")
|
|
self.mapview.write(" <title>Geo Maps JavaScript API for Gramps</title>\n")
|
|
self.mapview.write(" <meta http-equiv=\"Content-Script-Type\" content=\"text/javascript\">\n")
|
|
self.mapview.write(" <script type=\"text/javascript\"\n" )
|
|
self.mapview.write(" src=\"file://"+const.ROOT_DIR+"/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/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/ajaxymap?v=3.0&appid=MapstractionDemo\" 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/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/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 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(\"year\");\n")
|
|
self.mapview.write(" min = parseInt(year);\n")
|
|
self.mapview.write(" max = min + step;\n")
|
|
self.mapview.write(" if ( selectedmarkers == \"All\" ) { 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.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):
|
|
self.mapview.write(" </body>\n")
|
|
self.mapview.write("</html>\n")
|
|
self.mapview.close()
|
|
|
|
def create_pages(self,type,h3mess,h4mess):
|
|
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 type == 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
|
|
# for 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
|
|
|
|
LOG.debug( "self.maxlon = %f\n" % self.maxlon)
|
|
LOG.debug("self.minlon = %f\n" % self.minlon)
|
|
LOG.debug("self.maxlat = %f\n" % self.maxlat)
|
|
LOG.debug("self.minlat = %f\n" % self.minlat)
|
|
LOG.debug("signminlon = %f\n" % signminlon )
|
|
LOG.debug("signmaxlon = %f\n" % signmaxlon )
|
|
LOG.debug("signminlat = %f\n" % signminlat )
|
|
LOG.debug("signmaxlat = %f\n" % signmaxlat )
|
|
LOG.debug("maxlong = %f\n" % maxlong)
|
|
LOG.debug("maxlat = %f\n" % maxlat)
|
|
LOG.debug("zoomlat = %f\n" % zoomlat)
|
|
LOG.debug("zoomlong = %f\n" % zoomlong)
|
|
LOG.debug("latit = %f\n" % latit)
|
|
LOG.debug("longt = %f\n" % longt)
|
|
|
|
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 type == 1:
|
|
ftype = "P"
|
|
elif type == 2:
|
|
ftype = "E"
|
|
elif type == 3:
|
|
ftype = "F"
|
|
elif type == 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(type,first,last)
|
|
self.createMapstractionTrailer()
|
|
if self.nbpages == 1:
|
|
self.open(self.htmlfile)
|
|
|
|
def createMapstraction(self,displaytype):
|
|
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.createMapstractionNotImplemented(self.dbstate)
|
|
self.createMapstractionTrailer()
|
|
|
|
def append_to_places_without_coordinates(self, ID, Place):
|
|
self.place_without_coordinates.append([ID, Place])
|
|
self.without += 1
|
|
|
|
def append_to_places_list(self, Place, evttype, name, lat, long, descr, center, year):
|
|
self.place_list.append([Place, name, evttype, lat, long, descr, int(center), year])
|
|
self.nbmarkers += 1
|
|
|
|
a = float(lat)
|
|
b = float(long)
|
|
if year is not None:
|
|
c = int(year)
|
|
if c != 0:
|
|
if c < self.minyear:
|
|
self.minyear = c
|
|
if c > self.maxyear:
|
|
self.maxyear = c
|
|
|
|
if a < 0.0:
|
|
a = a - 0.00000001
|
|
else:
|
|
a = a + 0.00000001
|
|
if b < 0.0:
|
|
b = b - 0.00000001
|
|
else:
|
|
b = b + 0.00000001
|
|
|
|
if self.minlat == 0.0:
|
|
self.minlat = a
|
|
if a < self.minlat:
|
|
if a < 0.0:
|
|
self.minlat = a
|
|
|
|
if self.maxlat == 0.0:
|
|
self.maxlat = a
|
|
if a > self.maxlat:
|
|
if a > 0.0:
|
|
self.maxlat = a
|
|
|
|
if self.minlon == 0.0:
|
|
self.minlon = b
|
|
if b < self.minlon:
|
|
if b < 0.0:
|
|
self.minlon = b
|
|
|
|
if self.maxlon == 0.0:
|
|
self.maxlon = b
|
|
if b > self.maxlon:
|
|
if b > 0.0:
|
|
self.maxlon = b
|
|
|
|
def isyearnotinmarker(self,allyears,year):
|
|
ret = 1
|
|
for y in allyears:
|
|
if year == y:
|
|
ret = 0
|
|
return ret
|
|
|
|
def create_markers(self,format,firstm,lastm):
|
|
margin = 10
|
|
self.mapview.write(" <div id=\"map\" style=\"width: %dpx; height: %dpx\"></div>\n" %
|
|
( ( self.width - margin*4 ), ( self.height * 0.74 )))
|
|
self.mapview.write(" <script type=\"text/javascript\">\n")
|
|
self.mapview.write(" var mapstraction = new Mapstraction('map','%s');\n"%self.usedmap)
|
|
self.mapview.write(" mapstraction.addControls({ 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(%s,%s);"%(self.latit,self.longt))
|
|
self.mapview.write("mapstraction.setCenterAndZoom(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 y in self.yearinmarker:
|
|
years += "%d " % y
|
|
years += "end"
|
|
self.mapview.write("my_marker.setAttribute('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(%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(\"%s\");"%mark[0])
|
|
self.yearinmarker.append(mark[7])
|
|
divclose=False
|
|
self.mapview.write("my_marker.setInfoBubble(\"<div style='white-space:nowrap;' >")
|
|
if format == 1:
|
|
self.mapview.write("%s<br>____________<br><br>%s"%(mark[0],mark[5]))
|
|
elif format == 2:
|
|
self.mapview.write("%s____________<br><br>%s - %s"%(mark[1],mark[7],mark[5]))
|
|
elif format == 3:
|
|
self.mapview.write("%s<br>____________<br><br>%s - %s"%(mark[0],mark[7],mark[5]))
|
|
elif format == 4:
|
|
self.mapview.write("%s<br>____________<br><br>%s - %s"%(mark[0],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 y in self.yearinmarker:
|
|
years += "%d " % y
|
|
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(%s,%s);\n"%(latitude,longitude))
|
|
self.mapview.write(" mapstraction.setCenterAndZoom(point, %d);\n"%2)
|
|
self.mapview.write(" my_marker = new Marker(point);\n")
|
|
self.mapview.write(" my_marker.setLabel(\"%s\");\n"%_("No location."))
|
|
self.mapview.write(" my_marker.setInfoBubble(\"<div 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,db,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 = db.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 = db.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) : birth place.") % {
|
|
'comment': comment}
|
|
else:
|
|
descr1=_("birth place.")
|
|
descr = place.get_title()
|
|
city = place.get_main_location().get_city()
|
|
country = place.get_main_location().get_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 ):
|
|
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_coordinates(place.gramps_id,descr)
|
|
latitude = ""
|
|
longitude = ""
|
|
death_ref = person.get_death_ref()
|
|
if death_ref:
|
|
death = db.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 = db.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) : death place.") % {
|
|
'comment': comment}
|
|
else:
|
|
descr1=_("death place.")
|
|
city = place.get_main_location().get_city()
|
|
country = place.get_main_location().get_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 ):
|
|
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_coordinates(place.gramps_id,descr)
|
|
|
|
def createMapstractionPlaces(self,db):
|
|
"""
|
|
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 db.db.get_place_handles():
|
|
place = db.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")
|
|
city = place.get_main_location().get_city()
|
|
country = place.get_main_location().get_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 ):
|
|
self.append_to_places_list(descr, None,
|
|
"",
|
|
latitude, longitude,
|
|
descr1, self.center, None)
|
|
self.center = False
|
|
else:
|
|
self.append_to_places_without_coordinates(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,db):
|
|
"""
|
|
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 db.db.get_event_handles():
|
|
event = db.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 = db.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 = [db.db.get_person_from_handle(ref_handle)
|
|
for (ref_type, ref_handle) in \
|
|
db.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:
|
|
self.append_to_places_without_coordinates(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, db):
|
|
"""
|
|
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 db.active:
|
|
person = db.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 = db.db.get_family_from_handle(fhandle)
|
|
father_handle = fam.get_father_handle()
|
|
father = db.db.get_person_from_handle(father_handle)
|
|
if father:
|
|
comment = _("Id : Father : %s") % father.gramps_id
|
|
self.createPersonMarkers(db,father,comment)
|
|
mother_handle = fam.get_mother_handle()
|
|
mother = db.db.get_person_from_handle(mother_handle)
|
|
if mother:
|
|
comment = _("Id : Mother : %s") % mother.gramps_id
|
|
self.createPersonMarkers(db,mother,comment)
|
|
index = 0
|
|
child_ref_list = fam.get_child_ref_list()
|
|
if child_ref_list:
|
|
for child_ref in child_ref_list:
|
|
child = db.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(db,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,db):
|
|
"""
|
|
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 db.active:
|
|
person = db.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 = db.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 = db.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()
|
|
city = place.get_main_location().get_city()
|
|
country = place.get_main_location().get_country()
|
|
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_coordinates(
|
|
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 createMapstractionNotImplemented(self,db):
|
|
"""
|
|
This function is used to inform the user this work is not implemented.
|
|
"""
|
|
self.mapview.write(" <H1>%s </H1>" % _("Not yet implemented ..."))
|
|
|