josch/neo1973-germany
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

adjusted pathes

Browse source 
git-svn-id: http://www.neo1973-germany.de/svn@71 46df4e5c-bc4e-4628-a0fc-830ba316316d
This commit is contained in:
emdete 2008-04-04 06:28:07 +00:00
parent f4b55d18c7
commit b599c882ce
1 changed files with 449 additions and 446 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

887
pylgrim/pylgrim.py
View file

@ -1,18 +1,18 @@
#!/usr/bin/python #!/usr/bin/python
#coding=utf8 #coding=utf8
''' '''
This program is free software: you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or the Free Software Foundation, either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
''' '''
#TODO: restructure tile loading #TODO: restructure tile loading
@ -33,494 +33,497 @@ from dbus import SystemBus, Interface
import time import time
import math import math
from urllib2 import build_opener from urllib2 import build_opener
from freesmartphone import DBUS_NAME, DIN_LOCATION
from base import dedbusmap
def err(*data):
print 'err', data
class PylgrimMap(object): class PylgrimMap(object):
def __init__(self): def __init__(self):
self.opener = build_opener() self.opener = build_opener()
def download(self, x,y,z): def download(self, x, y, zoom):
filename = "%d/%d/%d.png"%(z,x,y) filename = "%d/%d/%d.png"%(zoom, x, y)
print 'download', filename print 'download', filename
try: try:
dirname = "%d/%d"%(z,x) dirname = "%d/%d"%(zoom, x)
if not os.path.exists(dirname): if not os.path.exists(dirname):
os.makedirs(dirname) os.makedirs(dirname)
localFile = open(filename, 'w') localFile = open(filename, 'w')
webFile = self.opener.open("http://a.tile.openstreetmap.org/%d/%d/%d.png"%(z,x,y)) webFile = self.opener.open("http://a.tile.openstreetmap.org/%d/%d/%d.png"%(zoom, x, y))
localFile.write(webFile.read()) localFile.write(webFile.read())
webFile.close() webFile.close()
localFile.close() localFile.close()
except Exception, e: except Exception, e:
print 'download error', e print 'download error', e
if os.path.exists(filename): if os.path.exists(filename):
os.unlink(filename) os.unlink(filename)
class PylgrimView(edje.Edje, PylgrimMap): class PylgrimView(edje.Edje, PylgrimMap):
class Tile(evas.Image): class Tile(evas.Image):
def __init__(self, canvas): def __init__(self, canvas):
evas.Image.__init__(self,canvas) evas.Image.__init__(self, canvas)
self.pass_events = True self.pass_events = True
self.show() self.show()
#we need this to store the original position while the zoom animations #we need this to store the original position while the zoom animations
self.position = (0,0) self.position = (0, 0)
def set_position(self, x, y): def set_position(self, x, y):
self.position = (x,y) self.position = (x, y)
self.move(x,y) self.move(x, y)
class Mark(evas.Image): class Mark(evas.Image):
def __init__(self, canvas): def __init__(self, canvas):
evas.Image.__init__(self,canvas) evas.Image.__init__(self, canvas)
self.pass_events = True self.pass_events = True
self.show() self.show()
#we need this to store the original position while the zoom animations #we need this to store the original position while the zoom animations
self.position = (0,0) self.position = (0, 0)
def set_position(self, x, y): def set_position(self, x, y):
self.position = (x,y) self.position = (x, y)
self.move(x,y) self.move(x, y)
def __init__(self, evas_canvas, filename, initial_lat, initial_lon, initial_zoom=10, offline=False, use_overlay=True): def __init__(self, evas_canvas, filename, latitude, longitude, zoom=10, offline=False, use_overlay=True):
PylgrimMap.__init__(self) PylgrimMap.__init__(self)
self.evas_canvas = evas_canvas self.evas_canvas = evas_canvas
self.offline = offline self.offline = offline
self.use_overlay = use_overlay self.use_overlay = use_overlay
edje.Edje.__init__(self, self.evas_canvas.evas_obj.evas, file=filename, group="pylgrim") edje.Edje.__init__(self, self.evas_canvas.evas_obj.evas, file=filename, group="pylgrim")
self.size = self.evas_canvas.evas_obj.evas.size self.size = self.evas_canvas.evas_obj.evas.size
self.on_key_down_add(self.on_key_down) self.on_key_down_add(self.on_key_down)
self.on_key_up_add(self.on_key_up) self.on_key_up_add(self.on_key_up)
self.focus = True self.focus = True
self.evas_canvas.evas_obj.data["pylgrim"] = self self.evas_canvas.evas_obj.data["pylgrim"] = self
self.show() self.show()
#mouse position #mouse position
self.x_pos, self.y_pos = (0,0) self.x_pos, self.y_pos = (0, 0)
#global variable for zooming #global variable for zooming
self.zoom_step = 0.0 self.zoom_step = 0.0
#global list for tiles to download #global list for tiles to download
self.tiles_to_download = [] self.tiles_to_download = []
self.tiles_to_download_total = 0 self.tiles_to_download_total = 0
self.tiles_to_preload = [] self.tiles_to_preload = []
#initial lat,lon,zoom #initial latitude, longitude, zoom
self.lat = initial_lat self.latitude = latitude
self.lon = initial_lon self.longitude = longitude
self.x = 0 self.x = 0
self.y = 0 self.y = 0
self.z = initial_zoom self.zoom = zoom
self.offset_x = 0 self.offset_x = 0
self.offset_y = 0 self.offset_y = 0
self.icons = [] self.icons = []
self.overlay = edje.Edje(self.evas_canvas.evas_obj.evas, file=filename, group='overlay') self.overlay = edje.Edje(self.evas_canvas.evas_obj.evas, file=filename, group='overlay')
self.overlay.size = self.evas_canvas.evas_obj.evas.size self.overlay.size = self.evas_canvas.evas_obj.evas.size
self.overlay.layer = 2 self.overlay.layer = 2
self.evas_canvas.evas_obj.data["overlay"] = self.overlay self.evas_canvas.evas_obj.data["overlay"] = self.overlay
self.overlay.show() self.overlay.show()
if self.use_overlay: if self.use_overlay:
self.progress_bg = evas.Rectangle(self.evas_canvas.evas_obj.evas) self.progress_bg = evas.Rectangle(self.evas_canvas.evas_obj.evas)
self.progress_bg.geometry = 0,0,0,0 self.progress_bg.geometry = 0, 0, 0, 0
self.progress_bg.color = 255, 255, 255, 255 self.progress_bg.color = 255, 255, 255, 255
self.progress_bg.layer = 3 self.progress_bg.layer = 3
self.progress_bg.show() self.progress_bg.show()
self.progress = evas.Rectangle(self.evas_canvas.evas_obj.evas) self.progress = evas.Rectangle(self.evas_canvas.evas_obj.evas)
self.progress.geometry = 0,0,0,0 self.progress.geometry = 0, 0, 0, 0
self.progress.color = 255, 0, 0, 255 self.progress.color = 255, 0, 0, 255
self.progress.layer = 4 self.progress.layer = 4
self.progress.show() self.progress.show()
''' '''
self.menu = edje.Edje(self.evas_canvas.evas_obj.evas, file=filename, group='menu') self.menu = edje.Edje(self.evas_canvas.evas_obj.evas, file=filename, group='menu')
self.menu.size = self.evas_canvas.evas_obj.evas.size self.menu.size = self.evas_canvas.evas_obj.evas.size
self.menu.layer = 4 self.menu.layer = 4
self.evas_canvas.evas_obj.data["menu"] = self.menu self.evas_canvas.evas_obj.data["menu"] = self.menu
self.menu.show() self.menu.show()
''' '''
#calculate size of tile raster #calculate size of tile raster
self.border_x = int(math.ceil(self.size[0]/256.0)) self.border_x = int(math.ceil(self.size[0]/256.0))
self.border_y = int(math.ceil(self.size[1]/256.0)) self.border_y = int(math.ceil(self.size[1]/256.0))
self.mouse_down = False self.mouse_down = False
self.animate = False self.animate = False
self.set_current_tile(initial_lat, initial_lon, initial_zoom) self.set_current_tile(self.latitude, self.longitude, zoom)
''' '''
self.marker = PylgrimView.Mark(self.evas_canvas.evas_obj.evas) self.marker = PylgrimView.Mark(self.evas_canvas.evas_obj.evas)
self.marker.file_set("blue-dot.png") self.marker.file_set("blue-dot.png")
self.marker.lat = 49.073866 self.marker.latitude = 49.073866
self.marker.lon = 8.184814 self.marker.longitude = 8.184814
self.marker.size_set(32,32) self.marker.size_set(32, 32)
self.marker.fill_set(0,0,32,32) self.marker.fill_set(0, 0, 32, 32)
self.marker.x = (self.marker.lon+180)/360 * 2**self.z self.marker.x = (self.marker.longitude+180)/360 * 2**self.zoom
self.marker.y = (1-math.log(math.tan(self.marker.lat*math.pi/180) + 1/math.cos(self.marker.lat*math.pi/180))/math.pi)/2 * 2**self.z self.marker.y = (1-math.log(math.tan(self.marker.latitude*math.pi/180) + 1/math.cos(self.marker.latitude*math.pi/180))/math.pi)/2 * 2**self.zoom
self.marker.offset_x, self.marker.offset_y = int((self.marker.x-int(self.marker.x))*256),int((self.marker.y-int(self.marker.y))*256) self.marker.offset_x, self.marker.offset_y = int((self.marker.x-int(self.marker.x))*256), int((self.marker.y-int(self.marker.y))*256)
self.marker.set_position(self.size[0]/2-16+256*(int(self.marker.x)-int(self.x))+self.marker.offset_x-self.offset_x, self.size[1]/2-32+256*(int(self.marker.y)-int(self.y))+self.marker.offset_y-self.offset_y) self.marker.set_position(self.size[0]/2-16+256*(int(self.marker.x)-int(self.x))+self.marker.offset_x-self.offset_x, self.size[1]/2-32+256*(int(self.marker.y)-int(self.y))+self.marker.offset_y-self.offset_y)
self.marker.layer = 1 self.marker.layer = 1
self.marker.show() self.marker.show()
''' '''
#ecore.timer_add(3, self.init_dbus) ecore.timer_add(3, self.init_dbus)
def init_dbus(self): def init_dbus(self):
print 'LocationFeed init_dbus' print 'PylgrimView init_dbus'
try: try:
gps_obj = SystemBus(mainloop=DBusEcoreMainLoop()).get_object('org.mobile.gps', '/org/mobile/gps/RemoteObject') gps_obj = SystemBus(mainloop=DBusEcoreMainLoop()).get_object(DBUS_NAME,
gps_name = 'org.mobile.gps.RemoteInterface' #'/org/mobile/GoogleLocation',
gps_obj.connect_to_signal("position", self.position, dbus_interface=gps_name) '/org/mobile/GpsLocation',
self.gps_interface = Interface(gps_obj, gps_name) )
#self.gps_interface.get_position() gps_obj.connect_to_signal("position", self.position, dbus_interface=DIN_LOCATION)
return False self.gps_interface = Interface(gps_obj, DIN_LOCATION)
except Exception, e: self.gps_interface.GetPosition(reply_handler=self.position, error_handler=err, )
print 'LocationFeed', e return False
return True except Exception, e:
print 'PylgrimView', e
return True
def position(self, content): def position(self, content):
fix = int(content.get('fix', 0)) content = dedbusmap(content)
if fix: print 'position', content
latitude = float(content.get('latitude', self.lat)) fix = int(content.get('fix', 0))
longitude = float(content.get('longitude', self.lon)) if fix:
print 'position', latitude, longitude latitude = float(content.get('latitude', self.latitude))
if not self.animate: longitude = float(content.get('longitude', self.longitude))
self.set_current_tile(latitude, longitude, self.z) print 'position', latitude, longitude
if not self.animate:
self.set_current_tile(latitude, longitude, self.zoom)
def on_key_down(self, obj, event): def on_key_down(self, obj, event):
if event.keyname in ("F6", "f"): if event.keyname in ("F6", "f"):
self.evas_canvas.evas_obj.fullscreen = not self.evas_canvas.evas_obj.fullscreen self.evas_canvas.evas_obj.fullscreen = not self.evas_canvas.evas_obj.fullscreen
elif event.keyname in ("Escape", "q"): elif event.keyname in ("Escape", "q"):
ecore.main_loop_quit() ecore.main_loop_quit()
elif event.keyname in ("F7","plus") and not self.animate: elif event.keyname in ("F7", "plus") and not self.animate:
ecore.timer_add(0.05, self.animate_zoom_in) ecore.timer_add(0.05, self.animate_zoom_in)
elif event.keyname in ("F8","minus") and not self.animate: elif event.keyname in ("F8", "minus") and not self.animate:
ecore.timer_add(0.05, self.animate_zoom_out) ecore.timer_add(0.05, self.animate_zoom_out)
elif event.keyname in ("Up",) and not self.animate: elif event.keyname in ("Up", ) and not self.animate:
delta_y = -10 delta_y = -10
for icon in self.icons: for icon in self.icons:
icon.set_position(icon.pos[0],icon.pos[1]-delta_y) icon.set_position(icon.pos[0], icon.pos[1]-delta_y)
self.current_pos = (self.current_pos[0],self.current_pos[1]-delta_y) self.current_pos = (self.current_pos[0], self.current_pos[1]-delta_y)
elif event.keyname in ("Down",) and not self.animate: elif event.keyname in ("Down", ) and not self.animate:
delta_y = 10 delta_y = 10
for icon in self.icons: for icon in self.icons:
icon.set_position(icon.pos[0],icon.pos[1]-delta_y) icon.set_position(icon.pos[0], icon.pos[1]-delta_y)
self.current_pos = (self.current_pos[0],self.current_pos[1]-delta_y) self.current_pos = (self.current_pos[0], self.current_pos[1]-delta_y)
elif event.keyname in ("Left",) and not self.animate: elif event.keyname in ("Left", ) and not self.animate:
delta_x = -10 delta_x = -10
for icon in self.icons: for icon in self.icons:
icon.set_position(icon.pos[0]-delta_x,icon.pos[1]) icon.set_position(icon.pos[0]-delta_x, icon.pos[1])
self.current_pos = (self.current_pos[0]-delta_x,self.current_pos[1]) self.current_pos = (self.current_pos[0]-delta_x, self.current_pos[1])
elif event.keyname in ("Right",) and not self.animate: elif event.keyname in ("Right", ) and not self.animate:
delta_x = 10 delta_x = 10
for icon in self.icons: for icon in self.icons:
icon.set_position(icon.pos[0]-delta_x,icon.pos[1]) icon.set_position(icon.pos[0]-delta_x, icon.pos[1])
self.current_pos = (self.current_pos[0]-delta_x,self.current_pos[1]) self.current_pos = (self.current_pos[0]-delta_x, self.current_pos[1])
else: else:
print "key not recognized:",event.keyname print "key not recognized:", event.keyname
def on_key_up(self, obj, event): def on_key_up(self, obj, event):
if event.keyname in ("Up","Down", "Left", "Right") and not self.animate: if event.keyname in ("Up", "Down", "Left", "Right") and not self.animate:
if abs(self.current_pos[0]) > self.size[0]/2 or abs(self.current_pos[1]) > self.size[1]/2: if abs(self.current_pos[0]) > self.size[0]/2 or abs(self.current_pos[1]) > self.size[1]/2:
self.x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0 self.x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0
self.y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0 self.y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0
self.offset_x, self.offset_y = int((self.x-int(self.x))*256),int((self.y-int(self.y))*256) self.offset_x, self.offset_y = int((self.x-int(self.x))*256), int((self.y-int(self.y))*256)
self.init_redraw() self.init_redraw()
self.update_coordinates() self.update_coordinates()
#jump to coordinates #jump to coordinates
def set_current_tile(self, lat, lon, z): def set_current_tile(self, latitude, longitude, zoom):
#update shown coordinates everytime they change #update shown coordinates everytime they change
self.overlay.part_text_set("label", "lat:%f lon:%f zoom:%d"%(lat,lon,z)) self.overlay.part_text_set("label", "latitude:%f longitude:%f zoom:%d"%(latitude, longitude, zoom))
x = (lon+180)/360 * 2**z x = (longitude+180)/360 * 2**zoom
y = (1-math.log(math.tan(lat*math.pi/180) + 1/math.cos(lat*math.pi/180))/math.pi)/2 * 2**z y = (1-math.log(math.tan(latitude*math.pi/180) + 1/math.cos(latitude*math.pi/180))/math.pi)/2 * 2**zoom
offset_x, offset_y = int((x-int(x))*256),int((y-int(y))*256) offset_x, offset_y = int((x-int(x))*256), int((y-int(y))*256)
#only redraw if x, y, z, offset_x or offset_y differ from before #only redraw if x, y, zoom, offset_x or offset_y differ from before
if int(x) != int(self.x) \ if int(x) != int(self.x) \
or int(y) != int(self.y) \ or int(y) != int(self.y) \
or z != self.z \ or zoom != self.zoom \
or offset_x != self.offset_x \ or offset_x != self.offset_x \
or offset_y != self.offset_y: or offset_y != self.offset_y:
self.z = z self.zoom = zoom
self.x = x self.x = x
self.y = y self.y = y
self.offset_x, self.offset_y = offset_x, offset_y self.offset_x, self.offset_y = offset_x, offset_y
self.init_redraw() self.init_redraw()
def init_redraw(self): def init_redraw(self):
print "redraw" print "redraw"
self.animate = True self.animate = True
#reload icons list if its length differs from before eg. when size changes #reload icons list if its length differs from before eg. when size changes
if len(self.icons) != (2*self.border_x+1)*(2*self.border_y+1): if len(self.icons) != (2*self.border_x+1)*(2*self.border_y+1):
print "x:", self.border_x, "y:", self.border_y print "x:", self.border_x, "y:", self.border_y
#clean up #clean up
for icon in self.icons: for icon in self.icons:
icon.delete() icon.delete()
self.icons = [] self.icons = []
#fill #fill
for i in xrange((2*self.border_x+1)*(2*self.border_y+1)): for i in xrange((2*self.border_x+1)*(2*self.border_y+1)):
self.icons.append(PylgrimView.Tile(self.evas_canvas.evas_obj.evas)) self.icons.append(PylgrimView.Tile(self.evas_canvas.evas_obj.evas))
if not self.offline: if not self.offline:
#add all tiles that are not yet downloaded to a list #add all tiles that are not yet downloaded to a list
for i in xrange(2*self.border_x+1): for i in xrange(2*self.border_x+1):
for j in xrange(2*self.border_y+1): for j in xrange(2*self.border_y+1):
if not os.path.exists("%d/%d/%d.png"%(self.z,self.x+i-self.border_x,self.y+j-self.border_y))\ if not os.path.exists("%d/%d/%d.png"%(self.zoom, self.x+i-self.border_x, self.y+j-self.border_y))\
and not (self.z,self.x+i-self.border_x,self.y+j-self.border_y) in self.tiles_to_download: and not (self.zoom, self.x+i-self.border_x, self.y+j-self.border_y) in self.tiles_to_download:
self.tiles_to_download.append((self.z,self.x+i-self.border_x,self.y+j-self.border_y)) self.tiles_to_download.append((self.zoom, self.x+i-self.border_x, self.y+j-self.border_y))
self.tiles_to_download_total = len(self.tiles_to_download) self.tiles_to_download_total = len(self.tiles_to_download)
''' '''
#add additional tiles around the raster to a preload list #add additional tiles around the raster to a preload list
for i in xrange(2*self.border_x+3): for i in xrange(2*self.border_x+3):
if i == 0 or i == 2*self.border_x+2: if i == 0 or i == 2*self.border_x+2:
#if first or last row, download full row #if first or last row, download full row
for j in xrange(2*self.border_y+3): for j in xrange(2*self.border_y+3):
if not os.path.exists("%d/%d/%d.png"%(self.z,self.x+i-self.border_x-1,self.y+j-self.border_y-1)): if not os.path.exists("%d/%d/%d.png"%(self.zoom, self.x+i-self.border_x-1, self.y+j-self.border_y-1)):
self.tiles_to_preload.append((self.z,self.x+i-self.border_x-1,self.y+j-self.border_y-1)) self.tiles_to_preload.append((self.zoom, self.x+i-self.border_x-1, self.y+j-self.border_y-1))
#lots TODO here #lots TODO here
#let preload more than one tile - maybe a preload_border_x/y variable #let preload more than one tile - maybe a preload_border_x/y variable
#manage simultaneos proeloads #manage simultaneos proeloads
#manage not preloading duplicates #manage not preloading duplicates
else else
#else download first and last tile #else download first and last tile
''' '''
#if there are tiles to download, display progress bar #if there are tiles to download, display progress bar
if self.use_overlay and self.tiles_to_download_total > 0: if self.use_overlay and self.tiles_to_download_total > 0:
self.progress_bg.geometry = 39, self.size[1]/2-1, self.size[0]-78,22 self.progress_bg.geometry = 39, self.size[1]/2-1, self.size[0]-78, 22
self.progress.geometry = 40, self.size[1]/2, 1,20 self.progress.geometry = 40, self.size[1]/2, 1, 20
self.overlay.part_text_set("progress", "downloaded 0 of %d tiles"%self.tiles_to_download_total) self.overlay.part_text_set("progress", "downloaded 0 of %d tiles"%self.tiles_to_download_total)
ecore.timer_add(0.0, self.download_and_paint_current_tiles) ecore.timer_add(0.0, self.download_and_paint_current_tiles)
def download_and_paint_current_tiles(self): def download_and_paint_current_tiles(self):
if len(self.tiles_to_download) > 0: if len(self.tiles_to_download) > 0:
z,x,y = self.tiles_to_download.pop() zoom, x, y = self.tiles_to_download.pop()
if self.use_overlay: if self.use_overlay:
self.progress.geometry = 40, self.size[1]/2, (self.size[0]-80)*(self.tiles_to_download_total-len(self.tiles_to_download))/self.tiles_to_download_total,20 self.progress.geometry = 40, self.size[1]/2, (self.size[0]-80)*(self.tiles_to_download_total-len(self.tiles_to_download))/self.tiles_to_download_total, 20
self.overlay.part_text_set("progress", "downloaded %d of %d tiles"%(self.tiles_to_download_total-len(self.tiles_to_download),self.tiles_to_download_total)) self.overlay.part_text_set("progress", "downloaded %d of %d tiles"%(self.tiles_to_download_total-len(self.tiles_to_download), self.tiles_to_download_total))
self.download(x,y,z) self.download(x, y, zoom)
return True return True
#we get here if all tiles are downloaded #we get here if all tiles are downloaded
for i in xrange(2*self.border_x+1): for i in xrange(2*self.border_x+1):
for j in xrange(2*self.border_y+1): for j in xrange(2*self.border_y+1):
#if some errors occur replace with placeholder #if some errors occur replace with placeholder
filename = "%d/%d/%d.png"%(self.z,self.x+i-self.border_x,self.y+j-self.border_y) filename = "%d/%d/%d.png"%(self.zoom, self.x+i-self.border_x, self.y+j-self.border_y)
try: try:
self.icons[(2*self.border_y+1)*i+j].file_set(filename) self.icons[(2*self.border_y+1)*i+j].file_set(filename)
except Exception, e: except Exception, e:
print e print e
if os.path.exists(filename): if os.path.exists(filename):
os.unlink(filename) os.unlink(filename)
self.icons[(2*self.border_y+1)*i+j].file_set("404.png") self.icons[(2*self.border_y+1)*i+j].file_set("404.png")
self.icons[(2*self.border_y+1)*i+j].set_position((i-self.border_x)*256+self.size[0]/2-self.offset_x,(j-self.border_y)*256+self.size[1]/2-self.offset_y) self.icons[(2*self.border_y+1)*i+j].set_position((i-self.border_x)*256+self.size[0]/2-self.offset_x, (j-self.border_y)*256+self.size[1]/2-self.offset_y)
self.icons[(2*self.border_y+1)*i+j].size = 256,256 self.icons[(2*self.border_y+1)*i+j].size = 256, 256
self.icons[(2*self.border_y+1)*i+j].fill = 0, 0, 256, 256 self.icons[(2*self.border_y+1)*i+j].fill = 0, 0, 256, 256
self.current_pos = (0,0) self.current_pos = (0, 0)
if self.use_overlay: if self.use_overlay:
self.overlay.part_text_set("progress", "") self.overlay.part_text_set("progress", "")
self.progress_bg.geometry = 0,0,0,0 self.progress_bg.geometry = 0, 0, 0, 0
self.progress.geometry = 0,0,0,0 self.progress.geometry = 0, 0, 0, 0
self.animate = False self.animate = False
return False return False
def update_coordinates(self): def update_coordinates(self):
x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0 x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0
y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0 y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0
self.lon = (x*360)/2**self.z-180 self.longitude = (x*360)/2**self.zoom-180
n = math.pi*(1-2*y/2**self.z) n = math.pi*(1-2*y/2**self.zoom)
self.lat = 180/math.pi*math.atan(0.5*(math.exp(n)-math.exp(-n))) self.latitude = 180/math.pi*math.atan(0.5*(math.exp(n)-math.exp(-n)))
self.overlay.part_text_set("label", "lat:%f lon:%f zoom:%d"%(self.lat,self.lon,self.z)) self.overlay.part_text_set("label", "latitude:%f longitude:%f zoom:%d"%(self.latitude, self.longitude, self.zoom))
def zoom_in(self, z): def zoom_in(self, zoom):
for icon in self.icons: for icon in self.icons:
x = (1+z)*(icon.position[0]-self.size[0]/2)+self.size[0]/2 x = (1+zoom)*(icon.position[0]-self.size[0]/2)+self.size[0]/2
y = (1+z)*(icon.position[1]-self.size[1]/2)+self.size[1]/2 y = (1+zoom)*(icon.position[1]-self.size[1]/2)+self.size[1]/2
icon.geometry = int(x),int(y),256+int(256*z),256+int(256*z) icon.geometry = int(x), int(y), 256+int(256*zoom), 256+int(256*zoom)
icon.fill = 0, 0, 256+int(256*z),256+int(256*z) icon.fill = 0, 0, 256+int(256*zoom), 256+int(256*zoom)
def zoom_out(self, z): def zoom_out(self, zoom):
for icon in self.icons: for icon in self.icons:
x = (1-z*0.5)*(icon.position[0]-self.size[0]/2)+self.size[0]/2 x = (1-zoom*0.5)*(icon.position[0]-self.size[0]/2)+self.size[0]/2
y = (1-z*0.5)*(icon.position[1]-self.size[1]/2)+self.size[1]/2 y = (1-zoom*0.5)*(icon.position[1]-self.size[1]/2)+self.size[1]/2
icon.geometry = int(x),int(y),256-int(256*z*0.5),256-int(256*z*0.5) icon.geometry = int(x), int(y), 256-int(256*zoom*0.5), 256-int(256*zoom*0.5)
icon.fill = 0, 0, 256-int(256*z*0.5),256-int(256*z*0.5) icon.fill = 0, 0, 256-int(256*zoom*0.5), 256-int(256*zoom*0.5)
def animate_zoom_in(self): def animate_zoom_in(self):
if self.z < 18: if self.zoom < 18:
self.animate = True self.animate = True
if self.zoom_step < 1.0: if self.zoom_step < 1.0:
self.zoom_in(self.zoom_step) self.zoom_in(self.zoom_step)
self.zoom_step+=0.125 self.zoom_step+=0.125
return True return True
self.zoom_step = 0.0 self.zoom_step = 0.0
self.set_current_tile(self.lat, self.lon, self.z+1) self.set_current_tile(self.latitude, self.longitude, self.zoom+1)
else: else:
self.animate = False self.animate = False
return False return False
def animate_zoom_out(self): def animate_zoom_out(self):
if self.z > 5: if self.zoom > 5:
self.animate = True self.animate = True
if self.zoom_step < 1.0: if self.zoom_step < 1.0:
self.zoom_out(self.zoom_step) self.zoom_out(self.zoom_step)
self.zoom_step+=0.125 self.zoom_step+=0.125
return True return True
self.zoom_step = 0.0 self.zoom_step = 0.0
self.set_current_tile(self.lat, self.lon, self.z-1) self.set_current_tile(self.latitude, self.longitude, self.zoom-1)
else: else:
self.animate = False self.animate = False
return False return False
@edje.decorators.signal_callback("mouse,down,1", "*") @edje.decorators.signal_callback("mouse,down,1", "*")
def on_mouse_down(self, emission, source): def on_mouse_down(self, emission, source):
if not self.animate: if not self.animate:
if source in "plus": if source in "plus":
ecore.timer_add(0.05, self.animate_zoom_in) ecore.timer_add(0.05, self.animate_zoom_in)
elif source in "minus": elif source in "minus":
ecore.timer_add(0.05, self.animate_zoom_out) ecore.timer_add(0.05, self.animate_zoom_out)
else: else:
self.x_pos, self.y_pos = self.evas_canvas.evas_obj.evas.pointer_canvas_xy self.x_pos, self.y_pos = self.evas_canvas.evas_obj.evas.pointer_canvas_xy
self.mouse_down = True self.mouse_down = True
@edje.decorators.signal_callback("mouse,up,1", "*") @edje.decorators.signal_callback("mouse,up,1", "*")
def on_mouse_up(self, emission, source): def on_mouse_up(self, emission, source):
self.mouse_down = False self.mouse_down = False
if not self.animate: if not self.animate:
#redraw if moved further than one tile in each direction 'cause the preoload will only download one tile further than requested #redraw if moved further than one tile in each direction 'cause the preoload will only download one tile further than requested
if abs(self.current_pos[0]) > 256 or abs(self.current_pos[1]) > 256: if abs(self.current_pos[0]) > 256 or abs(self.current_pos[1]) > 256:
self.x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0 self.x = int(self.x) + (self.offset_x-self.current_pos[0])/256.0
self.y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0 self.y = int(self.y) + (self.offset_y-self.current_pos[1])/256.0
self.offset_x, self.offset_y = int((self.x-int(self.x))*256),int((self.y-int(self.y))*256) self.offset_x, self.offset_y = int((self.x-int(self.x))*256), int((self.y-int(self.y))*256)
self.init_redraw() self.init_redraw()
self.update_coordinates() self.update_coordinates()
if abs(self.current_pos[0]) > 0 or abs(self.current_pos[1]) > 0: if abs(self.current_pos[0]) > 0 or abs(self.current_pos[1]) > 0:
#on mouse up + move: update current coordinates #on mouse up + move: update current coordinates
self.update_coordinates() self.update_coordinates()
@edje.decorators.signal_callback("mouse,move", "*") @edje.decorators.signal_callback("mouse,move", "*")
def on_mouse_move(self, emission, source): def on_mouse_move(self, emission, source):
if self.mouse_down and not self.animate: if self.mouse_down and not self.animate:
x_pos, y_pos = self.evas_canvas.evas_obj.evas.pointer_canvas_xy x_pos, y_pos = self.evas_canvas.evas_obj.evas.pointer_canvas_xy
delta_x = self.x_pos - x_pos delta_x = self.x_pos - x_pos
delta_y = self.y_pos - y_pos delta_y = self.y_pos - y_pos
self.x_pos, self.y_pos = x_pos, y_pos self.x_pos, self.y_pos = x_pos, y_pos
for icon in self.icons: for icon in self.icons:
icon.set_position(icon.pos[0]-delta_x,icon.pos[1]-delta_y) icon.set_position(icon.pos[0]-delta_x, icon.pos[1]-delta_y)
self.current_pos = (self.current_pos[0]-delta_x,self.current_pos[1]-delta_y) self.current_pos = (self.current_pos[0]-delta_x, self.current_pos[1]-delta_y)
#self.marker.set_position(self.marker.pos[0]-delta_x,self.marker.pos[1]-delta_y) #self.marker.set_position(self.marker.pos[0]-delta_x, self.marker.pos[1]-delta_y)
class PylgrimControl(PylgrimView): class PylgrimControl(PylgrimView):
def __init__(self, evas_canvas, filename, initial_lat, initial_lon, initial_zoom=10, offline=False, use_overlay=True): def __init__(self, evas_canvas, filename, latitude, longitude, zoom=10, offline=False, use_overlay=True):
PylgrimView.__init__(self, evas_canvas, filename, initial_lat, initial_lon, initial_zoom=10, offline=False, use_overlay=True) PylgrimView.__init__(self, evas_canvas, filename, latitude, longitude, zoom=10, offline=False, use_overlay=True)
if __name__ == "__main__": if __name__ == "__main__":
WIDTH = 480 WIDTH = 480
HEIGHT = 640 HEIGHT = 640
TITLE = "pylgrim" TITLE = "pylgrim"
WM_NAME = "pylgrim" WM_NAME = "pylgrim"
WM_CLASS = "swallow" WM_CLASS = "swallow"
from optparse import OptionParser from optparse import OptionParser
class myOptionParser(OptionParser): class myOptionParser(OptionParser):
def __init__(self, usage): def __init__(self, usage):
OptionParser.__init__(self, usage) OptionParser.__init__(self, usage)
self.add_option("-e", self.add_option("-e",
"--engine", "--engine",
type="choice", type="choice",
choices=("x11", "x11-16"), choices=("x11", "x11-16"),
default="x11-16", default="x11-16",
help=("which display engine to use (x11, x11-16), " help=("which display engine to use (x11, x11-16), "
"default=%default")) "default=%default"))
self.add_option("-n", self.add_option("-n",
"--no-fullscreen", "--no-fullscreen",
action="store_true", action="store_true",
help="do not launch in fullscreen") help="do not launch in fullscreen")
self.add_option("-o", self.add_option("-o",
"--offline", "--offline",
action="store_true", action="store_true",
help="do not attempt to download tiles") help="do not attempt to download tiles")
self.add_option("-g", self.add_option("-g",
"--geometry", "--geometry",
type="string", type="string",
metavar="WxH", metavar="WxH",
action="callback", action="callback",
callback=self.parse_geometry, callback=self.parse_geometry,
default=(WIDTH, HEIGHT), default=(WIDTH, HEIGHT),
help="use given window geometry") help="use given window geometry")
self.add_option("-f", self.add_option("-f",
"--fps", "--fps",
type="int", type="int",
default=20, default=20,
help="frames per second to use, default=%default") help="frames per second to use, default=%default")
def parse_geometry(self, option, opt, value, parser): def parse_geometry(self, option, opt, value, parser):
try: try:
w, h = value.split("x") w, h = value.split("x")
w = int(w) w = int(w)
h = int(h) h = int(h)
except Exception, e: except Exception, e:
raise optparse.OptionValueError("Invalid format for %s" % option) raise optparse.OptionValueError("Invalid format for %s" % option)
parser.values.geometry = (w, h) parser.values.geometry = (w, h)
class EvasCanvas(object): class EvasCanvas(object):
def __init__(self, fullscreen, engine, size): def __init__(self, fullscreen, engine, size):
if engine == "x11": if engine == "x11":
f = ecore.evas.SoftwareX11 f = ecore.evas.SoftwareX11
elif engine == "x11-16": elif engine == "x11-16":
if ecore.evas.engine_type_supported_get("software_x11_16"): if ecore.evas.engine_type_supported_get("software_x11_16"):
f = ecore.evas.SoftwareX11_16 f = ecore.evas.SoftwareX11_16
else: else:
print "warning: x11-16 is not supported, fallback to x11" print "warning: x11-16 is not supported, fallback to x11"
f = ecore.evas.SoftwareX11 f = ecore.evas.SoftwareX11
self.evas_obj = f(w=size[0], h=size[1]) self.evas_obj = f(w=size[0], h=size[1])
self.evas_obj.callback_delete_request = self.on_delete_request self.evas_obj.callback_delete_request = self.on_delete_request
self.evas_obj.callback_resize = self.on_resize self.evas_obj.callback_resize = self.on_resize
self.evas_obj.title = TITLE self.evas_obj.title = TITLE
self.evas_obj.name_class = (WM_NAME, WM_CLASS) self.evas_obj.name_class = (WM_NAME, WM_CLASS)
self.evas_obj.fullscreen = fullscreen self.evas_obj.fullscreen = fullscreen
self.evas_obj.size = size self.evas_obj.size = size
self.evas_obj.show() self.evas_obj.show()
def on_resize(self, evas_obj): def on_resize(self, evas_obj):
x, y, w, h = evas_obj.evas.viewport x, y, w, h = evas_obj.evas.viewport
size = (w, h) size = (w, h)
for key in evas_obj.data.keys(): for key in evas_obj.data.keys():
evas_obj.data[key].size = size evas_obj.data[key].size = size
#calculate size of tile raster #calculate size of tile raster
evas_obj.data["pylgrim"].border_x = int(math.ceil(evas_obj.data["pylgrim"].size[0]/256.0)) evas_obj.data["pylgrim"].border_x = int(math.ceil(evas_obj.data["pylgrim"].size[0]/256.0))
evas_obj.data["pylgrim"].border_y = int(math.ceil(evas_obj.data["pylgrim"].size[1]/256.0)) evas_obj.data["pylgrim"].border_y = int(math.ceil(evas_obj.data["pylgrim"].size[1]/256.0))
evas_obj.data["pylgrim"].init_redraw() evas_obj.data["pylgrim"].init_redraw()
def on_delete_request(self, evas_obj): def on_delete_request(self, evas_obj):
ecore.main_loop_quit() ecore.main_loop_quit()
options, args = myOptionParser(usage="usage: %prog [options]").parse_args() print 'start', __name__
edje.frametime_set(1.0 / options.fps) options, args = myOptionParser(usage="usage: %prog [options]").parse_args()
evas_canvas = EvasCanvas( edje.frametime_set(1.0 / options.fps)
fullscreen=not options.no_fullscreen, evas_canvas = EvasCanvas(
engine=options.engine, fullscreen=not options.no_fullscreen,
size=options.geometry engine=options.engine,
) size=options.geometry
filename = os.path.splitext(sys.argv[0])[0] + ".edj" )
PylgrimControl(evas_canvas, filename, 49.009051, 8.402481, 13, options.offline, ) filename = os.path.splitext(sys.argv[0])[0] + ".edj"
ecore.main_loop_begin() PylgrimControl(evas_canvas, filename, 49.009051, 8.402481, 13, options.offline, )
ecore.main_loop_begin()
''' # vim:tw=0:nowrap
export CPPFLAGS="$CPPFLAGS -I/opt/e17/include"
export LDFLAGS="$LDFLAGS -L/opt/e17/lib"
export PKG_CONFIG_PATH="/opt/e17/lib/pkgconfig:$PKG_CONFIG_PATH"
export PATH="$PATH:/opt/e17/bin"
export PYTHONPATH="/home/josch/usr/lib/python2.5/site-packages"
'''