# -*- python -*-
# -*- coding: utf-8 -*-
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2007-2009 Serge Noiraud
# Copyright (C) 2008 Benny Malengier
# Copyright (C) 2009 Gerald Britton
# Copyright (C) 2009 Helge GRAMPS
# Copyright (C) 2009 Josip
# Copyright (C) 2009 Gary Burton
# Copyright (C) 2009 Nick Hall
#
# 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 gen.ggettext import gettext as _
import os
import sys
import urlparse
import const
import operator
import locale
from gtk.keysyms import Tab as KEY_TAB
import socket
#-------------------------------------------------------------------------
#
# set up logging
#
#-------------------------------------------------------------------------
import logging
_LOG = logging.getLogger("GeoGraphy")
#-------------------------------------------------------------------------
#
# GTK/Gnome modules
#
#-------------------------------------------------------------------------
import gtk
import pango
import gobject
#-------------------------------------------------------------------------
#
# Gramps Modules
#
#-------------------------------------------------------------------------
import gen.lib
import Utils
import config
import Errors
from gen.display.name import displayer as _nd
from PlaceUtils import conv_lat_lon
from gui.views.navigationview import NavigationView
from gui.editors import EditPlace
from gui.selectors.selectplace import SelectPlace
import Bookmarks
from Utils import navigation_label
#-------------------------------------------------------------------------
#
# map icons
#
#-------------------------------------------------------------------------
_ICONS = {
gen.lib.EventType.BIRTH : 'gramps-geo-birth',
gen.lib.EventType.DEATH : 'gramps-geo-death',
gen.lib.EventType.MARRIAGE : 'gramps-geo-marriage',
}
#-------------------------------------------------------------------------
#
# regexp for html title Notes ...
#
#-------------------------------------------------------------------------
import re
ZOOMANDPOS = re.compile('zoom=([0-9]*) coord=([0-9\.\-\+]*), ([0-9\.\-\+]*):::')
#-------------------------------------------------------------------------
#
# Web interfaces
#
#-------------------------------------------------------------------------
URL_SEP = '/'
from htmlrenderer import HtmlView
#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
#covert to unicode for better hadnling of path in Windows
GEOVIEW_SUBPATH = Utils.get_empty_tempdir('geoview')
#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
_HTMLHEADER = '''\
%(title)s
%(css)s
'''
_JAVASCRIPT = '''\
'''
#-------------------------------------------------------------------------
#
# Functions
#
#-------------------------------------------------------------------------
def _get_sign(value):
"""
return 1 if we have a negative number, 0 in other case
"""
if value < 0.0:
return 1
else:
return 0
def _get_zoom_lat(value):
"""
return the zoom value for latitude depending on the distance.
"""
zoomlat = 1
for i, distance in enumerate([80.0, 40.0, 20.0, 10.0, 3.0,
2.0, 1.0, 0.5, 0.2, 0.1]):
if value < distance:
zoomlat = i+1
return zoomlat + 2
def _get_zoom_long(value):
"""
return the zoom value for longitude depending on the distance.
"""
zoomlong = 1
for i, distance in enumerate([120.0, 60.0, 30.0, 15.0, 7.0,
4.0, 2.0, 1.0, .5, .2, .1]):
if value < distance:
zoomlong = i+1
return zoomlong + 2
def _make_callback(func, val):
"""
return a function
"""
return lambda x: func(val)
def _escape(text):
"""
return the text with some characters translated : " &
"""
text = text.replace('&','\\&')
text = text.replace('"','\\"')
return text
#-------------------------------------------------------------------------
#
# GeoView
#
#-------------------------------------------------------------------------
class GeoView(HtmlView):
"""
The view used to render html pages.
"""
CONFIGSETTINGS = (
('preferences.alternate-provider', False),
('preferences.timeperiod-before-range', 10),
('preferences.timeperiod-after-range', 10),
('preferences.crosshair', False),
('preferences.markers', 200),
('preferences.coordinates-in-degree', False),
('preferences.network-test', False),
('preferences.network-timeout', 5),
('preferences.network-periodicity', 10),
('preferences.network-site', 'www.gramps-project.org'),
('preferences.webkit', False),
)
def __init__(self, pdata, dbstate, uistate):
HtmlView.__init__(self, pdata, dbstate, uistate, title=_("GeoView"))
self.dbstate = dbstate
self.uistate = uistate
self.dbstate.connect('database-changed', self._new_database)
self.widget = None
self.invalidpath = const.ROOT_DIR.find("(")
if self.invalidpath != -1:
_LOG.debug("\n\nInvalid PATH (avoid parenthesis):\n%s\n\n" %
const.ROOT_DIR)
self.displaytype = "person"
self.active_filter = 'Person Filter Gramplet'
self.additional_uis.append(self.additional_ui())
self.resize_occurs = False
self.Navigator_min_width = 0
def build_widget(self):
self.no_network = False
self.placeslist = []
self.nbmarkers = 0
self.nbplaces = 0
self.without = 0
self.nbpages = 0
self.last_index = 0
self.yearinmarker = []
self.javascript_ready = False
self.mustcenter = False
self.centerlat = self.centerlon = 0.0
self.setattr = True
self.latit = self.longt = 0.0
self.height = self.width = 0.0
self.zoom = 1
self.lock_action = None
self.realzoom = 0
self.reallatitude = self.reallongitude = 0.0
self.cal = 0
if config.get('geoview.lock'):
self.realzoom = config.get('geoview.zoom')
self.displaytype = config.get('geoview.map')
self.reallatitude, self.reallongitude = conv_lat_lon(
config.get('geoview.latitude'),
config.get('geoview.longitude'),
"D.D8")
if self.displaytype == "places":
self.active_filter = 'Place Filter Gramplet'
elif self.displaytype == "event":
self.active_filter = 'Event Filter Gramplet'
elif self.displaytype == "family":
self.active_filter = 'Family Filter Gramplet'
else:
self.active_filter = 'Person Filter Gramplet'
self.minyear = self.maxyear = 1
self.maxbut = 10
self.mapview = None
self.yearint = 0
self.centered = True
self.center = True
self.place_list = []
self.htmlfile = ""
self.places = []
self.sort = []
self.psort = []
self.clear = gtk.Button("")
self.clear.set_tooltip_text(
_("Clear the entry field in the places selection box.")
)
self.savezoom = gtk.Button("")
self.savezoom.connect("clicked", self._save_zoom)
self.savezoom.set_tooltip_text(
_("Save the zoom and coordinates between places "
"map, person map, family map and event map.")
)
self.provider = gtk.Button("")
self.provider.connect("clicked", self._change_provider)
self.provider.set_tooltip_text(
_("Select the maps provider. You can choose "
"between OpenStreetMap and Google maps.")
)
self.buttons = gtk.ListStore(gobject.TYPE_STRING, # The year
)
self.plist = gtk.ListStore(gobject.TYPE_STRING, # The name
gobject.TYPE_INT, # the marker index
gobject.TYPE_INT # the marker page
)
# I suppress sort in the combobox for performances.
# I tried to load a database with more than 35000 places.
# with the sort function, its takes approximatively 20 minutes
# to see the combobox and the map.
# Without the sort function, it takes approximatively 4 minutes.
#self.plist.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.without_coord_file = []
self.place_without_coordinates = []
self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
self.last_year = None
self.last_selected_year = 0
self.header_size = 0
self.years = gtk.HBox()
self.ylabel = gtk.Label("")
self.ylabel.set_alignment(1.0, 0.5)
cell = gtk.CellRendererText()
self.yearsbox = gtk.ComboBox(self.buttons) # pylint: disable-msg=W0201
self.yearsbox.pack_start(cell)
self.yearsbox.add_attribute(self.yearsbox.get_cells()[0], 'text', 0)
self.yearsbox.connect('changed', self._ask_year_selection)
self.yearsbox.set_tooltip_text(
_("Select the period for which you want to see the places.")
)
self.years.pack_start(self.ylabel, True, True, padding=2)
self.years.pack_start(self.yearsbox, True, True, padding=2)
self.pages_selection = gtk.HBox()
self.pages = []
self.last_page = 1
bef = gtk.Button("<<")
bef.set_tooltip_text(_("Prior page."))
self.pages.append(bef)
cur = gtk.Button("1")
cur.set_tooltip_text(_("The current page/the last page."))
self.pages.append(cur)
aft = gtk.Button(">>")
aft.set_tooltip_text(_("Next page."))
self.pages.append(aft)
for page in self.pages:
page.connect("clicked", self._ask_new_page)
self.pages_selection.pack_start(page, False, False, padding=2)
self.nocoord = gtk.Button("Unref") # don't translate
self.nocoord.connect("clicked", self._show_places_without_coord)
self.nocoord.set_tooltip_text(
_("The number of places which have no coordinates."))
self.without_coord_file = os.path.join(GEOVIEW_SUBPATH,
"without_coord.html")
self.endinit = False
self.generic_filter = None
self.signal_map = {'place-add': self._place_changed,
'place-update' : self._place_changed}
self.context_id = 0
self.active = False
self.already_testing = False
self.alt_provider = self._config.get('preferences.alternate-provider')
self.usedmap = "googlev3" if self.alt_provider else "openlayers"
fpath = os.path.join(const.WEBSTUFF_DIR, 'images', 'crosshairs.png')
self.crosspath = urlparse.urlunsplit(
('file', '', URL_SEP.join(fpath.split(os.sep)), '', '')
)
self.side = None
self.bottom = None
self._manage_filter('Place Filter Gramplet')
return HtmlView.build_widget(self)
def can_configure(self):
"""
We have a configuration window.
"""
return True
def get_title(self):
"""
Used to set the titlebar in the configuration window.
"""
return _('Geography')
def _get_configure_page_funcs(self):
"""
The function which is used to create the configuration window.
"""
return [self.map_options, self.geoview_options, self.net_options]
def config_connect(self):
"""
This method will be called after the ini file is initialized,
use it to monitor changes in the ini file
"""
self._config.connect("preferences.crosshair",
self.config_crosshair)
self._config.connect("preferences.network-test",
self.config_network_test)
def config_update_int(self, obj, constant):
"""
Try to read an int.
"""
try:
self._config.set(constant, int(obj.get_text()))
except: # pylint: disable-msg=W0704
#pass # pylint: disable-msg=W0702
print "WARNING: ignoring invalid value for '%s'" % constant
def config_update(self, obj, constant):
# pylint: disable-msg=W0613
"""
Some preferences changed in the configuration window.
"""
self._change_map(self.usedmap)
self._set_provider_icon()
self._ask_year_selection(self.last_year)
def config_crosshair(self, client, cnxn_id, entry, data):
# pylint: disable-msg=W0613
"""
Do we have a crosshair ?
"""
if self.javascript_ready:
_LOG.debug("crosshair : %d" %
self._config.get("preferences.crosshair")
)
self.renderer.execute_script(
"javascript:addcrosshair('%d','%s','geo-map')" %
(self._config.get("preferences.crosshair"),
self.crosspath)
)
self._size_request_for_map(self.box, None)
pass
def geoview_options(self, configdialog):
"""
Function that builds the widget in the configuration dialog
for the time period options.
"""
table = gtk.Table(2, 2)
table.set_border_width(12)
table.set_col_spacings(6)
table.set_row_spacings(6)
configdialog.add_text(table,
_("You can adjust the time period "
"with the two following values."),
1)
configdialog.add_pos_int_entry(table,
_('The number of years before the first event date'),
2, 'preferences.timeperiod-before-range',
self.config_update_int)
configdialog.add_pos_int_entry(table,
_('The number of years after the last event date'),
3, 'preferences.timeperiod-after-range',
self.config_update_int)
return _('Time period adjustment'), table
def map_options(self, configdialog):
"""
Function that builds the widget in the configuration dialog
for the map options.
"""
table = gtk.Table(2, 2)
table.set_border_width(12)
table.set_col_spacings(6)
table.set_row_spacings(6)
configdialog.add_checkbox(table,
_('Crosshair on the map.'),
1, 'preferences.crosshair')
configdialog.add_checkbox(table,
_('Show the coordinates in the statusbar either in degrees\n'
'or in internal Gramps format ( D.D8 )'),
2, 'preferences.coordinates-in-degree')
configdialog.add_pos_int_entry(table,
_('The maximum number of markers per page.\n'
'If the time to load one page is too long, reduce this value'),
3, 'preferences.markers',
self.config_update_int)
if self.get_toolkit() == 3 :
# We have mozilla ( gecko ) and webkit toolkits.
# We propose to the user the choice between these toolkits.
# useful when webkit crash and not gecko.
# We need to restart Gramps.
# In case of crash with a browser, we can change the toolkit in
# Geography_geoview.ini :
# webkit=False => gtkmozembed (gecko)
# webkit=True => webkit
configdialog.add_checkbox(table,
_('When selected, we use webkit else we use mozilla\n'
'We need to restart Gramps.'),
4, 'preferences.webkit')
return _('The map'), table
def config_network_test(self, client, cnxn_id, entry, data):
# pylint: disable-msg=W0613
"""
Do we need to test the network ?
"""
if self._config.get('preferences.network-test'):
self._test_network()
def net_options(self, configdialog):
"""
Function that builds the widget in the configuration dialog
for the network options.
"""
table = gtk.Table(1, 1)
table.set_border_width(12)
table.set_col_spacings(6)
table.set_row_spacings(6)
configdialog.add_checkbox(table,
_('Test the network '),
1, 'preferences.network-test')
configdialog.add_pos_int_entry(table,
_('Time out for the network connection test'),
2, 'preferences.network-timeout',
self.config_update_int)
configdialog.add_pos_int_entry(table,
_('Time in seconds between two network tests.\n'
'Must be greater or equal to 10 seconds'),
3, 'preferences.network-periodicity',
self.config_update_int)
configdialog.add_text(table,
_('Host to test for http. Please, change this\n'
'and select one of your choice'),
4)
configdialog.add_entry(table, '',
5, 'preferences.network-site')
return _('The network'), table
def _place_changed(self, handle_list):
# pylint: disable-msg=W0613
"""
One place changed. need to display it.
"""
self.displaytype = "places"
self._set_lock_unlock(True)
self._geo_places()
def top_widget(self):
"""
The top widget to use, for GeoView :
- Places list search
- Page selection if more than NB_MARKERS_PER_PAGE markers.
- Place without coordinates if needed
- Years selection
"""
self.box1 = gtk.VBox(False, 1) # pylint: disable-msg=W0201
self.clear.set_alignment(1.0, 0.5)
self.savezoom.set_alignment(1.0, 0.5)
cell = gtk.CellRendererText()
self.placebox = gtk.ComboBoxEntry(self.plist)# pylint: disable-msg=W0201
self.placebox.pack_start(cell)
self.placebox.add_attribute(self.placebox.get_cells()[0], 'text', 0)
self.placebox.set_tooltip_text(
_("Select the place for which you want to see the info bubble."))
completion = gtk.EntryCompletion()
completion.set_model(self.plist)
completion.set_minimum_key_length(1)
completion.set_text_column(0)
completion.set_inline_completion(True)
completion.set_match_func(self._match_string)
self.placebox.child.connect('changed', self._entry_selected_place)
self.placebox.child.connect('key-press-event', self._entry_key_event)
self.clear.connect('clicked', self._erase_placebox_selection)
self.placebox.child.set_completion(completion)
box = gtk.HBox()
box.pack_start(self.clear, False, False, padding=2)
box.pack_start(self.placebox, True, True, padding=2)
box.pack_start(self.pages_selection, False, False, padding=2)
box.pack_start(self.nocoord, False, False, padding=2)
box.pack_start(self.years, False, False, padding=2)
box.pack_start(self.savezoom, False, False, padding=2)
box.pack_start(self.provider, False, False, padding=2)
box.show_all()
self.heading = gtk.Label('')
self.heading.set_single_line_mode(True)
font = pango.FontDescription("monospace")
font.set_weight(pango.WEIGHT_HEAVY)
font.set_style(pango.STYLE_NORMAL)
self.heading.modify_font(font)
self.box1.pack_start(box, True, True, padding=2)
self.box1.pack_start(self.heading, True, True, padding=2)
self.box1.show_all()
return self.box1
def _entry_key_event(self, widget, event):
"""
The user enter characters. If he enter tab, I'll try to complete.
This is used when the completion doen't start at the beginning
of the word or sentence.
i.e : If we have in our place list :
...
"town of london, England"
"in the town of londonderry"
"ville de londres"
...
in the entrybox, if you select "londr", then enter tab,
the selected item will be "ville de londres"
"""
prefix = widget.get_text().lower()
count = 0
found = _("Unknown")
if event.keyval == KEY_TAB:
for place in self.plist:
if prefix in place[0].lower():
count += 1
found = place[0]
if count == 1:
self.placebox.child.set_text(found)
def _match_string(self, compl, key, fiter): # pylint: disable-msg=W0613
"""
Used to select places in the combobox.
"""
model = compl.get_model()
text = model.get_value(fiter, 0)
# the key passed to this function is not unicode! bug ?
# ie : in french, when you enter é, key is equal to e
ukey = compl.get_entry().get_text()
if ukey is None or text is None:
return False
if ukey.lower() in text.lower():
return True
return False
def _set_years_selection(self, yearbase, step, maxyear):
"""
Creation of the years list for the years comboBox.
"""
base = 0
self.ylabel.set_text("%s : %d %s" % ( _("Time period"),
step, _("years")) )
self.yearsbox.hide()
self.yearsbox.freeze_child_notify()
self.yearsbox.set_model(None)
self.buttons.clear()
self.buttons.append([""])
self.buttons.append([_("All")])
for but in range(0, self.maxbut + 1): # pylint: disable-msg=W0612
newyear = yearbase + base
if newyear <= maxyear:
self.buttons.append([str(newyear)])
base += step
self.yearsbox.set_model(self.buttons)
self.yearsbox.set_active(1)
self.yearsbox.show()
self.yearsbox.thaw_child_notify()
def _ask_year_selection(self, widget, data=None):
# pylint: disable-msg=W0613
"""
Ask to the renderer to apply the selected year
"""
if widget and widget.get_active():
self.last_year = widget
self._set_markers_and_crosshair_on_page(widget)
def _ask_new_page(self, widget, data=None): # pylint: disable-msg=W0613
"""
Ask to select a new page when we are in a multi-pages map.
"""
if widget is None:
return
page = widget.get_label()
(current, maxp ) = self.pages[1].get_label().split('/', 1)
if ( page == "<<" and int(current) > 1):
cpage = -1
elif ( page == ">>" and int(current) < int(maxp)):
cpage = +1
else:
cpage = 0
cpage += int(current)
self.last_page = cpage
ftype = {"places":'P', "event":'E', "family":'F', "person":'I'}.get(
self.displaytype, 'X')
url = os.path.join(GEOVIEW_SUBPATH,
"GeoV-%c-%05d.html" % (ftype, cpage)
)
url = urlparse.urlunsplit(
('file', '', URL_SEP.join(url.split(os.sep)), '', '')
)
url += '?map=%s' % self.usedmap
url += '&zoom=%d' % int(self.realzoom)
url += '&lat=%s' % str(self.reallatitude)
url += '&lon=%s' % str(self.reallongitude)
url += '&cross=%s' % int(self._config.get("preferences.crosshair"))
self._openurl(url)
self._create_pages_selection(cpage, int(maxp))
self._savezoomandposition()
# Need to wait the page is loaded to show the markers.
gobject.timeout_add(1500, self._show_selected_places)
self.placebox.child.set_text("")
def _show_selected_places(self):
"""
Here, we synchronize the years combobox with the renderer
except when we are in the places view.
"""
if self.displaytype != "places":
for index, r_year in enumerate(self.buttons):
if self.last_selected_year == r_year[0]:
self.yearsbox.set_active(index)
self._call_js_selectmarkers(r_year[0])
self._size_request_for_map(self.box, None)
def _show_places_without_coord(self, widget): # pylint: disable-msg=W0613
"""
Show the page which contains the list of all places without coordinates.
"""
url = urlparse.urlunsplit(
('file', '', URL_SEP.join(self.without_coord_file.split(os.sep)),
'', '')
)
self._openurl(url)
def _entry_selected_place(self, combobox): # pylint: disable-msg=W0612
"""
Ask to the renderer to show the info bubble.
"""
place = combobox.get_text()
for entry in self.placebox.get_model():
if entry[0] == place:
# Is this entry in the current page ?
if self.last_page == int(entry[2]):
# Yes, we don't need to load another page.
self._show_place_info_bubble(entry[1])
self._show_selected_places()
else:
# No, we need to load the correct page
self.last_page = int(entry[2])
ftype = {"places":'P',
"event":'E',
"family":'F',
"person":'I'}.get( self.displaytype, 'X')
url = os.path.join(GEOVIEW_SUBPATH,
"GeoV-%c-%05d.html" % (ftype, entry[2])
)
url = urlparse.urlunsplit(
('file', '', URL_SEP.join(url.split(os.sep)), '', '')
)
url += '?map=%s' % self.usedmap
url += '&zoom=%d' % int(self.realzoom)
url += '&lat=%s' % str(self.reallatitude)
url += '&lon=%s' % str(self.reallongitude)
url += '&cross=%s' % int(
self._config.get("preferences.crosshair")
)
self._openurl(url)
(current, maxp ) = self.pages[1].get_label().split('/', 1)
self._create_pages_selection(entry[2], int(maxp))
self._savezoomandposition()
# Need to wait the page is loaded to show the info bubble.
gobject.timeout_add(1500, self._show_place_info_bubble,
entry[1])
# Need to wait the page is loaded to show the markers.
gobject.timeout_add(1600, self._show_selected_places)
return
def _show_place_info_bubble(self, marker_index):
"""
We need to call javascript to show the info bubble.
"""
if self.javascript_ready:
self.renderer.execute_script("javascript:placeclick('%d')" %
marker_index)
self._size_request_for_map(self.box, None)
def _erase_placebox_selection(self, arg):
# pylint: disable-msg=W0613
"""
We erase the place name in the entrybox after 1 second.
"""
self.placebox.child.set_text("")
def on_delete(self):
"""
We need to suppress temporary files here.
Save the zoom, latitude, longitude and lock
"""
self.javascript_ready = False
self._savezoomandposition()
if config.get('geoview.lock'):
config.set('geoview.zoom', int(self.realzoom))
config.set('geoview.latitude', str(self.reallatitude))
config.set('geoview.longitude', str(self.reallongitude))
config.set('geoview.map', self.displaytype)
else:
config.set('geoview.zoom', 0)
config.set('geoview.latitude', "0.0")
config.set('geoview.longitude', "0.0")
config.set('geoview.map', "person")
NavigationView.on_delete(self)
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.years.hide()
self.pages_selection.hide()
self.nocoord.hide()
self.box.connect("size-allocate", self._size_request_for_map)
def _size_request_for_bars(self, widget, event, data, data1):
if self.widget is not None:
self._size_request_for_map(self.widget,None,None)
def _size_request_for_map(self, widget, event, data=None):
# pylint: disable-msg=W0613
"""
We need to resize the map
"""
if not self.javascript_ready:
return
if not self.resize_occurs:
self.resize_occurs = True
gobject.timeout_add(300, self._really_resize_the_map,
widget, event, data)
def _really_resize_the_map(self, widget, event, data=None):
# VPane -> Hpane -> NoteBook -> HPaned -> VBox -> Window
# We need to get the HPaned size and the VPaned size.
if not self.javascript_ready:
# Two reason for this :
# 1 - we are quitting gramps
# 2 - the renderer is not ready to accept javascript
return
self.resize_occurs = False
self.box1_size = self.box1.get_allocation()
self.header_size = self.box1_size.height
self.height = (widget.parent.get_allocation().height - self.header_size -
widget.parent.get_child2().get_allocation().height - 30)
self.width = (widget.parent.parent.get_allocation().width -
widget.parent.parent.get_child2().get_allocation().width - 30)
# We need to know what is the min width of the Navigation bar.
Navigator_width = widget.parent.parent.parent.parent.get_child1().get_allocation().width
if self.Navigator_min_width == 0:
self.Navigator_min_width = Navigator_width
if Navigator_width < self.Navigator_min_width:
widget.parent.parent.parent.parent.set_position(self.Navigator_min_width)
_LOG.debug("Navigator width = %d" % Navigator_width)
if not self.sidebar.get_property('visible'):
if self.side is not None:
self.width = widget.parent.parent.get_allocation().width - 24
else:
self.side = widget
self.width = widget.parent.parent.get_allocation().width - 300
_LOG.debug("No sidebar : map width=%d" % self.width)
else:
_LOG.debug("Sidebar : map width=%d" % self.width)
if not self.bottombar.get_property('visible'):
if self.bottom is not None:
self.height = (widget.parent.get_allocation().height
- self.header_size - 24)
else:
self.bottom = widget
self.height = (widget.parent.get_allocation().height
- self.header_size - 400)
_LOG.debug("No bottombar : map height=%d" % self.height )
else:
_LOG.debug("bottombar : map height=%d" % self.height )
self.widget = widget
self.height = 10 if self.height < 10 else self.height
self.width = 10 if self.width < 10 else self.width
if Navigator_width < self.Navigator_min_width:
self.width -= ( self.Navigator_min_width - Navigator_width )
self.box1_size.width = self.width
self.box1_size.height = self.height
#self.box1.set_allocation(self.box1_size)
if self.javascript_ready:
_LOG.debug("New size : width=%d and height=%d" %
(self.width, self.height)
)
self.renderer.execute_script(
"javascript:mapstraction.resizeTo('%dpx','%dpx');" %
(self.width, self.height)
)
self.renderer.execute_script(
"javascript:setcenterandzoom(mapstraction,uzoom,ulat,ulon)"
)
self.frames.set_size_request(self.width+4, self.height+4)
if not self.uistate.get_active('Person'):
return
self.external_uri()
def set_active(self):
"""
Set view active when we enter into this view.
"""
self.key_active_changed = self.dbstate.connect(
'active-changed', self._goto_active_person)
hobj = self.get_history()
self.active_signal = hobj.connect(
'active-changed', self._goto_active_person)
self._goto_active_person()
self.active = True
NavigationView.set_active(self)
self._test_network()
def set_inactive(self):
"""
Set view inactive when switching to another view.
"""
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Navigator')
action.set_sensitive(True)
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Toolbar')
action.set_sensitive(True)
HtmlView.set_inactive(self)
self.dbstate.disconnect(self.key_active_changed)
self.active = False
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
as a stock icon.
"""
return 'gramps-geo'
def get_viewtype_stock(self):
"""Type of view in category
"""
return 'gramps-geo'
def _savezoomandposition(self, timeloop=None):
"""
The only way we have to save the zoom and position is to change the
title of the html page then to get this title.
When the title change, we receive a 'changed-title' signal.
Then we can get the new title with the new values.
"""
res = self.dbstate.db.get_researcher()
title = None
if res: # Don't modify the current values if no db is loaded.
start = 0
try:
title = ZOOMANDPOS.search(self.renderer.title, start)
if title:
if self.realzoom != title.group(1):
self.realzoom = title.group(1) if int(title.group(1)) < 17 else 17
if self.reallatitude != title.group(2):
self.reallatitude = title.group(2)
if self.reallongitude != title.group(3):
self.reallongitude = title.group(3)
except: # pylint: disable-msg=W0704
pass # pylint: disable-msg=W0702
if timeloop:
if self.active:
if title is not None:
self.uistate.status.pop(self.context_id)
if self._config.get('preferences.coordinates-in-degree'):
latitude, longitude = conv_lat_lon(
self.reallatitude, self.reallongitude, "DEG")
else:
latitude, longitude = conv_lat_lon(
self.reallatitude, self.reallongitude, "D.D8")
mess = "%s= %s\t%s= %s\t%s= %s" % (
_("Latitude"), latitude,
_("Longitude"), longitude,
_("Zoom"), self.realzoom
)
self.context_id = self.uistate.status.push(1, mess)
gobject.timeout_add(timeloop,
self._savezoomandposition, timeloop)
def _do_we_need_to_zoom_between_map(self):
"""
Look if we need to use the lasts zoom, latitude and longitude retrieved
from the renderer, or if we must use the last ones we just created.
"""
if self.reallatitude is None:
self.reallatitude = 0.0
if self.reallongitude is None:
self.reallongitude = 0.0
if not config.get('geoview.lock'):
self.reallatitude = self.latit
self.reallongitude = self.longt
self.realzoom = self.zoom if self.zoom < 17 else 17
def _change_map(self, usedmap):
"""
Tell the browser to change the current map.
"""
self.uistate.clear_filter_results()
self._do_we_need_to_zoom_between_map()
if self.last_page != 1:
ftype = {"places":'P',
"event":'E',
"family":'F',
"person":'I'}.get(self.displaytype, 'X')
url = os.path.join(GEOVIEW_SUBPATH, "GeoV-%c-%05d.html" %
(ftype, self.last_page))
url = urlparse.urlunsplit( ('file', '',
URL_SEP.join(url.split(os.sep)),
'', ''))
else:
if not self.htmlfile:
self.htmlfile = os.path.join(GEOVIEW_SUBPATH, "geography.html")
url = urlparse.urlunsplit( ('file', '',
URL_SEP.join(self.htmlfile.split(os.sep)),
'', ''))
url += '?map=%s' % usedmap
url += '&zoom=%d' % int(self.realzoom)
url += '&lat=%s' % str(self.reallatitude)
url += '&lon=%s' % str(self.reallongitude)
url += '&cross=%s' % int(self._config.get("preferences.crosshair"))
self._openurl(url)
self._savezoomandposition()
if self.displaytype != "places":
# Need to wait the page is loaded to set the markers and crosshair.
gobject.timeout_add(1500, self._set_markers_and_crosshair_on_page,
self.last_year)
else:
# Need to wait the page is loaded to set the crosshair.
gobject.timeout_add(1500, self.config_crosshair,
False, False, False, False)
def _set_markers_and_crosshair_on_page(self, widget):
"""
get the year to select then call javascript
"""
if not self.endinit:
return
if widget:
model = widget.get_model()
if model:
year = "no"
try:
year = model.get_value(widget.get_active_iter(), 0)
except: # pylint: disable-msg=W0704
pass # pylint: disable-msg=W0702
if self.last_selected_year == 0:
self.last_selected_year = year
elif year != "no":
self.last_selected_year = year
self._call_js_selectmarkers(year)
self.config_crosshair(False, False, False, False)
def _call_js_selectmarkers(self, year):
"""
Ask to the renderer to show All or specific markers.
"""
if self.javascript_ready:
if year == _("All"):
self.renderer.execute_script(
"javascript:selectmarkers('All')")
else:
self.renderer.execute_script(
"javascript:selectmarkers('%s')" % year )
def additional_ui(self):
"""
Specifies the UIManager XML code that defines the menus and buttons
associated with the interface.
"""
return '''
'''
def define_actions(self):
"""
Required define_actions function for NavigationView. Builds the action
group information required.
"""
NavigationView.define_actions(self)
# geoview actions
self._add_action('AddPlace', 'geo-place-add',
_('_Add Place'),
callback=self._add_place,
tip=_("Add the location centred on the map as a new place in "
"Gramps. Double click the location to centre on the map."))
self._add_action('LinkPlace', 'geo-place-link',
_('_Link Place'),
callback=self._link_place,
tip=_("Link the location centred on the map to a place in "
"Gramps. Double click the location to centre on the map."))
self._add_action('AddPlaceMenu', 'geo-place-add',
_('_Add Place'),
callback=self._add_place,
tip=_("Add the location centred on the map as a new place in "
"Gramps. Double click the location to centre on the map."))
self._add_action('LinkPlaceMenu', 'geo-place-link',
_('_Link Place'),
callback=self._link_place,
tip=_("Link the location centred on the map to a place in "
"Gramps. Double click the location to centre on the map."))
self._add_action('AllPlacesMaps', 'geo-show-place', _('_All Places'),
callback=self._all_places, tip=_("Attempt to view all places in "
"the family tree."))
self._add_action('PersonMaps', 'geo-show-person', _('_Person'),
callback=self._person_places,
tip=_("Attempt to view all the places "
"where the selected people lived."))
self._add_action('FamilyMaps', 'geo-show-family', _('_Family'),
callback=self._family_places,
tip=_("Attempt to view places of the selected people's family."))
self._add_action('EventMaps', 'geo-show-event', _('_Event'),
callback=self._event_places,
tip=_("Attempt to view places connected to all events."))
self._add_action('AllPlacesMapsMenu', 'geo-show-place',
_('_All Places'), callback=self._all_places,
tip=_("Attempt to view all places in "
"the family tree."))
self._add_action('PersonMapsMenu', 'geo-show-person', _('_Person'),
callback=self._person_places,
tip=_("Attempt to view all the places "
"where the selected people lived."))
self._add_action('FamilyMapsMenu', 'geo-show-family', _('_Family'),
callback=self._family_places,
tip=_("Attempt to view places of the selected people's family."))
self._add_action('EventMapsMenu', 'geo-show-event', _('_Event'),
callback=self._event_places,
tip=_("Attempt to view places connected to all events."))
def change_page(self):
"""
Called by viewmanager at end of realization when arriving on the page
At this point the Toolbar is created. We need to:
1. get the menutoolbutton
2. add all possible css styles sheet available
3. add the actions that correspond to clicking in this drop down menu
4. set icon and label of the menutoolbutton now that it is realized
5. store label so it can be changed when selection changes
"""
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Bars/Sidebar')
action.set_sensitive(False)
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Bars/Bottombar')
action.set_sensitive(False)
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Navigator')
action.set_sensitive(False)
action.set_active(True)
action = self.uistate.uimanager.get_action('/MenuBar/ViewMenu/Toolbar')
action.set_sensitive(False)
hobj = self.get_history()
self.fwd_action.set_sensitive(not hobj.at_end())
self.back_action.set_sensitive(not hobj.at_front())
self.other_action.set_sensitive(not self.dbstate.db.readonly)
self.uistate.modify_statusbar(self.dbstate)
self.uistate.clear_filter_results()
self._set_lock_unlock(config.get('geoview.lock'))
self._savezoomandposition(500) # every 500 millisecondes
self.endinit = True
self.uistate.clear_filter_results()
self._set_provider_icon()
self._geo_places()
def _goto_active_person(self, handle=None): # pylint: disable-msg=W0613
"""
Here when the GeoView page is loaded
"""
if not self.uistate.get_active('Person'):
return
self._geo_places()
def _manage_filter(self, filter): # pylint: disable-msg=W0613
"""
Remove the old filter and add the new one
"""
if self.sidebar.has_gramplet(self.active_filter):
self.sidebar.remove_gramplet(self.active_filter)
self.sidebar.add_gramplet(filter)
elif self.bottombar.has_gramplet(self.active_filter):
self.bottombar.remove_gramplet(self.active_filter)
self.bottombar.add_gramplet(filter)
else:
self.sidebar.add_gramplet(filter)
self.active_filter = filter
def _all_places(self, hanle=None): # pylint: disable-msg=W0613
"""
Specifies the place for the home person to display with mapstraction.
"""
self.displaytype = "places"
self._manage_filter('Place Filter Gramplet')
self._geo_places()
def _person_places(self, handle=None): # pylint: disable-msg=W0613
"""
Specifies the person places.
"""
self.displaytype = "person"
if not self.uistate.get_active('Person'):
return
self._manage_filter('Person Filter Gramplet')
self._geo_places()
def _family_places(self, hanle=None): # pylint: disable-msg=W0613
"""
Specifies the family places to display with mapstraction.
"""
self.displaytype = "family"
if not self.uistate.get_active('Person'):
return
self._manage_filter('Family Filter Gramplet')
self._geo_places()
def _event_places(self, hanle=None): # pylint: disable-msg=W0613
"""
Specifies all event places to display with mapstraction.
"""
self.displaytype = "event"
self._manage_filter('Event Filter Gramplet')
self._geo_places()
def _new_database(self, database):
"""
We just change the database.
Restore the initial config. Is it good ?
"""
if config.get('geoview.lock'):
self.realzoom = config.get('geoview.zoom')
self.displaytype = config.get('geoview.map')
self.reallatitude, self.reallongitude = conv_lat_lon(
config.get('geoview.latitude'),
config.get('geoview.longitude'),
"D.D8")
self._change_db(database)
for sig in self.signal_map:
self.callman.add_db_signal(sig, self.signal_map[sig])
def _geo_places(self):
"""
Specifies the places to display with mapstraction.
"""
if not self.endinit:
return
if not self.dbstate.db.is_open():
return
if self.nbmarkers > 0 :
# While the db is not loaded, we have 0 markers.
self._savezoomandposition()
self._test_network()
self.nbmarkers = 0
self.nbplaces = 0
self.without = 0
self.javascript_ready = False
self._createmapstraction(self.displaytype)
def _set_lock_unlock(self, state):
"""
Change the lock/unlock state.
"""
config.set('geoview.lock', state)
self._set_lock_unlock_icon()
def _set_lock_unlock_icon(self):
"""
Change the lock/unlock icon depending on the button state.
"""
child = self.savezoom.child
if child:
self.savezoom.remove(child)
image = gtk.Image()
if config.get('geoview.lock'):
image.set_from_stock('geo-fixed-zoom', gtk.ICON_SIZE_MENU)
else:
image.set_from_stock('geo-free-zoom', gtk.ICON_SIZE_MENU)
image.show()
self.savezoom.add(image)
self._geo_places()
def _save_zoom(self, button): # pylint: disable-msg=W0613
"""
Do we change the zoom between maps ?
It's not between maps providers, but between people, family,
events or places map.
When we unlock, we reload the page with our values.
"""
if config.get('geoview.lock'):
config.set('geoview.lock', False)
self._set_lock_unlock(False)
else:
config.set('geoview.lock', True)
self._set_lock_unlock(True)
def _change_provider(self, button): # pylint: disable-msg=W0613
"""
Toogle between the two maps providers.
Inactive ( the default ) is openstreetmap.
As openstreetmap has no api, we now use openlayers.
Active means Google maps.
"""
if self._config.get('preferences.alternate-provider'):
self.usedmap = "openlayers"
self._config.set('preferences.alternate-provider', False)
else:
self.usedmap = "googlev3"
self._config.set('preferences.alternate-provider', True)
self._set_provider_icon()
self._change_map(self.usedmap)
self._ask_year_selection(self.last_year)
def _set_provider_icon(self):
"""
Change the provider icon depending on the button state.
"""
child = self.provider.child
if child:
self.provider.remove(child)
image = gtk.Image()
if self._config.get('preferences.alternate-provider'):
image.set_from_stock('gramps-geo-altmap', gtk.ICON_SIZE_MENU)
else:
image.set_from_stock('gramps-geo-mainmap', gtk.ICON_SIZE_MENU)
image.show()
self.provider.add(image)
def _createpageplaceswithoutcoord(self):
"""
Create a page with the list of all places without coordinates
page.
"""
ufd = open(self.without_coord_file, "w+")
ufd.write(
_HTMLHEADER %
{ 'title' : _('List of places without coordinates'),
'lang' : 'en',
'css' : self._add_stylesheet(),
}
+ ' \n'
)
ufd.write(
' \n' +
' '
% (_('Here is the list of all places in the family tree'
' for which we have no coordinates.
'
' This means no longitude or latitude.'),
_('Back to prior page')
)
)
self.places = sorted(self.place_without_coordinates)
ufd.write(
"
| NB | " +
"Gramps ID | Place | "
)
#for p, place in enumerate(self.places):
# ufd.write(" | %d | %s | %s |
\n"
# % (p + 1, place[0], place[1]))
ufd.writelines(
" | %d | %s | %s |
\n"
% (p + 1, gid, place)
for p, (gid, place) in enumerate(self.places)
)
ufd.write("
\n"
" \n"
"