vcs.maemo.org Git - wifihood/blob - wifiview

   1 #!/usr/bin/env python
   2
   3 import gtk
   4 import gobject
   5
   6 import urllib2
   7 import math
   8
   9 import os
  10
  11 class mapWidget(gtk.Image):
  12
  13   def __init__(self):
  14
  15     gtk.Image.__init__(self)
  16
  17     # Maximum width should be 800, but actually gets reduced
  18     self.win_x , self.win_y = 800 , 480
  19
  20     p = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, self.win_x, self.win_y)
  21     self.set_from_pixbuf(p)
  22
  23     zoom = 17
  24     lat = 40.40491
  25     lon = -3.6774
  26     self.reftile_x , self.reftile_y = self.lon2tilex( lon , zoom ) , self.lat2tiley( lat , zoom )
  27     self.zoom = zoom
  28     # Half the size of a tile
  29     self.refpix_x , self.refpix_y = 128 , 128
  30     self.refpix_x , self.refpix_y = 0 , 0
  31
  32     self.composeMap( zoom )
  33
  34   def lon2tilex ( self , lon , zoom ) :
  35     return int( ( lon + 180 ) / 360 * 2 ** zoom )
  36
  37   def lat2tiley ( self , lat , zoom ) :
  38     lat = lat * math.pi / 180
  39     return int( ( 1 - math.log( math.tan( lat ) + 1 / math.cos( lat ) ) / math.pi ) / 2 * 2 ** zoom )
  40
  41   def composeMap( self , zoom ) :
  42     center_x , center_y = self.win_x / 2 , self.win_y / 2
  43
  44     # To get the central pixel in the window center, we must shift to the tile origin
  45     center_x -= self.refpix_x
  46     center_y -= self.refpix_y
  47
  48     # Ranges should be long enough as to fill the screen
  49     # Maybe they should be decided based on self.win_x, self.win_y
  50     for i in range(-3,4) :
  51       for j in range(-3,4) :
  52         file = self.tilename( i , j , zoom )
  53         if file is None :
  54           pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 256, 256 )
  55           pixbuf.fill( 0x00000000 )
  56         else :
  57           try :
  58             pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  59           except gobject.GError , ex :
  60             print "Corrupted file %s" % ( file )
  61             os.unlink( file )
  62             #file = self.tilename( self.reftile_x + i , self.reftile_y + j , zoom )
  63             file = self.tilename( i , j , zoom )
  64             try :
  65               pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  66             except :
  67               print "Total failure for tile for %s,%s" % ( self.reftile_x + i , self.reftile_y + j )
  68               pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, 256, 256 )
  69
  70         dest_x = 256 * i + center_x
  71         dest_y = 256 * j + center_y
  72
  73         init_x = 0
  74         size_x = 256
  75         if dest_x < 0 :
  76            init_x = abs(dest_x)
  77            size_x = 256 + dest_x
  78            dest_x = 0
  79         if dest_x + 256 > self.win_x :
  80            size_x = self.win_x - dest_x
  81
  82         init_y = 0
  83         size_y = 256
  84         if dest_y < 0 :
  85            init_y = abs(dest_y)
  86            size_y = 256 + dest_y
  87            dest_y = 0
  88         if dest_y + 256 > self.win_y :
  89            size_y = self.win_y - dest_y
  90
  91         if ( size_x > 0 and size_y > 0 ) and ( init_x < 256 and init_y < 256 ) :
  92             pixbuf.copy_area( init_x, init_y, size_x, size_y, self.get_pixbuf(), dest_x , dest_y )
  93         del(pixbuf)
  94
  95   def tilename ( self , x , y , zoom ) :
  96     file = self.tile2file( self.reftile_x + x , self.reftile_y + y , zoom )
  97     try :
  98       os.stat(file)
  99     except :
 100     #  if mapDownload :
 101       if False :
 102         try :
 103           # useful members : response.code, response.headers
 104           response = urllib2.urlopen( "http://tile.openstreetmap.org/%s/%s/%s.png" % ( zoom , x , y ) )
 105           if response.geturl() == "http://tile.openstreetmap.org/11/0/0.png" :
 106               return None
 107           fd = open( file , 'w' )
 108           fd.write( response.read() )
 109           fd.close()
 110         except :
 111           return None
 112       else :
 113         return None
 114     return file
 115
 116   def tile2file( self , tilex , tiley , zoom ) :
 117     basedir = "/home/user/MyDocs/.maps/OpenStreetMap I"
 118     rootdir = "%s/%s" % ( basedir , zoom )
 119     if not os.path.isdir( rootdir ) :
 120       os.mkdir(rootdir)
 121     rootsubdir = "%s/%s" % ( rootdir , tilex )
 122     if not os.path.isdir( rootsubdir ) :
 123       os.mkdir(rootsubdir)
 124     return "%s/%s.png" % ( rootsubdir , tiley )
 125
 126   def Shift( self , dx , dy ) :
 127     self.hide()
 128
 129     tile_x , tile_y = ( self.refpix_x - dx ) / 256 , ( self.refpix_y - dy ) / 256
 130     self.reftile_x += tile_x
 131     self.reftile_y += tile_y
 132
 133     self.refpix_x -= dx + 256 * tile_x
 134     self.refpix_y -= dy + 256 * tile_y
 135
 136     self.composeMap( self.zoom )
 137     self.show()
 138
 139   def SetZoom( self , zoom ) :
 140     self.hide()
 141     # FIXME : Use current lat,lon instead of hardcoded ones
 142     lat , lon = 40.40491 , -3.6774
 143     self.reftile_x , self.reftile_y = self.lon2tilex( lon , zoom ) , self.lat2tiley( lat , zoom )
 144     self.zoom = zoom
 145     self.refpix_x , self.refpix_y = 128 , 128
 146     self.composeMap( zoom )
 147     self.show()
 148
 149   def Up( self ) :
 150     self.hide()
 151     self.reftile_y -= 1
 152     self.composeMap( self.zoom )
 153     self.show()
 154
 155   def Down( self ) :
 156     self.hide()
 157     self.reftile_y += 1
 158     self.composeMap( self.zoom )
 159     self.show()
 160
 161   def Right( self ) :
 162     self.hide()
 163     self.reftile_x += 1
 164     self.composeMap( self.zoom )
 165     self.show()
 166
 167   def Left( self ) :
 168     self.hide()
 169     self.reftile_x -= 1
 170     self.composeMap( self.zoom )
 171     self.show()
 172
 173 class ZoomDialog ( gtk.Dialog ) :
 174
 175     def __init__ ( self , widget ) :
 176         gtk.Dialog.__init__( self , "Select zoom level",
 177                              None,
 178                              gtk.DIALOG_MODAL,
 179                              ( gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
 180                                gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT
 181                                )
 182                              )
 183
 184         zooms = gtk.ListStore(int)
 185         combo = gtk.ComboBox( zooms )
 186
 187         for zoom in range(8,19) :
 188             iter = zooms.append()
 189             zooms.set( iter , 0 , zoom )
 190             if zoom == widget.zoom :
 191                 combo.set_active_iter( iter )
 192
 193         cell = gtk.CellRendererText()
 194         combo.pack_start(cell, True)
 195         combo.add_attribute(cell, 'text', 0)
 196
 197         self.vbox.pack_start(combo , True, True, 0)
 198
 199         self.connect_object( "response", self.response , combo , widget )
 200
 201     def response ( self , combo , response  , widget ) :
 202         if response == gtk.RESPONSE_ACCEPT :
 203             item = combo.get_active_iter()
 204             model = combo.get_model()
 205             widget.SetZoom( model.get(item,0)[0] )
 206         self.destroy()
 207
 208
 209 class MapWindow:
 210
 211     def delete_event(self, widget, event, data=None):
 212         # If you return FALSE in the "delete_event" signal handler,
 213         # GTK will emit the "destroy" signal. Returning TRUE means
 214         # you don't want the window to be destroyed.
 215         # This is useful for popping up 'are you sure you want to quit?'
 216         # type dialogs.
 217         print "delete event occurred"
 218
 219         # Change FALSE to TRUE and the main window will not be destroyed
 220         # with a "delete_event".
 221         return False
 222
 223     def destroy(self, widget, data=None):
 224         print "destroy signal occurred"
 225         gtk.main_quit()
 226
 227     def press_event ( self, widget, event, *args ) :
 228       # FIXME : Set only if far enough from borders
 229       border_x = 40
 230       border_y = 30
 231       print "press  ",event.get_coords(),event.get_root_coords()
 232       if event.x > border_x and event.y > border_y and event.x < ( self.size_x - border_x ) and event.y < ( self.size_y - border_y ) :
 233         self.click_x = event.x
 234         self.click_y = event.y
 235
 236     def release_event ( self, widget, event, *args ) :
 237       min_shift = 50
 238       print "unpress",event.get_coords(),event.get_root_coords()
 239       if self.click_x is not None and self.click_y is not None :
 240         delta_x = int( event.x - self.click_x )
 241         delta_y = int( event.y - self.click_y )
 242         shift = math.sqrt( delta_x * delta_x + delta_y * delta_y )
 243         if shift > min_shift :
 244           self.map.Shift(delta_x, delta_y)
 245         #  if delta_x > 100 :
 246         #    self.map.Left()
 247         #  elif delta_x < -100 :
 248         #    self.map.Right()
 249         #  elif delta_y > 100 :
 250         #    self.map.Up()
 251         #  elif delta_y < -100 :
 252         #    self.map.Down()
 253       self.click_x , self.click_y = None , None
 254
 255     def screen_event ( self, widget, event, *args ) :
 256       print "REDIOS",event
 257       print "      ",widget
 258       print "      ",args
 259
 260
 261     def on_button_press ( self, widget, event, *args ) :
 262       print "HOLA",event
 263
 264     def on_key_press ( self, widget, event, *args ) :
 265       if event.keyval == gtk.keysyms.Up :
 266           self.map.Up()
 267       elif event.keyval == gtk.keysyms.Down :
 268           self.map.Down()
 269       elif event.keyval == gtk.keysyms.Right :
 270           self.map.Right()
 271       elif event.keyval == gtk.keysyms.Left :
 272           self.map.Left()
 273       else :
 274           print "UNKNOWN",event.keyval
 275
 276     def __init__(self):
 277
 278         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 279
 280         self.window.connect("delete_event", self.delete_event)
 281         self.window.connect("destroy", self.destroy)
 282
 283         self.window.set_border_width(10)
 284
 285         self.window.connect("key-press-event", self.on_key_press)
 286
 287         vbox = gtk.VBox(False, 0)
 288         self.window.add( vbox )
 289
 290         # To get explicit GDK_BUTTON_PRESS instead of paired GDK_LEAVE_NOTIFY & GDK_ENTER_NOTIFY
 291 #        self.window.add_events(gtk.gdk.BUTTON_MOTION_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK)
 292         self.window.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK )
 293         #
 294 #        self.window.connect('motion_notify_event', self.screen_event)
 295         self.window.connect('button_press_event', self.press_event)
 296         self.window.connect('button_release_event', self.release_event)
 297         #
 298         self.map = mapWidget()
 299         vbox.pack_end( self.map , True , True , 5)
 300
 301         self.create_menu( vbox )
 302
 303         # and the window
 304         self.window.show_all()
 305
 306         self.size_x , self.size_y = 800 , 480
 307         self.click_x , self.click_y = None , None
 308
 309     def zoomdialog ( self , widget ) :
 310         dialog = ZoomDialog( widget )
 311         dialog.show_all()
 312
 313     def create_menu ( self , vbox ) :
 314         menubar = gtk.MenuBar()
 315
 316         zoomlevel = gtk.MenuItem( label="Zoom level" )
 317         zoomlevel.connect_object( "activate", self.zoomdialog, self.map )
 318         menubar.append( zoomlevel )
 319
 320         vbox.pack_start(menubar,True,True,5)
 321
 322     def main(self):
 323         gtk.main()
 324
 325 if __name__ == "__main__":
 326     map = MapWindow()
 327     map.main()
 328