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

   1 #!/usr/bin/env python
   2
   3 import gtk
   4 import gobject
   5 try :
   6     import hildon
   7 except :
   8     hildon = False
   9
  10 import urllib2
  11 import math
  12
  13 import os
  14
  15 import wifimap.config
  16
  17 class mapWidget ( gtk.Image ) :
  18
  19   def __init__ ( self , config ) :
  20
  21     self.conf = config
  22     gtk.Image.__init__(self)
  23
  24     # Maximum width should be 800, but actually gets reduced
  25     self.win_x , self.win_y = 800 , 480
  26     self.tile_size = 256
  27
  28     p = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, True, 8, self.win_x, self.win_y)
  29     self.set_from_pixbuf(p)
  30
  31     self.reftile_x , self.refpix_x = self.lon2tilex( self.conf.lon , self.conf.zoom )
  32     self.reftile_y , self.refpix_y = self.lat2tiley( self.conf.lat , self.conf.zoom )
  33
  34     self.composeMap()
  35
  36   def lon2tilex ( self , lon , zoom ) :
  37     number = math.modf( ( lon + 180 ) / 360 * 2 ** zoom )
  38     return int( number[1] ) , int( self.tile_size * number[0] )
  39
  40   def lat2tiley ( self , lat , zoom ) :
  41     lat = lat * math.pi / 180
  42     number = math.modf( ( 1 - math.log( math.tan( lat ) + 1 / math.cos( lat ) ) / math.pi ) / 2 * 2 ** zoom )
  43     return int( number[1] ) , int( self.tile_size * number[0] )
  44
  45   def tilex2lon ( self , ( tilex , pixx ) , zoom ) :
  46     tilex = float(tilex)
  47     pixx = float(pixx)
  48     return ( tilex + pixx/self.tile_size ) / 2.0 ** zoom * 360.0 - 180.0
  49
  50   def tiley2lat ( self , ( tiley , pixy ) , zoom ) :
  51     tiley = float(tiley)
  52     pixy = float(pixy)
  53     tiley = math.pi * ( 1 - 2 * ( tiley + pixy/self.tile_size ) / 2.0 ** zoom )
  54     return math.degrees( math.atan( math.sinh( tiley ) ) )
  55
  56   def composeMap( self ) :
  57     center_x , center_y = self.win_x / 2 , self.win_y / 2
  58
  59     # To get the central pixel in the window center, we must shift to the tile origin
  60     center_x -= self.refpix_x
  61     center_y -= self.refpix_y
  62
  63     # Ranges should be long enough as to fill the screen
  64     # Maybe they should be decided based on self.win_x, self.win_y
  65     for i in range(-3,4) :
  66       for j in range(-3,4) :
  67         file = self.tilename( i , j , self.conf.zoom )
  68         if file is None :
  69           pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, self.tile_size, self.tile_size )
  70           pixbuf.fill( 0x00000000 )
  71         else :
  72           try :
  73             pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  74           except gobject.GError , ex :
  75             print "Corrupted file %s" % ( file )
  76             os.unlink( file )
  77             #file = self.tilename( self.reftile_x + i , self.reftile_y + j , self.conf.zoom )
  78             file = self.tilename( i , j , self.conf.zoom )
  79             try :
  80               pixbuf = gtk.gdk.pixbuf_new_from_file( file )
  81             except :
  82               print "Total failure for tile for %s,%s" % ( self.reftile_x + i , self.reftile_y + j )
  83               pixbuf = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, self.tile_size, self.tile_size )
  84
  85         dest_x = self.tile_size * i + center_x
  86         dest_y = self.tile_size * j + center_y
  87
  88         init_x = 0
  89         size_x = self.tile_size
  90         if dest_x < 0 :
  91            init_x = abs(dest_x)
  92            size_x = self.tile_size + dest_x
  93            dest_x = 0
  94         if dest_x + self.tile_size > self.win_x :
  95            size_x = self.win_x - dest_x
  96
  97         init_y = 0
  98         size_y = self.tile_size
  99         if dest_y < 0 :
 100            init_y = abs(dest_y)
 101            size_y = self.tile_size + dest_y
 102            dest_y = 0
 103         if dest_y + self.tile_size > self.win_y :
 104            size_y = self.win_y - dest_y
 105
 106         if ( size_x > 0 and size_y > 0 ) and ( init_x < self.tile_size and init_y < self.tile_size ) :
 107             pixbuf.copy_area( init_x, init_y, size_x, size_y, self.get_pixbuf(), dest_x , dest_y )
 108         del(pixbuf)
 109
 110     pixmap,mask = self.get_pixbuf().render_pixmap_and_mask()
 111     red = pixmap.new_gc()
 112     red.foreground = pixmap.get_colormap().alloc_color("red")
 113     green = pixmap.new_gc()
 114     green.foreground = pixmap.get_colormap().alloc_color("green")
 115     blue = pixmap.new_gc()
 116     blue.foreground = pixmap.get_colormap().alloc_color("blue")
 117
 118     filename = "/tmp/vale/wiscan_gui.campus.info"
 119     fd = open( filename )
 120     for line in fd.readlines() :
 121         values = line.split()
 122
 123         x_pos = self.lon2tilex( float(values[6]) , self.conf.zoom )
 124         y_pos = self.lat2tiley( float(values[5]) , self.conf.zoom )
 125
 126         dest_x = self.tile_size * ( x_pos[0] - self.reftile_x ) + center_x + x_pos[1]
 127         dest_y = self.tile_size * ( y_pos[0] - self.reftile_y ) + center_y + y_pos[1]
 128
 129         pixmap.draw_rectangle(blue, True , dest_x , dest_y , 3 , 3 )
 130     fd.close()
 131
 132     self.get_pixbuf().get_from_drawable( pixmap , pixmap.get_colormap() , 0, 0 , 0 , 0 , self.win_x, self.win_y )
 133
 134
 135   def tilename ( self , x , y , zoom ) :
 136     file = self.tile2file( self.reftile_x + x , self.reftile_y + y , zoom )
 137     try :
 138       os.stat(file)
 139     except :
 140     #  if mapDownload :
 141       if False :
 142         try :
 143           # useful members : response.code, response.headers
 144           response = urllib2.urlopen( "http://tile.openstreetmap.org/%s/%s/%s.png" % ( zoom , x , y ) )
 145           if response.geturl() == "http://tile.openstreetmap.org/11/0/0.png" :
 146               return None
 147           fd = open( file , 'w' )
 148           fd.write( response.read() )
 149           fd.close()
 150         except :
 151           return None
 152       else :
 153         return None
 154     return file
 155
 156   def tile2file( self , tilex , tiley , zoom ) :
 157     rootdir = "%s/%s/%s" % ( self.conf.mapsdir , self.conf.mapclass , zoom )
 158     if not os.path.isdir( rootdir ) :
 159       os.mkdir(rootdir)
 160     rootsubdir = "%s/%s" % ( rootdir , tilex )
 161     if not os.path.isdir( rootsubdir ) :
 162       os.mkdir(rootsubdir)
 163     return "%s/%s.png" % ( rootsubdir , tiley )
 164
 165   def Shift( self , dx , dy ) :
 166     self.hide()
 167
 168     tile_x , tile_y = ( self.refpix_x - dx ) / self.tile_size , ( self.refpix_y - dy ) / self.tile_size
 169     self.reftile_x += tile_x
 170     self.reftile_y += tile_y
 171
 172     self.refpix_x -= dx + self.tile_size * tile_x
 173     self.refpix_y -= dy + self.tile_size * tile_y
 174
 175     self.composeMap()
 176     self.show()
 177
 178   def ZoomChange ( self , selector ) :
 179     model = selector.get_model(0)
 180     active = selector.get_active(0)
 181     value = model.get( model.get_iter(active) , 0 )
 182     self.SetZoom( int(value[0]) )
 183
 184   def SetZoom( self , zoom ) :
 185     self.hide()
 186     lat = self.tiley2lat( ( self.reftile_y , self.refpix_y ) , self.conf.zoom )
 187     lon = self.tilex2lon( ( self.reftile_x , self.refpix_x ) , self.conf.zoom )
 188     self.reftile_x , self.refpix_x = self.lon2tilex( lon , zoom )
 189     self.reftile_y , self.refpix_y = self.lat2tiley( lat , zoom )
 190     self.conf.zoom = zoom
 191     self.composeMap()
 192     self.show()
 193
 194   def Up( self ) :
 195     self.hide()
 196     self.reftile_y -= 1
 197     self.composeMap()
 198     self.show()
 199
 200   def Down( self ) :
 201     self.hide()
 202     self.reftile_y += 1
 203     self.composeMap()
 204     self.show()
 205
 206   def Right( self ) :
 207     self.hide()
 208     self.reftile_x += 1
 209     self.composeMap()
 210     self.show()
 211
 212   def Left( self ) :
 213     self.hide()
 214     self.reftile_x -= 1
 215     self.composeMap()
 216     self.show()
 217
 218 if hildon :
 219
 220     class ZoomDialog ( hildon.TouchSelector ) :
 221
 222         def __init__ ( self , widget ) :
 223             hildon.TouchSelector.__init__( self )
 224
 225             zooms = gtk.ListStore(str)
 226
 227             active = index = 0
 228             for zoom in range(8,19) :
 229                 iter = zooms.append()
 230                 zooms.set( iter , 0 , "%2d" % zoom )
 231                 if zoom == widget.conf.zoom :
 232                     active = index
 233                 index += 1
 234
 235             column = self.append_text_column( zooms , True )
 236             #renderer = gtk.CellRendererText()
 237             #column = self.append_column( zooms , renderer )
 238             #column.set_property('text-column', 0)
 239
 240             # NOTE : with text=True, we must use 1 instead of 0
 241             self.set_active( 0 , active )
 242
 243 else :
 244
 245     class ZoomDialog ( gtk.Dialog ) :
 246
 247         def __init__ ( self , widget ) :
 248             gtk.Dialog.__init__( self , "Select zoom level",
 249                                  None,
 250                                  gtk.DIALOG_MODAL,
 251                                  ( gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
 252                                    gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT
 253                                    )
 254                                  )
 255
 256             zooms = gtk.ListStore(int)
 257             combo = gtk.ComboBox( zooms )
 258
 259             for zoom in range(8,19) :
 260                 iter = zooms.append()
 261                 zooms.set( iter , 0 , zoom )
 262                 if zoom == widget.conf.zoom :
 263                     combo.set_active_iter( iter )
 264
 265             cell = gtk.CellRendererText()
 266             combo.pack_start(cell, True)
 267             combo.add_attribute(cell, 'text', 0)
 268
 269             self.vbox.pack_start(combo , True, True, 0)
 270
 271             self.connect_object( "response", self.response , combo , widget )
 272
 273         def response ( self , combo , response  , widget ) :
 274             if response == gtk.RESPONSE_ACCEPT :
 275                 item = combo.get_active_iter()
 276                 model = combo.get_model()
 277                 widget.SetZoom( model.get(item,0)[0] )
 278             self.destroy()
 279
 280
 281 class MapWindow:
 282
 283     def destroy(self, widget, data=None):
 284         gtk.main_quit()
 285
 286     def press_event ( self, widget, event, *args ) :
 287       # FIXME : Set only if far enough from borders
 288       border_x = 40
 289       border_y = 30
 290       print "press  ",event.get_coords(),event.get_root_coords()
 291       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 ) :
 292         self.click_x = event.x
 293         self.click_y = event.y
 294
 295     def release_event ( self, widget, event, *args ) :
 296       min_shift = 50
 297       print "unpress",event.get_coords(),event.get_root_coords()
 298       if self.click_x is not None and self.click_y is not None :
 299         delta_x = int( event.x - self.click_x )
 300         delta_y = int( event.y - self.click_y )
 301         shift = math.sqrt( delta_x * delta_x + delta_y * delta_y )
 302         if shift > min_shift :
 303           self.map.Shift(delta_x, delta_y)
 304         #  if delta_x > 100 :
 305         #    self.map.Left()
 306         #  elif delta_x < -100 :
 307         #    self.map.Right()
 308         #  elif delta_y > 100 :
 309         #    self.map.Up()
 310         #  elif delta_y < -100 :
 311         #    self.map.Down()
 312       self.click_x , self.click_y = None , None
 313
 314     def screen_event ( self, widget, event, *args ) :
 315       print "REDIOS",event
 316       print "      ",widget
 317       print "      ",args
 318
 319
 320     def on_button_press ( self, widget, event, *args ) :
 321       print "HOLA",event
 322
 323     def on_key_press ( self, widget, event, *args ) :
 324       if event.keyval == gtk.keysyms.Up :
 325           self.map.Up()
 326       elif event.keyval == gtk.keysyms.Down :
 327           self.map.Down()
 328       elif event.keyval == gtk.keysyms.Right :
 329           self.map.Right()
 330       elif event.keyval == gtk.keysyms.Left :
 331           self.map.Left()
 332       else :
 333           print "UNKNOWN",event.keyval
 334
 335     def __init__(self):
 336
 337         if hildon :
 338             self.window = hildon.Window()
 339             program = hildon.Program.get_instance()
 340             program.add_window(self.window)
 341             gtk.set_application_name( "Wifi View" )
 342         else :
 343             self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
 344
 345         self.window.connect("destroy", self.destroy)
 346
 347         self.window.set_border_width(10)
 348
 349         self.window.connect("key-press-event", self.on_key_press)
 350
 351         vbox = gtk.VBox(False, 0)
 352         self.window.add( vbox )
 353
 354         # To get explicit GDK_BUTTON_PRESS instead of paired GDK_LEAVE_NOTIFY & GDK_ENTER_NOTIFY
 355 #        self.window.add_events(gtk.gdk.BUTTON_MOTION_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.POINTER_MOTION_MASK)
 356         self.window.set_events( gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK )
 357         #
 358 #        self.window.connect('motion_notify_event', self.screen_event)
 359         self.window.connect('button_press_event', self.press_event)
 360         self.window.connect('button_release_event', self.release_event)
 361         #
 362         self.config = wifimap.config.Configuration()
 363         self.map = mapWidget( self.config )
 364         vbox.pack_end( self.map , True , True , 5)
 365
 366         self.create_menu( vbox )
 367
 368         # and the window
 369         self.window.show_all()
 370
 371         self.size_x , self.size_y = 800 , 480
 372         self.click_x , self.click_y = None , None
 373
 374     def zoomdialog ( self , widget ) :
 375         dialog = ZoomDialog( widget )
 376         dialog.show_all()
 377
 378     def create_menu ( self , vbox ) :
 379         if hildon :
 380
 381             self.menubar = menubar = hildon.AppMenu()
 382
 383             #zoomlevel = hildon.Button(gtk.HILDON_SIZE_AUTO,
 384             #                          hildon.BUTTON_ARRANGEMENT_VERTICAL,
 385             #                          "Zoom level", None)
 386             #zoomlevel.connect_object( "clicked", self.zoomstack, self.map )
 387             selector = ZoomDialog( self.map )
 388             zoomlevel = hildon.PickerButton(gtk.HILDON_SIZE_AUTO,
 389                                           hildon.BUTTON_ARRANGEMENT_VERTICAL)
 390             zoomlevel.set_title( "Zoom" )
 391             zoomlevel.set_selector( selector )
 392             zoomlevel.connect_object( "value-changed", self.map.ZoomChange , selector )
 393             menubar.append( zoomlevel )
 394
 395             menubar.show_all()
 396             self.window.set_app_menu( menubar )
 397
 398         else :
 399
 400             menubar = gtk.MenuBar()
 401
 402             zoomlevel = gtk.MenuItem( label="Zoom level" )
 403             zoomlevel.connect_object( "activate", self.zoomdialog, self.map )
 404             menubar.append( zoomlevel )
 405
 406             vbox.pack_start(menubar,True,True,5)
 407
 408     def main(self):
 409         gtk.main()
 410
 411 if __name__ == "__main__":
 412     map = MapWindow()
 413     map.main()
 414