BUG FIX: reverse and re-layer pixbuf_from_signal() signal to icon comparisons

[wifi-radar.git] / wifi-radar

#!/usr/bin/python
#
#   $Id$
#    vi:set filetype=python noet:
#
#       A wireless profile manager for Linux
#
#   Originally created for x1000 Linux:
#           http://x1000.bitbuilder.com
#
#   Created by:
#           Ahmad Baitalmal <ahmad@baitalmal.com>
#
#   Maintained by:
#           Brian Elliott Finley <brian@thefinleys.com>
#       
#   License:
#       GPL
#
#       http://www.bitbuilder.com/wifi_radar
#       http://svn.systemimager.org
#
#       See CREDITS file for more contributors.
#       See ChangeLog file for, well, changes.
#

import ConfigParser, os, Queue, re, string, sys, threading
from signal import SIGTERM
from subprocess import call, Popen, PIPE
from time   import sleep
from types  import *

WIFI_RADAR_VERSION = "0.0.0"

if __debug__:
        print '__debug__ is True'
        # NOTE: Remove the '-OO' from '#!/usr/bin/python -OO' in the first line to 
        #       turn on debugging.

#
# Where the conf file should live could be different for your distro.  Please change
# at install time with "make install sysconfdir=/etc/wifi-radar" or similar. -BEF-
#
CONF_FILE                = "/etc/wifi-radar.conf"

os.environ['LC_MESSAGES'] = 'C'


#####################################
# Labels
USE_DHCP_LABEL  = "Automatic network configuration (DHCP)"
USE_IP_LABEL    = "Manual network configuration"
WIFI_SET_LABEL  = "WiFi Options"
CON_PP_LABEL    = "Connection Commands"
DIS_PP_LABEL    = "Disconnection Commands"
USE_WPA_LABEL   = "Use WPA"
NO_WPA_LABEL    = "No WPA"
####################################################################################################

####################################################################################################
####################################################################################################

# Sets the interface to the specified network device
def set_network_device(device):
        #print "set_network_device: ", device
        if device != "auto_detect":
                confFile.set_opt('DEFAULT.interface', device)
        else: # auto detect network device      
                # Get a list of 802.11 enabled devices by parsing the output of iwconfig.
                # If no devices are found, default to eth1.
                # call iwconfig command and read output
                iwconfig_info = Popen(confFile.get_opt('DEFAULT.iwconfig_command'), shell=True, stdout=PIPE).stdout
                wireless_devices = [ (x[0:x.find(" ")]) for x in iwconfig_info if("ESSID" in x)]
                if len(wireless_devices) > 0:
                        confFile.set_opt('DEFAULT.interface', wireless_devices[0])
                else:
                        print "No wifi-device found. Exiting."
                        sys.exit()

# Helper function to reduce code duplication
def get_new_profile():
        """ Return a blank profile """
        return { 'known': False,
                         'available': False,
                         'encrypted': False,
                         'essid': '',
                         'bssid': '',
                         'protocol': 'g',
                         'signal': 0,
                         'channel': 'auto',
                         'con_prescript': '',
                         'con_postscript': '',
                         'dis_prescript': '',
                         'dis_postscript': '',
                         'key': '',
                         'mode': '',
                         'security': '',
                         'use_wpa': False,
                         'wpa_driver': '',
                         'use_dhcp': True,
                         'ip': '',
                         'netmask': '',
                         'gateway': '',
                         'domain': '',
                         'dns1': '',
                         'dns2': ''
                        }

def get_profile_from_conf_file( essid, bssid, confFile ):
        # We got the essid, get the key
        profile = {}
        section_name = make_section_name( essid, bssid )
        if not confFile.has_section( section_name ):
                return None
        # read the option values
        for option in confFile.options(section_name):
                (profile['essid'], profile['bssid']) = split_section_name( section_name )
                profile[option] = confFile.get_opt(section_name + "." + option)
        return profile

def make_section_name( essid, bssid ):
        return essid + ':' + bssid

def split_section_name( section ):
        parts = re.split(':', section)
        return [ ':'.join(parts[0:len(parts)-6]), ':'.join(parts[len(parts)-6:len(parts)]) ]

def shellcmd( command ):
        """Run commands through the shell"""
        try:
                command = ' '.join(command)
                return_code = call(command, shell=True)
                if return_code >= 0:
                        if __debug__: print >>sys.stderr, "Child returned", return_code
                        return True
                else:
                        print >>sys.stderr, "Child was terminated by signal", -return_code
        except OSError, exception:
                print >>sys.stderr, "Execution failed:", exception
        return False

def convert_confFile():
        for apname in confFile.sections():
                if confFile.has_option( apname, 'prescript' ):
                        confFile.set( apname, 'con_prescript',  confFile.get( apname, 'prescript' ) )
                        confFile.remove_option( apname, 'prescript' )
                if confFile.has_option( apname, 'postscript' ):
                        confFile.set( apname, 'con_postscript',  confFile.get( apname, 'postscript' ) )
                        confFile.remove_option( apname, 'postscript' )
                confFile.set( apname, 'dis_prescript', '' )
                confFile.set( apname, 'dis_postscript', '' )

# Scan for a limited time, return ap names and bssid found
# Access points we find will be put on the outgoing Queue, apQueue
def scanning_thread( confFile, apQueue, commandQueue ):
        # Setup our essid pattern matcher
        essid_pattern           = re.compile( "ESSID\s*(:|=)\s*\"([^\"]+)\"", re.I | re.M  | re.S )
        protocol_pattern        = re.compile( "Protocol\s*(:|=)\s*IEEE 802.11\s*([abg]+)", re.I | re.M  | re.S )
        mode_pattern            = re.compile( "Mode\s*(:|=)\s*([^\n]+)", re.I | re.M  | re.S )
        channel_pattern         = re.compile( "Channel\s*(:|=)*\s*(\d+)", re.I | re.M  | re.S )
        enckey_pattern          = re.compile( "Encryption key\s*(:|=)\s*(on|off)", re.I | re.M  | re.S )
        signal_pattern          = re.compile( "Signal level\s*(:|=)\s*-?([0-9]+)", re.I | re.M  | re.S )
        
        access_points = {}
        command = "scan"
        while True:
                try:
                        command = commandQueue.get_nowait()
                        if __debug__: print "scanning_thread received command", command
                        command_read = True
                except Queue.Empty:
                        command_read = False
                if command == "scan":
                        if __debug__: print "Beginning scan pass"
                        # Some cards need to have the interface up to scan
                        if confFile.get_opt_as_bool('DEFAULT.ifup_required'):
                                # call ifconfig command and wait for return
                                shellcmd([confFile.get_opt('DEFAULT.ifconfig_command'), confFile.get_opt('DEFAULT.interface'), 'up'])
                        # update the signal strengths
                        scandata = Popen([confFile.get_opt('DEFAULT.iwlist_command'), confFile.get_opt('DEFAULT.interface'), 'scan'], stdout=PIPE).stdout.read()
                        #if __debug__:
                                #print "Current IP ", get_current_ip()
                                #print "Current ESSID ", get_current_essid()
                                #print "Current BSSID ", get_current_bssid()
                        # zero out the signal levels for all access points
                        for bssid in access_points:
                                access_points[bssid]['signal'] = 0
                        # split the scan data based on the address line
                        hits = scandata.split(' - ')
                        for hit in hits:
                                # set the defaults for profile template
                                profile = get_new_profile()
                                m = essid_pattern.search( hit )
                                if m:
                                        # we found an essid
                                        profile['essid'] = m.groups()[1]
                                        m = bssid_pattern.search( hit )                 # get BSSID from scan
                                        if m: profile['bssid'] = m.groups()[1]
                                        m = protocol_pattern.search( hit )              # get protocol from scan
                                        if m: profile['protocol'] = m.groups()[1]
                                        m = mode_pattern.search( hit )                  # get mode from scan
                                        if m: profile['mode'] = m.groups()[1]
                                        m = channel_pattern.search( hit )               # get channel from scan
                                        if m: profile['channel'] = m.groups()[1]
                                        m = enckey_pattern.search( hit )                # get encryption key from scan
                                        if m: profile['encrypted'] = ( m.groups()[1] == 'on' )
                                        m = signal_pattern.search( hit )                # get signal strength from scan
                                        if m: profile['signal'] = m.groups()[1]
                                        access_points[ profile['bssid'] ] = profile
                        for bssid in access_points:
                                access_points[bssid]['available'] = ( access_points[bssid]['signal'] > 0 )
                                # Put all, now or previously, sensed access_points into apQueue
                                try:
                                        apQueue.put_nowait( access_points[bssid] )
                                except Queue.Full:
                                        pass
                elif command == "exit":
                        if __debug__: print "Exiting scanning_thread"
                        return
                if command_read: commandQueue.task_done()
                if confFile.get_opt('DEFAULT.interface').find('ath') == 0:
                                sleep( 30 )
                else:
                                sleep( 1 )


### ConnectionManager
### class to manage connections
class ConnectionManager():
        def __init__( self, confFile, commandQueue ):
                self.confFile = confFile
                self.commQueue = commandQueue
                # is connection running?
                self.state = False
                if self.get_current_ip():
                        self.state = True
                        self.profile = self.confFile.get_profile( make_section_name(self.get_current_essid(), self.get_current_bssid()) )
                print "Connection state is currently:", self.state
        
        def if_change( self, state ):
                if ( (state.lower() == 'up') or (state.lower() == 'down') ):
                        # call ifconfig command and wait for return
                        shellcmd([self.confFile.get_opt('DEFAULT.ifconfig_command'), self.confFile.get_opt('DEFAULT.interface'), state])
        
        def connect_to_network( self, profile, status_window ):
                self.profile = profile
                msg = "Connecting to the %s (%s) network" % ( self.profile['essid'], self.profile['bssid'] )
                say( msg )
                if __debug__: print "   %s" % msg
                # ready to dance
                # Let's run the connection prescript
                if self.profile['con_prescript'].strip() != '':
                        # got something to execute
                        # run connection prescript through shell and wait for return
                        if __debug__: print "executing connection prescript:", self.profile['con_prescript']
                        shellcmd([self.profile['con_prescript']])
                if status_window:
                        status_window.run()
                # Some cards need to have the interface up
                if self.confFile.get_opt_as_bool('DEFAULT.ifup_required'):
                        self.if_change('up')
                # Start building iwconfig command line, command
                iwconfig_command = [ self.confFile.get_opt('DEFAULT.iwconfig_command') ]
                iwconfig_command.append( confFile.get_opt('DEFAULT.interface') )
                # Setting essid
                iwconfig_command.append( 'essid' )
                iwconfig_command.append( self.profile['essid'] )
                # Setting nick
                #iwconfig_commands.append( 'nick "%s"' % self.profile['essid'] )
                # Setting key
                iwconfig_command.append( 'key' )
                if self.profile['key'] == '':
                        iwconfig_command.append( 'off' )
                else:
                        iwconfig_command.append( self.profile['key'] )
                        #iwconfig_commands.append( "key %s %s" % ( self.profile['security'], self.profile['key'] ) )
                # Setting mode to Master, this will cause association with the AP to fail
                #iwconfig_command.append( 'mode' )
                #iwconfig_command.append( 'Master' )
                # Setting channel
                if self.profile['channel'] != '':
                        iwconfig_command.append( 'channel' )
                        iwconfig_command.append( self.profile['channel'] )
                # Now we do the ap by address (do this last since iwconfig seems to want it only there)
                iwconfig_command.append( 'ap' )
                iwconfig_command.append( self.profile['bssid'] )
                # Some cards require a commit
                if self.confFile.get_opt_as_bool('DEFAULT.commit_required'):
                        if __debug__: print 'iwconfig_args %s ' % ( iwconfig_args, )
                        iwconfig_command.append( 'commit' )
                # call iwconfig command and wait for return
                if not shellcmd(iwconfig_command): return
                # Now normal network stuff
                # Kill off any existing DHCP clients running
                if os.path.isfile(self.confFile.get_opt('DHCP.pidfile')):
                        if __debug__: print "Killing existing DHCP..."
                        try:
                                if self.confFile.get_opt('DHCP.kill_args') != '':
                                        # call DHCP client kill command and wait for return
                                        if __debug__: print self.confFile.get_opt('DHCP.command') + " " + self.confFile.get_opt('DHCP.kill_args')
                                        shellcmd([self.confFile.get_opt('DHCP.command'), self.confFile.get_opt('DHCP.kill_args')])
                                else:
                                        os.kill(int(open(self.confFile.get_opt('DHCP.pidfile'), mode='r').readline()), SIGTERM)
                        except OSError:
                                print "failed to kill DHCP client"
                                sys.exit()
                        finally:
                                print "Stale pid file.  Removing..."
                                os.remove(self.confFile.get_opt('DHCP.pidfile'))
                # Kill off any existing WPA supplicants running
                if os.access(self.confFile.get_opt('WPA.pidfile'), os.R_OK):
                        if __debug__: print "Killing existing WPA supplicant..."
                        try:
                                if not self.confFile.get_opt('WPA.kill_command') != '':
                                        # call WPA supplicant kill command and wait for return
                                        shellcmd([self.confFile.get_opt('WPA.kill_command'), self.confFile.get_opt('WPA.kill_command')])
                                else:
                                        os.kill(int(open(self.confFile.get_opt('WPA.pidfile'), mode='r').readline()), SIGTERM)
                        except OSError:
                                print "failed to kill WPA supplicant"
                                sys.exit()
                        finally:
                                print "Stale pid file.  Removing..."
                                os.remove(self.confFile.get_opt('WPA.pidfile'))
                # Begin WPA supplicant
                if self.profile['use_wpa'] :
                        if __debug__: print "WPA args: %s" % ( wpa_options, )
                        if status_window:
                                status_window.update_message("WPA supplicant starting")
                        # call WPA supplicant command and do not wait for return
                        wpa_proc = Popen([self.confFile.get_opt('WPA.command'), self.confFile.get_opt('WPA.args'), self.confFile.get_opt('DEFAULT.interface')])
                if self.profile['use_dhcp'] :
                        if __debug__: print "Disable iwlist while dhcp in progress..."
                        try:
                                self.commQueue.put("pause")
                        except Queue.Full:
                                pass
                        if status_window:
                                status_window.update_message("Acquiring IP Address (DHCP)")
                        # call DHCP client command and do not wait for return
                        dhcp_command = [ self.confFile.get_opt('DHCP.command') ]
                        dhcp_command.extend( self.confFile.get_opt('DHCP.args').split(' ') )
                        dhcp_command.append( self.confFile.get_opt('DEFAULT.interface') )
                        dhcp_proc = Popen(dhcp_command, stdout=None)
                        timer = self.confFile.get_opt_as_int('DHCP.timeout') + 3
                        tick = 0.25
                        waiting = dhcp_proc.poll()
                        while waiting == None:
                                waiting = dhcp_proc.poll()
                                if timer < 0:
                                        os.kill(dhcp_proc.pid, SIGTERM)
                                        break
                                if sys.modules.has_key("gtk"):
                                        while gtk.events_pending():
                                                gtk.main_iteration(False)
                                timer -= tick
                                sleep(tick)
                        if not self.get_current_ip():
                                if status_window:
                                        status_window.update_message("Could not get IP address!")
                                        if sys.modules.has_key("gtk"):
                                                while gtk.events_pending():
                                                        gtk.main_iteration(False)
                                        sleep(3)
                                else:
                                        print "Could not get IP address!"
                        else:
                                if status_window:
                                        status_window.update_message("Got IP address. Done.")
                                        self.state = True
                                        if sys.modules.has_key("gtk"):
                                                while gtk.events_pending():
                                                        gtk.main_iteration(False)
                                        sleep(2)
                        # Re-enable iwlist
                        try:
                                self.commQueue.put("scan")
                        except Queue.Full:
                                pass
                else:
                        ifconfig_command= "%s %s down; %s %s %s netmask %s" % ( self.confFile.get_opt('DEFAULT.ifconfig_command'), self.confFile.get_opt('DEFAULT.interface'), self.confFile.get_opt('DEFAULT.ifconfig_command'), self.confFile.get_opt('DEFAULT.interface'), self.profile['ip'], self.profile['netmask'] )
                        route_command   = "%s add default gw %s" % ( self.confFile.get_opt('DEFAULT.route_command'), self.profile['gateway'] )
                        resolv_contents = ''
                        if self.profile['domain'] != '': resolv_contents += "domain %s\n" % domain
                        if self.profile['dns1'] != '': resolv_contents += "nameserver %s\n" % dns1
                        if self.profile['dns2'] != '': resolv_contents += "nameserver %s\n" % dns2
                        if ( resolv_contents != '' ):
                                resolv_file=open('/etc/resolv.conf', 'w')
                                resolv_file.write(s)
                                resolv_file.close
                        if not shellcmd([ifconfig_command]): return
                        if not shellcmd([route_command]): return
                        self.state = True
                # Let's run the connection postscript
                con_postscript = self.profile['con_postscript']
                if self.profile['con_postscript'].strip() != '':
                        if __debug__: print "executing connection postscript:", self.profile['con_postscript']
                        shellcmd([self.profile['con_postscript']])
                if status_window:
                        status_window.destroy()
        
        def disconnect_interface( self ):
                msg = "Disconnecting"
                say( msg )
                if __debug__: print msg
                # Pause scanning while manipulating card
                try:
                        self.commQueue.put("pause")
                except Queue.Full:
                        pass
                # Let's run the disconnection prescript
                if self.profile['dis_prescript'].strip() != '':
                        if __debug__: print "executing disconnection prescript:", self.profile['dis_prescript']
                        shellcmd([self.profile['dis_prescript']])
                if __debug__: print "Kill off any existing DHCP clients running..."
                if os.path.isfile(self.confFile.get_opt('DHCP.pidfile')):
                        if __debug__: print "Killing existing DHCP..."
                        try:
                                if self.confFile.get_opt('DHCP.kill_args') != '':
                                        dhcp_command = [ self.confFile.get_opt('DHCP.command') ]
                                        dhcp_command.extend( self.confFile.get_opt('DHCP.kill_args').split(' ') )
                                        dhcp_command.append( self.confFile.get_opt('DEFAULT.interface') )
                                        if __debug__: print "DHCP command", dhcp_command
                                        # call DHCP client command and wait for return
                                        if not shellcmd(dhcp_command): return
                                else:
                                        os.kill(int(open(self.confFile.get_opt('DHCP.pidfile'), mode='r').readline()), SIGTERM)
                        except OSError:
                                print "failed to kill DHCP client"
                if __debug__: print "Kill off any existing WPA supplicants running..."
                if os.access(self.confFile.get_opt('WPA.pidfile'), os.R_OK):
                        if __debug__: print "Killing existing WPA supplicant..."
                        try:
                                if not self.confFile.get_opt('WPA.kill_command') != '':
                                        wpa_command = [ self.confFile.get_opt('WPA.kill_command').split(' ') ]
                                        if not shellcmd(wpa_command): return
                                else:
                                        os.kill(int(open(self.confFile.get_opt('WPA.pidfile'), mode='r').readline()), SIGTERM)
                        except OSError:
                                print "failed to kill WPA supplicant"
                print "shutdown wireless:", self.confFile.get_opt('DEFAULT.iwconfig_command'), self.confFile.get_opt('DEFAULT.interface'), 'essid', 'off', 'key', 'off', 'mode', 'auto', 'channel', 'auto', 'ap', 'off'
                shellcmd([self.confFile.get_opt('DEFAULT.iwconfig_command'), self.confFile.get_opt('DEFAULT.interface'), 'essid', 'off', 'key', 'off', 'mode', 'auto', 'channel', 'auto', 'ap', 'off'])
                if __debug__: print "Let's clear out the wireless stuff"
                if __debug__: print 'Now take the interface down'
                self.if_change('down')
                if __debug__: print 'Since it may be brought back up by the next scan, lets unset its IP'
                shellcmd([self.confFile.get_opt('DEFAULT.ifconfig_command'), self.confFile.get_opt('DEFAULT.interface'), '0.0.0.0'])
                # Let's run the disconnection postscript
                if self.profile['dis_postscript'].strip() != '':
                        if __debug__: print "executing disconnection postscript:", self.profile['dis_postscript']
                        shellcmd([self.profile['dis_postscript']])
                self.state = False
                if __debug__: print 'Disconnect complete.'
                # Begin scanning again
                try:
                        self.commQueue.put("scan")
                except Queue.Full:
                        pass
        
        def get_current_ip( self ):
                """Returns the current IP if any by calling ifconfig"""
                ifconfig_command = [ confFile.get_opt('DEFAULT.ifconfig_command'), confFile.get_opt('DEFAULT.interface') ]
                ifconfig_info = Popen(ifconfig_command, stdout=PIPE).stdout
                # Be careful to the language (inet adr: in French for example)
                #
                # Hi Brian
                # 
                # I'm using wifi-radar on a system with German translations (de_CH-UTF-8).
                # There the string in ifconfig is inet Adresse for the IP which isn't
                # found by the current get_current_ip function in wifi-radar. I changed
                # the according line (#289; gentoo, v1.9.6-r1) to
                # >ip_re = re.compile(r'inet [Aa]d?dr[^.]*:([^.]*\.[^.]*\.[^.]*\.[0-9]*)')
                # which works on my system (LC_ALL=de_CH.UTF-8) and still works with LC_ALL=C.
                # 
                # I'd be happy if you could incorporate this small change because as now
                # I've got to change the file every time it is updated.
                # 
                # Best wishes
                # 
                # Simon
                ip_re = re.compile(r'inet [Aa]d?dr[^.]*:([^.]*\.[^.]*\.[^.]*\.[0-9]*)')
                line = ifconfig_info.read()
                if ip_re.search( line ):
                        return ip_re.search( line ).group(1)
                return None

        def get_current_essid( self ):
                """Returns the current ESSID if any by calling iwconfig"""
                iwconfig_info = Popen([confFile.get_opt('DEFAULT.iwconfig_command'), confFile.get_opt('DEFAULT.interface')], stdout=PIPE).stdout
                # Be careful to the language (inet adr: in French for example)
                essid_re = re.compile( "ESSID\s*(:|=)\s*\"([^\"]+)\"", re.I | re.M  | re.S )
                line = iwconfig_info.read()
                if essid_re.search( line ):
                        return essid_re.search( line ).group(2)
                return None
        
        def get_current_bssid( self ):
                """Returns the current BSSID if any by calling iwconfig"""
                iwconfig_info = Popen([confFile.get_opt('DEFAULT.iwconfig_command'), confFile.get_opt('DEFAULT.interface')], stdout=PIPE).stdout
                bssid_re = re.compile( "Access Point\s*(:|=)\s*([a-zA-Z0-9:]+)", re.I | re.M  | re.S )
                line = iwconfig_info.read()
                if bssid_re.search( line ):
                        return bssid_re.search( line ).group(2)
                return None
        


##################
# The main window
class radar_window:
        def __init__( self, confFile, apQueue, commQueue ):
                # create the main window and connect the normal events
                global  signal_xpm_none
                global  signal_xpm_low
                global  signal_xpm_barely
                global  signal_xpm_ok
                global  signal_xpm_best
                global  known_profile_icon
                global  unknown_profile_icon
                global  wifi_radar_icon
                
                self.confFile = confFile
                self.apQueue = apQueue
                self.commandQueue = commQueue
                self.access_points = {}
                self.connection = None
                
                self.signal_none_pb                     = gtk.gdk.pixbuf_new_from_xpm_data( signal_xpm_none )
                self.known_profile_icon         = gtk.gdk.pixbuf_new_from_inline( len( known_profile_icon[0] ), known_profile_icon[0], False )
                self.unknown_profile_icon       = gtk.gdk.pixbuf_new_from_inline( len( unknown_profile_icon[0] ), unknown_profile_icon[0], False )
                self.signal_low_pb                      = gtk.gdk.pixbuf_new_from_xpm_data( signal_xpm_low )
                self.signal_barely_pb           = gtk.gdk.pixbuf_new_from_xpm_data( signal_xpm_barely )
                self.signal_ok_pb                       = gtk.gdk.pixbuf_new_from_xpm_data( signal_xpm_ok )
                self.signal_best_pb                     = gtk.gdk.pixbuf_new_from_xpm_data( signal_xpm_best )
                self.window = gtk.Dialog('WiFi Radar', None, gtk.DIALOG_MODAL )
                icon = gtk.gdk.pixbuf_new_from_inline( len( wifi_radar_icon[0] ), wifi_radar_icon[0], False )
                self.window.set_icon( icon )
                self.window.set_border_width( 10 )
                self.window.set_size_request( 720, 300 )
                self.window.set_title( "WiFi Radar" )
                self.window.connect( 'delete_event', self.delete_event )
                self.window.connect( 'destroy', self.destroy, )
                # let's create all our widgets
                self.current_network = gtk.Label()
                self.current_network.show()
                self.close_button = gtk.Button( "Close", gtk.STOCK_CLOSE )
                self.close_button.show()
                self.close_button.connect( 'clicked', self.delete_event, None  )
                self.preferences_button = gtk.Button( "Preferences", gtk.STOCK_PREFERENCES )
                self.preferences_button.show()
                self.preferences_button.connect( 'clicked', self.edit_preferences, None )
                #                            essid  bssid known_icon      known  available  wep_icon signal_level    mode protocol channel
                self.pstore = gtk.ListStore( str,   str,  gtk.gdk.Pixbuf, bool,  bool,      str,     gtk.gdk.Pixbuf, str, str,     str )
                self.plist = gtk.TreeView( self.pstore )
                # The essid column
                self.pix_cell   = gtk.CellRendererPixbuf()
                self.wep_cell   = gtk.CellRendererPixbuf()
                self.essid_cell = gtk.CellRendererText()
                self.bssid_cell = gtk.CellRendererText()
                self.bssid_cell.set_property("width-chars", 20)
                self.pcol = gtk.TreeViewColumn( "SSID" )
                self.pcol.pack_start( self.pix_cell, False )
                self.pcol.pack_start( self.wep_cell, False )
                self.pcol.pack_start( self.essid_cell, True )
                self.pcol.pack_start( self.bssid_cell, True )
                self.pcol.add_attribute( self.wep_cell, 'stock-id', 5 )
                self.pcol.add_attribute( self.pix_cell, 'pixbuf', 2 )
                self.pcol.add_attribute( self.essid_cell, 'text', 0 )
                self.pcol.add_attribute( self.bssid_cell, 'text', 1 )
                self.plist.append_column( self.pcol )
                # The signal column
                self.sig_cell   = gtk.CellRendererPixbuf()
                self.scol               = gtk.TreeViewColumn( "Signal" )
                self.scol.pack_start( self.sig_cell, True )
                self.scol.add_attribute( self.sig_cell, 'pixbuf', 6 )
                self.plist.append_column( self.scol )
                # The mode column
                self.mode_cell  = gtk.CellRendererText()
                self.mcol               = gtk.TreeViewColumn( "Mode" )
                self.mcol.pack_start( self.mode_cell, True )
                self.mcol.add_attribute( self.mode_cell, 'text', 7 )
                self.plist.append_column( self.mcol )
                # The protocol column
                self.prot_cell  = gtk.CellRendererText()
                self.protcol    = gtk.TreeViewColumn( "802.11" )
                self.protcol.pack_start( self.prot_cell, True )
                self.protcol.add_attribute( self.prot_cell, 'text', 8 )
                self.plist.append_column( self.protcol )
                # The channel column
                self.channel_cell       = gtk.CellRendererText()
                self.channel            = gtk.TreeViewColumn( "Channel" )
                self.channel.pack_start( self.channel_cell, True )
                self.channel.add_attribute( self.channel_cell, 'text', 9 )
                self.plist.append_column( self.channel )
                # DnD Ordering
                self.plist.set_reorderable( True )
                self.pstore.connect( 'row-changed', self.update_auto_profile_order )
                # enable/disable buttons based on the selected network
                self.selected_network = self.plist.get_selection()
                self.selected_network.connect( 'changed', self.on_network_selection, None )
                # the list scroll bar
                sb = gtk.VScrollbar( self.plist.get_vadjustment() )
                sb.show()
                self.plist.show()
                # Add New button
                self.new_button = gtk.Button( "_New" )
                self.new_button.connect( 'clicked', self.create_new_profile, get_new_profile(), None  )
                self.new_button.show()
                # Add Configure button
                self.edit_button = gtk.Button( "C_onfigure" )
                self.edit_button.connect( 'clicked', self.edit_profile, None  )
                self.edit_button.show()
                self.edit_button.set_sensitive(False)
                # Add Delete button
                self.delete_button = gtk.Button( "_Delete" )
                self.delete_button.connect( 'clicked', self.delete_profile, None  )
                self.delete_button.show()
                self.delete_button.set_sensitive(False)
                # Add Connect button
                self.connect_button = gtk.Button( "Co_nnect" )
                self.connect_button.connect( 'clicked', self.connect_profile, None  )
                # Add Disconnect button
                self.disconnect_button = gtk.Button( "D_isconnect" )
                self.disconnect_button.connect( 'clicked', self.disconnect_profile, None  )
                # lets add our widgets
                rows            = gtk.VBox( False, 3 )
                net_list        = gtk.HBox( False, 0 )
                listcols        = gtk.HBox( False, 0 )
                prows           = gtk.VBox( False, 0 )
                # lets start packing
                # the network list
                net_list.pack_start( self.plist, True, True, 0 )
                net_list.pack_start( sb, False, False, 0 )
                # the rows level
                rows.pack_start( net_list , True, True, 0 )
                rows.pack_start( self.current_network, False, True, 0 )
                # the list columns
                listcols.pack_start( rows, True, True, 0 )
                listcols.pack_start( prows, False, False, 5 )
                # the list buttons
                prows.pack_start( self.new_button, False, False, 2 )
                prows.pack_start( self.edit_button, False, False, 2 )
                prows.pack_start( self.delete_button, False, False, 2 )
                prows.pack_end( self.connect_button, False, False, 2 )
                prows.pack_end( self.disconnect_button, False, False, 2 )

                self.window.action_area.pack_start( self.preferences_button )
                self.window.action_area.pack_start( self.close_button )

                rows.show()
                prows.show()
                listcols.show()
                self.window.vbox.add( listcols )
                self.window.vbox.set_spacing( 3 )
                self.window.show_all()
                #
                # Now, immediately hide these two.  The proper one will be
                # displayed later, based on interface state. -BEF-
                self.disconnect_button.hide()
                self.connect_button.hide()
                
                # set up connection manager for later use
                self.connection = ConnectionManager( self.confFile, self.commandQueue )
                
                # Add our known profiles in order
                for ap in self.confFile.auto_profile_order:
                        ap = ap.strip()
                        self.access_points[ ap ] = self.confFile.get_profile( ap )
                        wep = None
                        if self.access_points[ ap ]['encrypted']: wep = gtk.STOCK_DIALOG_AUTHENTICATION
                        self.pstore.append( [ self.access_points[ ap ]['essid'], self.access_points[ ap ]['bssid'], self.known_profile_icon, self.access_points[ ap ]['known'], self.access_points[ ap ]['available'], wep, self.signal_none_pb, self.access_points[ ap ]['mode'], self.access_points[ ap ]['protocol'], self.access_points[ ap ]['channel'] ] )
                # This is the first run (or, at least, no config file was present), so pop up the preferences window
                if ( self.confFile.get_opt_as_bool('DEFAULT.new_file') == True ):
                        self.confFile.remove_option('DEFAULT', 'new_file')
                        self.edit_preferences(self.preferences_button)

        def main( self ):
                gtk.main()

        def destroy( self, widget = None):
                self.confFile.write()
                gtk.main_quit()

        def delete_event( self, widget, event, data=None ):
                # Put "exit" on the command Queue and wait indefinitely for it to be accepted
                try:
                        self.commandQueue.put("exit", True)
                except Queue.Full:
                        pass
                # Save the preferred networks order
                self.update_auto_profile_order()
                self.destroy()
                return False

        def update_plist_items( self ):
                """ Updates the profiles list """
                # Indicate to PyGtk that only one Gtk thread should run here
                gtk.gdk.threads_enter()
                # update the current ip and essid
                # set the state of connect/disconnect buttons based on whether we have an IP address
                if self.connection:
                        if self.connection.state:
                                self.current_network.set_text( "Connected to %s ip(%s)" % ( make_section_name( self.connection.get_current_essid(), self.connection.get_current_bssid() ), self.connection.get_current_ip() ) )
                                self.connect_button.hide()
                                self.disconnect_button.show()
                        else:
                                self.current_network.set_text( "Not Connected." )
                                self.disconnect_button.hide()
                                self.connect_button.show()

                while True:
                # Get profiles scanned by iwlist
                        try:
                                profile = self.apQueue.get_nowait()
                                prow_iter = self.get_row_by_ap( profile['essid'], profile['bssid'] )
                                wep = None
                                if prow_iter != None:
                                        # the AP is in the list of APs on the screen
                                        apname = make_section_name(profile['essid'], profile['bssid'])
                                        if self.access_points.has_key(apname):
                                                # This AP has been configured and is/should be stored in the config file
                                                profile['known'] = self.access_points[apname]['known']
                                                self.access_points[apname]['available'] = profile['available']
                                                self.access_points[apname]['encrypted'] = profile['encrypted']
                                                self.access_points[apname]['signal']    = profile['signal']
                                                self.access_points[apname]['mode']              = profile['mode']
                                                self.access_points[apname]['protocol']  = profile['protocol']
                                                self.access_points[apname]['channel']   = profile['channel']
                                        # Set the 'known' values; False is default, overridden to True by self.access_points
                                        self.pstore.set_value(prow_iter, 2, self.pixbuf_from_known( profile[ 'known' ] ))
                                        self.pstore.set_value(prow_iter, 3, profile[ 'known' ])
                                        self.pstore.set_value(prow_iter, 4, profile['available'])
                                        if profile['encrypted']: wep = gtk.STOCK_DIALOG_AUTHENTICATION
                                        self.pstore.set_value(prow_iter, 5, wep)
                                        self.pstore.set_value(prow_iter, 6, self.pixbuf_from_signal( profile['signal'] ))
                                        self.pstore.set_value(prow_iter, 7, profile['mode'])
                                        self.pstore.set_value(prow_iter, 8, profile['protocol'])
                                        self.pstore.set_value(prow_iter, 9, profile['channel'])
                                        #print "update_plist_items: profile update", profile[ 'essid' ], profile['bssid']
                                        #for val in self.pstore[prow_iter]:
                                                #print val,
                                else:
                                        # the AP is not in the list of APs on the screen
                                        self.pstore.append( [ profile[ 'essid' ], profile['bssid'], self.pixbuf_from_known( profile['known'] ), profile['known'], profile['available'], wep, self.pixbuf_from_signal( profile['signal'] ), profile['mode'], profile['protocol'], profile['channel'] ] )
                                        #print "update_plist_items: new profile", profile[ 'essid' ], profile['bssid']
                        except Queue.Empty:
                                # Allow other Gtk threads to run
                                gtk.gdk.threads_leave()
                                #print "update_plist_items: Empty apQueue"
                                return True

        def pixbuf_from_known( self, known ):
                """ return the proper icon for value of known """
                if known:
                        return self.known_profile_icon
                else:
                        return self.unknown_profile_icon

        def pixbuf_from_signal( self, signal ):
                signal = int( signal )
                #print "signal level:", signal
                if signal < 3:
                        return self.signal_none_pb
                elif signal < 12:
                        return self.signal_low_pb
                elif signal < 20:
                        return self.signal_barely_pb
                elif signal < 35:
                        return self.signal_ok_pb
                elif signal >= 35:
                        return self.signal_best_pb
                else:
                        return None

        def get_row_by_ap( self, essid, bssid ):
                for row in self.pstore:
                        if ( (row[0] == essid) and (row[1] == bssid) ):
                                #print "matched:", row.iter, essid, bssid
                                return row.iter
                return None

        # enable/disable buttons based on the selected network
        def on_network_selection( self, widget, data=None ):
                ( store, selected_iter ) = self.selected_network.get_selected()
                #print self.access_points[( make_section_name( store.get_value( selected_iter, 0 ), store.get_value( selected_iter, 1 ) ) )]
                # if no networks are selected, disable all buttons except New
                # (this occurs after a drag-and-drop)
                if selected_iter == None:
                        self.edit_button.set_sensitive(False)
                        self.delete_button.set_sensitive(False)
                        return
                # enable/disable buttons
                if (store.get_value(selected_iter, 3) == True):                         # is selected network known?
                        self.edit_button.set_sensitive(True)
                        self.delete_button.set_sensitive(True)
                else:
                        self.edit_button.set_sensitive(True)
                        self.delete_button.set_sensitive(False)

        # init and run the preferences dialog
        def edit_preferences( self, widget, data=None ):
                p = preferences_dialog( self, self.confFile )
                ok = p.run()
                p.destroy()

        def create_new_profile( self, widget, profile, data=None ):
                profile_editor = profile_dialog( self, profile )
                profile = profile_editor.run()
                profile_editor.destroy()
                if profile:
                        apname = make_section_name( profile['essid'], profile['bssid'] )
                        # Check that the ap does not exist already
                        if apname in self.confFile.profiles():
                                dlg = gtk.MessageDialog( self.window, gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, "A profile for %s already exists" % (apname) )
                                dlg.run()
                                dlg.destroy()
                                del dlg
                                # try again
                        self.access_points[ apname ] = profile
                        self.confFile.set_section( apname, profile )
                        # if it is not in the auto_profile_order add it
                        if not apname in self.confFile.auto_profile_order:
                                self.confFile.auto_profile_order.append(apname)
                        # add to the store
                        wep = None
                        if profile['encrypted']: wep = gtk.STOCK_DIALOG_AUTHENTICATION
                        return True
                else:
                        # Did not create new profile
                        return False

        def edit_profile( self, widget, data=None ):
                ( store, selected_iter ) = self.plist.get_selection().get_selected()
                if not selected_iter: return
                apname = make_section_name( store.get_value( selected_iter, 0 ), store.get_value( selected_iter, 1 ) )
                profile = self.confFile.get_profile( apname )
                if profile:
                        profile_editor = profile_dialog( self, profile )
                        profile = profile_editor.run()
                        profile_editor.destroy()
                        if profile:
                                if __debug__:
                                        print "Got edited profile ", profile
                                apname = make_section_name( profile['essid'], profile['bssid'] )
                                self.access_points[ apname ] = profile
                                self.confFile.set_section( apname, profile )
                else:
                        profile = get_new_profile()
                        profile['essid'] = store.get_value( selected_iter, 0 )
                        profile['bssid'] = store.get_value( selected_iter, 1 )
                        self.create_new_profile( widget, profile, data )
                print "edited: ", profile['essid'], profile['bssid']

        def delete_profile( self, widget, data=None ):
                ( store, selected_iter ) = self.plist.get_selection().get_selected()
                if not selected_iter: return
                essid   = store.get_value( selected_iter, 0 )
                bssid   = store.get_value( selected_iter, 1 )
                known   = store.get_value( selected_iter, 3 )
                if not known: return
                dlg = gtk.MessageDialog(
                                        self.window,
                                        gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
                                        gtk.MESSAGE_QUESTION,
                                        gtk.BUTTONS_YES_NO,
                                "Are you sure you want to delete the %s (%s) profile?" % (essid, bssid) )
                res = dlg.run()
                dlg.destroy()
                del dlg
                if res == gtk.RESPONSE_NO: return
                # Remove it
                apname = make_section_name( essid, bssid )
                del self.access_points[ apname ]
                self.confFile.remove_section( apname )
                print "delete_profile: ", apname, ":", self.confFile.auto_profile_order
                if apname in self.confFile.auto_profile_order: self.confFile.auto_profile_order.remove(apname)
                self.pstore.remove( selected_iter )
                # Let's save our current state
                self.update_auto_profile_order()

        def connect_profile( self, widget, profile, data=None ):
                ( store, selected_iter ) = self.plist.get_selection().get_selected()
                if not selected_iter: return
                essid   = store.get_value( selected_iter, 0 )
                bssid   = store.get_value( selected_iter, 1 )
                known   = store.get_value( selected_iter, 3 )
                if not known:
                        if data != 'noconnect':
                                dlg = gtk.MessageDialog(
                                                self.window,
                                                gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_MODAL,
                                                gtk.MESSAGE_QUESTION,
                                                gtk.BUTTONS_YES_NO,
                                        "This network does not have a profile configured.\n\nWould you like to create one now?" )
                                res = dlg.run()
                                dlg.destroy()
                                del dlg
                                if res == gtk.RESPONSE_NO: return
                        profile = get_new_profile()
                        profile['essid'] = store.get_value( selected_iter, 0 )
                        profile['bssid'] = store.get_value( selected_iter, 1 )
                        if not self.create_new_profile( widget, profile, data ):
                                return
                apname = make_section_name( store.get_value( selected_iter, 0 ), store.get_value( selected_iter, 1 ) )
                self.connection.connect_to_network( self.access_points[apname], status_window( self ) )

        def disconnect_profile( self, widget, data=None ):
                                self.connection.disconnect_interface()

        def update_auto_profile_order( self, widget = None, data = None, data2 = None ):
                # recreate the auto_profile_order
                auto_profile_order = []
                piter = self.pstore.get_iter_first()
                while piter:
                        # only if it's known
                        if self.pstore.get_value( piter, 3 ) == True:
                                auto_profile_order.append( make_section_name( self.pstore.get_value( piter, 0 ), self.pstore.get_value( piter, 1 ) ) )
                        piter = self.pstore.iter_next( piter )
                self.confFile.auto_profile_order = auto_profile_order

###################################
# the preferences dialog
class preferences_dialog:
        def __init__( self, parent, confFile ):
                # set up the preferences window
                global wifi_radar_icon
                self.parent = parent
                self.confFile = confFile
                self.dialog = gtk.Dialog('WiFi Radar Preferences', self.parent.window,
                        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, 
                        ( gtk.STOCK_CLOSE, True ) )
                icon = gtk.gdk.pixbuf_new_from_inline( len( wifi_radar_icon[0] ), wifi_radar_icon[0], False )
                self.dialog.set_icon( icon )
                self.dialog.set_resizable( True )
                self.dialog.set_transient_for( self.parent.window )
                self.tooltips = gtk.Tooltips()
                #
                # set up preferences widgets
                #
                
                # auto detect wireless device
                self.w_auto_detect = gtk.CheckButton("Auto-detect wireless device")
                
                print "prefs: ", self.confFile.get_opt('DEFAULT.interface')
                
                self.w_auto_detect.set_active( self.confFile.get_opt('DEFAULT.interface') == "auto_detect" )
                self.w_auto_detect.connect("toggled", self.toggle_auto_detect)
                self.tooltips.set_tip(self.w_auto_detect, "Automatically select wireless device to configure")
                self.dialog.vbox.pack_start(self.w_auto_detect, False, False, 5)
                # network interface selecter
                self.w_interface = gtk.combo_box_entry_new_text()
                iwconfig_info = Popen([self.confFile.get_opt('DEFAULT.iwconfig_command')], stdout=PIPE).stdout
                wireless_devices = [ (x[0:x.find(" ")]) for x in iwconfig_info if ("ESSID" in x)]
                for device in wireless_devices:
                        if device != self.confFile.get_opt('DEFAULT.interface'):
                                self.w_interface.append_text(device)
                if self.confFile.get_opt('DEFAULT.interface') != "auto_detect":
                        self.w_interface.prepend_text( self.confFile.get_opt('DEFAULT.interface') )
                self.w_interface.set_active(0)
                self.w_interface_label = gtk.Label("Wireless device")
                self.w_hbox1 = gtk.HBox(False, 0)
                self.w_hbox1.pack_start(self.w_interface_label, False, False, 5)
                self.w_hbox1.pack_start(self.w_interface, True, True, 0)
                self.w_interface.set_sensitive( self.confFile.get_opt('DEFAULT.interface') != "auto_detect" )
                self.dialog.vbox.pack_start(self.w_hbox1, False, False, 5)
                # scan timeout (spin button of integers from 1 to 100)
                self.time_in_seconds = gtk.Adjustment( self.confFile.get_opt_as_int('DEFAULT.scan_timeout'),1,100,1,1,1 )
                self.w_scan_timeout = gtk.SpinButton(self.time_in_seconds, 1, 0)
                self.w_scan_timeout.set_update_policy(gtk.UPDATE_IF_VALID)
                self.w_scan_timeout.set_numeric(True)
                self.w_scan_timeout.set_snap_to_ticks(True)
                self.w_scan_timeout.set_wrap(False)
                self.tooltips.set_tip(self.w_scan_timeout, "How long should WiFi Radar scan for access points?")
                self.w_scan_timeout_label = gtk.Label("Scan timeout (seconds)")
                self.w_hbox2 = gtk.HBox(False, 0)
                self.w_hbox2.pack_start(self.w_scan_timeout_label, False, False, 5)
                self.w_hbox2.pack_start(self.w_scan_timeout, True, True, 0)
                self.dialog.vbox.pack_start(self.w_hbox2, False, False, 5)
                # speak up
                self.w_speak_up = gtk.CheckButton("Use speak-up")
                self.w_speak_up.set_active( self.confFile.get_opt_as_bool('DEFAULT.speak_up') )
                self.tooltips.set_tip(self.w_speak_up, "Should I speak up when connecting to a network? (If you have a speech command)")
                self.dialog.vbox.pack_start(self.w_speak_up, False, False, 5)
                # commit required
                self.w_commit_required = gtk.CheckButton("Commit required")
                self.w_commit_required.set_active( self.confFile.get_opt_as_bool('DEFAULT.commit_required') )
                self.tooltips.set_tip(self.w_commit_required, "Check this box if your card requires a \"commit\" command with iwconfig")
                self.dialog.vbox.pack_start(self.w_commit_required, False, False, 5)
                # ifup required
                self.w_ifup_required = gtk.CheckButton("Ifup required")
                self.w_ifup_required.set_active( self.confFile.get_opt_as_bool('DEFAULT.ifup_required') )
                self.tooltips.set_tip(self.w_ifup_required, "Check this box if your system requires the interface to be brought up first")
                self.dialog.vbox.pack_start(self.w_ifup_required, False, False, 5)              
        
        def toggle_auto_detect(self, auto_detect_toggle, data=None):
                self.w_interface.set_sensitive(not auto_detect_toggle.get_active())

        def run(self):
                self.dialog.show_all()
                return self.dialog.run()

        def destroy(self):
                # save preferences to config file
                if self.w_auto_detect.get_active():
                        set_network_device("auto_detect")
                        self.confFile.set_opt('DEFAULT.interface', "auto_detect")
                else:
                        set_network_device(self.w_interface.child.get_text())
                        self.confFile.set_opt('DEFAULT.interface', self.w_interface.child.get_text())
                # reconfigure the dhcp commands in case the network device was changed
                self.confFile.set_float_opt('DEFAULT.scan_timeout', self.w_scan_timeout.get_value())
                self.confFile.set_bool_opt('DEFAULT.speak_up', self.w_speak_up.get_active())
                self.confFile.set_bool_opt('DEFAULT.commit_required', self.w_commit_required.get_active())
                self.confFile.set_bool_opt('DEFAULT.ifup_required', self.w_ifup_required.get_active())
                if self.confFile.get_opt_as_bool('DEFAULT.ifup_required'):
                        shellcmd([self.confFile.get_opt('DEFAULT.ifconfig_command'), self.confFile.get_opt('DEFAULT.interface'), 'up'])
                self.confFile.write()
                self.dialog.destroy()
                del self.dialog


###################################
class profile_dialog:
        def __init__( self, parent, profile ):
                global wifi_radar_icon
                self.parent = parent
                self.profile = profile
                self.WIFI_MODES         = [ '', 'auto', 'Managed', 'Ad-Hoc', 'Master', 'Repeater', 'Secondary', 'Monitor' ]
                self.WIFI_SECURITY      = [ '', 'open', 'restricted' ]
                self.WIFI_CHANNELS      = [ '', 'auto', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14' ]
                self.dialog = gtk.Dialog('WiFi Profile', self.parent.window,
                                                                gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
                                                                ( gtk.STOCK_CANCEL, False, gtk.STOCK_SAVE, True ) )
                icon = gtk.gdk.pixbuf_new_from_inline( len( wifi_radar_icon[0] ), wifi_radar_icon[0], False )
                self.dialog.set_icon( icon )
                self.dialog.set_resizable( False )
                self.dialog.set_transient_for( self.parent.window )
                #self.dialog.set_size_request( 400, 400 )
                #################
                essid_table = gtk.Table( 1, 2, False )
                essid_table.set_row_spacings( 3 )
                essid_table.set_col_spacings( 3 )

                # The essid labels
                essid_table.attach( gtk.Label( 'Network Name' ), 0, 1, 0, 1 )
                # The essid textboxes
                self.essid_entry = gtk.Entry( 32 )
                self.essid_entry.set_text( self.profile['essid'] )
                essid_table.attach( self.essid_entry, 1, 2, 0, 1 )
                # Add the essid table to the dialog
                self.dialog.vbox.pack_start( essid_table, True, True, 5 )

                bssid_table = gtk.Table( 1, 2, False )
                bssid_table.set_row_spacings( 3 )
                bssid_table.set_col_spacings( 3 )
                # The bssid labels
                bssid_table.attach( gtk.Label( 'Network bssid' ), 0, 1, 0, 1 )
                # The bssid textboxes
                self.bssid_entry = gtk.Entry( 32 )
                self.bssid_entry.set_text( self.profile['bssid'] )
                bssid_table.attach( self.bssid_entry, 1, 2, 0, 1 )
                #self.key = gtk.Entry( 32 )
                #bssid_table.attach( self.key, 1, 2, 1, 2 )
                # Add the bssid table to the dialog
                self.dialog.vbox.pack_start( bssid_table, True, True, 5 )

                # create the wifi expander
                self.wifi_expander = gtk.Expander( WIFI_SET_LABEL )
                #self.wifi_expander.connect( 'notify::expanded', self.toggle_use_dhcp )
                wifi_table = gtk.Table( 4, 2, False )
                wifi_table.set_row_spacings( 3 )
                wifi_table.set_col_spacings( 3 )
                # The Wifi labels
                wifi_table.attach( gtk.Label( 'Mode' ), 0, 1, 0, 1 )
                wifi_table.attach( gtk.Label( 'Channel' ), 0, 1, 1, 2 )
                wifi_table.attach( gtk.Label( 'Key' ), 0, 1, 2, 3 )
                wifi_table.attach( gtk.Label( 'Security' ), 0, 1, 3, 4 )
                # The Wifi text boxes
                self.mode_combo = gtk.combo_box_new_text()
                for mode in self.WIFI_MODES:
                        self.mode_combo.append_text( mode )
                self.mode_combo.set_active( self.get_array_index( self.profile['mode'], self.WIFI_MODES ) )
                wifi_table.attach( self.mode_combo, 1, 2, 0, 1 )
                self.channel_combo = gtk.combo_box_new_text()
                for channel in self.WIFI_CHANNELS:
                        self.channel_combo.append_text( channel )
                self.channel_combo.set_active( self.get_array_index( self.profile['channel'], self.WIFI_CHANNELS ) )
                wifi_table.attach( self.channel_combo, 1, 2, 1, 2 )
                
                self.key_entry = gtk.Entry( 32 )
                self.key_entry.set_text( self.profile['key'] )
                wifi_table.attach( self.key_entry, 1, 2, 2, 3 )
                
                self.security_combo = gtk.combo_box_new_text()
                for security in self.WIFI_SECURITY:
                        self.security_combo.append_text( security )
                self.security_combo.set_active( self.get_array_index( self.profile['security'], self.WIFI_SECURITY ) )
                wifi_table.attach( self.security_combo, 1, 2, 3, 4 )
                # Add the wifi table to the expander
                self.wifi_expander.add( wifi_table )
                # Add the expander to the dialog
                self.dialog.vbox.pack_start( self.wifi_expander, False, False, 5 )

                # create the wpa expander
                self.wpa_expander = gtk.Expander( NO_WPA_LABEL )
                self.wpa_expander.connect( 'notify::expanded', self.toggle_use_wpa )
                wpa_table = gtk.Table( 1, 2, False )
                wpa_table.set_row_spacings( 3 )
                wpa_table.set_col_spacings( 3 )
                # The labels
                wpa_table.attach( gtk.Label( 'Driver' ), 0, 1, 0, 1 )
                # The text boxes
                self.wpa_driver_entry = gtk.Entry()
                self.wpa_driver_entry.set_text( self.profile['wpa_driver'] )
                wpa_table.attach( self.wpa_driver_entry, 1, 2, 0, 1 )
                # Add the wpa table to the expander
                self.wpa_expander.add( wpa_table )
                # Add the expander to the dialog
                self.dialog.vbox.pack_start( self.wpa_expander, False, False, 5 )

                # create the dhcp expander
                self.dhcp_expander = gtk.Expander( USE_DHCP_LABEL )
                self.dhcp_expander.connect( 'notify::expanded', self.toggle_use_dhcp )
                ip_table = gtk.Table( 6, 2, False )
                ip_table.set_row_spacings( 3 )
                ip_table.set_col_spacings( 3 )
                # The IP labels
                ip_table.attach( gtk.Label( 'IP' ), 0, 1, 0, 1 )
                ip_table.attach( gtk.Label( 'Netmask' ), 0, 1, 1, 2 )
                ip_table.attach( gtk.Label( 'Gateway' ), 0, 1, 2, 3 )
                ip_table.attach( gtk.Label( 'Domain' ), 0, 1, 3, 4 )
                ip_table.attach( gtk.Label( 'DNS' ), 0, 1, 4, 5 )
                ip_table.attach( gtk.Label( 'DNS' ), 0, 1, 5, 6 )
                # The IP text boxes
                self.ip_entry = gtk.Entry( 15 )
                self.ip_entry.set_text( self.profile['ip'] )
                ip_table.attach( self.ip_entry, 1, 2, 0, 1 )
                self.netmask_entry = gtk.Entry( 15 )
                self.netmask_entry.set_text( self.profile['netmask'] )
                ip_table.attach( self.netmask_entry, 1, 2, 1, 2 )
                self.gw_entry = gtk.Entry( 15 )
                self.gw_entry.set_text( self.profile['gateway'] )
                ip_table.attach( self.gw_entry, 1, 2, 2, 3 )
                self.domain_entry = gtk.Entry( 32 )
                self.domain_entry.set_text( self.profile['domain'] )
                ip_table.attach( self.domain_entry, 1, 2, 3, 4 )
                self.dns1_entry = gtk.Entry( 15 )
                self.dns1_entry.set_text( self.profile['dns1'] )
                ip_table.attach( self.dns1_entry, 1, 2, 4, 5 )
                self.dns2_entry = gtk.Entry( 15 )
                self.dns2_entry.set_text( self.profile['dns2'] )
                ip_table.attach( self.dns2_entry, 1, 2, 5, 6 )
                # Add the ip table to the expander
                self.dhcp_expander.add( ip_table )
                # Add the expander to the dialog
                self.dialog.vbox.pack_start( self.dhcp_expander, False, False, 5 )

                # create the connection-building postpre expander
                self.con_pp_expander = gtk.Expander( CON_PP_LABEL )
                con_pp_table = gtk.Table( 2, 2, False )
                con_pp_table.set_row_spacings( 3 )
                con_pp_table.set_col_spacings( 3 )
                # The labels
                con_pp_table.attach( gtk.Label( 'Before' ), 0, 1, 0, 1 )
                con_pp_table.attach( gtk.Label( 'After' ), 0, 1, 1, 2 )
                # The text boxes
                self.con_prescript_entry = gtk.Entry()
                self.con_prescript_entry.set_text( self.profile['con_prescript'] )
                con_pp_table.attach( self.con_prescript_entry, 1, 2, 0, 1 )
                self.con_postscript_entry = gtk.Entry()
                self.con_postscript_entry.set_text( self.profile['con_postscript'] )
                con_pp_table.attach( self.con_postscript_entry, 1, 2, 1, 2 )
                # Add the pp table to the expander
                self.con_pp_expander.add( con_pp_table )
                # Add the expander to the dialog
                self.dialog.vbox.pack_start( self.con_pp_expander, False, False, 5 )

                # create the disconnection postpre expander
                self.dis_pp_expander = gtk.Expander( DIS_PP_LABEL )
                dis_pp_table = gtk.Table( 2, 2, False )
                dis_pp_table.set_row_spacings( 3 )
                dis_pp_table.set_col_spacings( 3 )
                # The labels
                dis_pp_table.attach( gtk.Label( 'Before' ), 0, 1, 0, 1 )
                dis_pp_table.attach( gtk.Label( 'After' ), 0, 1, 1, 2 )
                # The text boxes
                self.dis_prescript_entry = gtk.Entry()
                self.dis_prescript_entry.set_text( self.profile['dis_prescript'] )
                dis_pp_table.attach( self.dis_prescript_entry, 1, 2, 0, 1 )
                self.dis_postscript_entry = gtk.Entry()
                self.dis_postscript_entry.set_text( self.profile['dis_postscript'] )
                dis_pp_table.attach( self.dis_postscript_entry, 1, 2, 1, 2 )
                # Add the pp table to the expander
                self.dis_pp_expander.add( dis_pp_table )
                # Add the expander to the dialog
                self.dialog.vbox.pack_start( self.dis_pp_expander, False, False, 5 )

        def run( self ):
                self.dialog.show_all()
                if self.dialog.run():
                        self.profile['known']                   = True
                        self.profile['essid']                   = self.essid_entry.get_text().strip()
                        self.profile['bssid']                   = self.bssid_entry.get_text().strip()
                        self.profile['key']                             = self.key_entry.get_text().strip()
                        self.profile['mode']                    = self.get_array_item( self.mode_combo.get_active(), self.WIFI_MODES )
                        self.profile['security']                = self.get_array_item( self.security_combo.get_active(), self.WIFI_SECURITY )
                        self.profile['encrypted']               = ( self.profile['security'] != '' )
                        self.profile['channel']                 = self.get_array_item( self.channel_combo.get_active(), self.WIFI_CHANNELS )
                        self.profile['protocol']                = 'g'
                        self.profile['available']               = ( self.profile['signal'] > 0 )
                        self.profile['con_prescript']   = self.con_prescript_entry.get_text().strip()
                        self.profile['con_postscript']  = self.con_postscript_entry.get_text().strip()
                        self.profile['dis_prescript']   = self.dis_prescript_entry.get_text().strip()
                        self.profile['dis_postscript']  = self.dis_postscript_entry.get_text().strip()
                        # wpa
                        self.profile['use_wpa']                 = self.wpa_expander.get_expanded()
                        self.profile['wpa_driver']              = self.wpa_driver_entry.get_text().strip()
                        # dhcp
                        self.profile['use_dhcp']                = not self.dhcp_expander.get_expanded()
                        self.profile['ip']                              = self.ip_entry.get_text().strip()
                        self.profile['netmask']                 = self.netmask_entry.get_text().strip()
                        self.profile['gateway']                 = self.gw_entry.get_text().strip()
                        self.profile['domain']                  = self.domain_entry.get_text().strip()
                        self.profile['dns1']                    = self.dns1_entry.get_text().strip()
                        self.profile['dns2']                    = self.dns2_entry.get_text().strip()
                        return self.profile
                return None

        def destroy( self ):
                self.dialog.destroy()
                del self.dialog

        def toggle_use_dhcp( self, widget, data = None ):
                expanded = self.dhcp_expander.get_expanded()
                if expanded:
                        self.dhcp_expander.set_label( USE_IP_LABEL )
                else:
                        self.dhcp_expander.set_label( USE_DHCP_LABEL )

        def toggle_use_wpa( self, widget, data = None ):
                expanded = self.wpa_expander.get_expanded()
                if expanded:
                        self.wpa_expander.set_label( USE_WPA_LABEL )
                else:
                        self.wpa_expander.set_label( NO_WPA_LABEL )

        def get_array_index( self, item, array ):
                try:
                        return array.index( item.strip() )
                except:
                        pass
                return 0

        def get_array_item( self, index, array ):
                try:
                        return array[ index ]
                except:
                        pass
                return ''

### status_window
###
### A simple class for putting up a "Please wait" dialog so the user
### doesn't think we've forgotten about them.
class status_window:
        def __init__( self, parent ):
                global wifi_radar_icon
                self.parent = parent
                self.dialog = gtk.Dialog("Working", self.parent.window, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
                icon = gtk.gdk.pixbuf_new_from_inline( len( wifi_radar_icon[0] ), wifi_radar_icon[0], False )
                self.dialog.set_icon( icon )
                self.lbl = gtk.Label("Please wait...")
                self.bar = gtk.ProgressBar()
                self.dialog.vbox.pack_start(self.lbl)
                self.dialog.vbox.pack_start(self.bar)
                self.dialog.show_all()

        def update_message( self, message ):
                self.lbl.set_text(message)

        def inhibit_close( self, widget, signal ):
                return True

        def update_window( self ):
                # Do stuff
                self.bar.pulse()
                return True

        def run( self ):
                self.dialog.show_all()
                self.timer = gobject.timeout_add(250,self.update_window)
                return

        def destroy( self ):
                gobject.source_remove(self.timer)
                self.dialog.destroy()
                del self.dialog

### ConfigFile
### class to manage the configuration file
class ConfigFile(ConfigParser.SafeConfigParser):
        """ class to manage the configuration file """
        def __init__( self, filename, defaults ):
                self.filename = filename
                self.auto_profile_order = []
                ConfigParser.SafeConfigParser.__init__(self, defaults)
        
        def set_section( self, section_name, section_dict ):
                """ set the contents of a section to values from a dictionary """
                try:
                        self.add_section(section_name)
                except ConfigParser.DuplicateSectionError:
                        pass
                for key in section_dict.keys():
                        if type(section_dict[key]) == BooleanType:
                                self.set_bool_opt(section_name + "." + key, section_dict[key])
                        elif type(section_dict[key]) == IntType:
                                self.set_int_opt(section_name + "." + key, section_dict[key])
                        elif type(section_dict[key]) == FloatType:
                                self.set_float_opt(section_name + "." + key, section_dict[key])
                        else:
                                self.set_opt(section_name + "." + key, section_dict[key])
        
        def get_profile( self, section_name ):
                """ return the profile recorded in the specified section """
                if section_name in self.profiles():
                        str_types = [ 'bssid', 'channel', 'essid', 'protocol', 'con_prescript', 'con_postscript', 'dis_prescript', 'dis_postscript', 'key', 'mode', 'security', 'wpa_driver', 'ip', 'netmask', 'gateway', 'domain', 'dns1', 'dns2' ]
                        bool_types = [ 'known', 'available', 'encrypted', 'use_wpa', 'use_dhcp' ]
                        int_types = [ 'signal' ]
                        profile = {}
                        for option in bool_types:
                                profile[option] = self.get_opt_as_bool( section_name + "." + option )
                        for option in int_types:
                                profile[option] = self.get_opt_as_int( section_name + "." + option )
                        for option in str_types:
                                profile[option] = self.get_opt( section_name + "." + option )
                        return profile
                return None
        
        def get_opt( self, option_path ):
                """ get a config option and handle exceptions """
                #print "ConfigFile.get_opt: ", option_path
                (section, option) = option_path.split('.')
                try:
                        return self.get(section, option)
                except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
                        return None
        
        def get_opt_as_bool( self, option_path ):
                """ get a config option and return as a boolean type """
                option = self.get_opt(option_path)
                if isinstance(option, BooleanType) or isinstance(option, NoneType):
                        return option
                if option == 'True':
                        return True
                if option == 'False':
                        return False
                raise ValueError, 'boolean option was not True or False'
        
        def get_opt_as_int( self, option_path ):
                """ get a config option and return as an integer type """
                return int(float(self.get_opt(option_path)))
        
        def set_bool_opt( self, option_path, value ):
                """ convert boolean type to string and set config option """
                if ( value == True ) or ( value > 0 ) or ( value == 'True' ):
                        value == 'True'
                elif ( value == False ) or ( value == 0 ) or ( value == 'False' ):
                        value == 'False'
                else:
                        raise ValueError, 'cannot convert value to string'
                self.set_opt(option_path, repr(value))
        
        def set_int_opt( self, option_path, value ):
                """ convert integer type to string and set config option """
                if not isinstance(value, IntType):
                        raise ValueError, 'value is not an integer'
                self.set_opt(option_path, repr(value))
        
        def set_float_opt( self, option_path, value ):
                """ convert float type to string and set config option """
                if not isinstance(value, FloatType):
                        raise ValueError, 'value is not a float'
                self.set_opt(option_path, repr(int(value)))
        
        def set_opt( self, option_path, value ):
                """ set a config option and handle exceptions """
                (section, option) = option_path.split('.')
                try:
                        self.set(section, option, value)
                except ConfigParser.NoSectionError:
                        self.add_section(section)
                        self.set_opt(option_path, value)
        
        def profiles( self ):
                """ return a list of the section names which denote AP profiles """
                profile_list = []
                for section in self.sections():
                        if ':' in section:
                                profile_list.append(section)
                return profile_list
        
        def read ( self ):
                fp = open( self.filename, "r" )
                self.readfp(fp)
                # convert the auto_profile_order to a list for ordering
                self.auto_profile_order = eval(self.get_opt('DEFAULT.auto_profile_order'))
                for ap in self.profiles():
                        self.set_bool_opt( ap + '.known', True)
                        if ap in self.auto_profile_order: continue
                        self.auto_profile_order.append( ap )
        
        def write( self ):
                """ Copied from ConfigParser and modified to write options in alphabetical order """
                self.set_opt('DEFAULT.auto_profile_order', str(self.auto_profile_order))
                fp = open( self.filename, "w" )
                # write DEFAULT section first
                if self._defaults:
                        fp.write("[DEFAULT]\n")
                        for key in sorted(self._defaults.keys()):
                                fp.write("%s = %s\n" % (key, str(self._defaults[key]).replace('\n','\n\t')))
                        fp.write("\n")
                # write non-profile sections first
                for section in self._sections:
                        if not section in self.profiles():
                                fp.write("[%s]\n" % section)
                                for key in sorted(self._sections[section].keys()):
                                        if key != "__name__":
                                                fp.write("%s = %s\n" %
                                                                (key, str(self._sections[section][key]).replace('\n', '\n\t')))
                                fp.write("\n")
                # write profile sections
                for section in self._sections:
                        if section in self.profiles():
                                fp.write("[%s]\n" % section)
                                for key in sorted(self._sections[section].keys()):
                                        if key != "__name__":
                                                fp.write("%s = %s\n" %
                                                                (key, str(self._sections[section][key]).replace('\n', '\n\t')))
                                fp.write("\n")


####################################################################################################
# Speaking up
def     say( words ):
        if not confFile.get_opt_as_bool('DEFAULT.speak_up'): return
        words = words.replace( "\"", "\\\"" )
        shellcmd([confFile.get_opt('DEFAULT.speak_command'), words])


# load our conf file and known profiles
####################################################################################################
# Defaults, these may get overridden by values found in the conf file.
                                        # The network interface you use.
                                        # Specify "auto_detect" as the interface to make wifi-radar automatically detect your wireless card.
config_defaults = { 'interface': "auto_detect",
                                        # How long should the scan for access points last?
                                        'scan_timeout': '5',
                                        # X1000 Linux has a say command (text to speech) to announce connecting to networks.
                                        # Set the speak_up option to false if you do not have or want this.
                                        'speak_command': '/usr/bin/say',
                                        # Should I speak up when connecting to a network? (If you have a speech command)
                                        'speak_up': 'False',
                                        # You may set this to true for cards that require a "commit" command with iwconfig
                                        'commit_required': 'False',
                                        # You may set this to true for cards that require the interface to be brought up first
                                        'ifup_required': 'False',
                                        # Set the location of several important programs
                                        'iwlist_command': '/sbin/iwlist',
                                        'iwconfig_command': '/sbin/iwconfig',
                                        'ifconfig_command': '/sbin/ifconfig',
                                        'route_command': '/sbin/route',
                                        'auto_profile_order': '[]',
                                        'version': WIFI_RADAR_VERSION }

config_dhcp = { 'command': 'dhcpcd',
                                'timeout': '30',
                                'args': '-D -H -o -i dhcp_client -t %(timeout)s',
                                'kill_args': '-k',
                                'pidfile': '/var/run/dhcpcd-%(interface)s.pid' }

config_wpa = {  'command': '/usr/sbin/wpa_supplicant',
                                'args': '-B -i %(interface)s -c %(configuration)s -D %(driver)s -P %(pidfile)s',
                                'kill_command': '',
                                'configuration': '/etc/wpa_supplicant.conf',
                                'driver': 'wext',
                                'pidfile': '/var/run/wpa_supplicant.pid' }

# initialize config, with defaults
confFile = ConfigFile(CONF_FILE, config_defaults)
confFile.set_section("DHCP", config_dhcp)
confFile.set_section("WPA", config_wpa)

if not os.path.isfile( CONF_FILE ):
        confFile.set_bool_opt('DEFAULT.new_file', True)
else:
        if not os.access(CONF_FILE, os.R_OK):
                print "Can't open " + CONF_FILE + "."
                print "Are you root?"
                sys.exit()
        confFile.read()


# First, we add our known profiles
for apname in confFile.profiles():
        ap = get_new_profile()
        (ap['essid'], ap['bssid']) = split_section_name( apname )
        # read the important values
        for key in ap.keys():
                ap[key] = confFile.get_opt(apname + "." + key)
        # if it is not in the auto_profile_order add it
        if not apname in confFile.auto_profile_order:
                confFile.auto_profile_order.append( apname )

#set_network_device(confFile.get_opt('DEFAULT.interface'))

####################################################################################################
# Embedded Images
wifi_radar_icon = [ ""
  "GdkP"
  "\0\0\22""7"
  "\2\1\0\2"
  "\0\0\1\214"
  "\0\0\0c"
  "\0\0\0O"
  "\377\377\377\377\0\377\377\377\377\0\377\377\377\377\0\377\377\377\377"
  "\0\377\377\377\377\0\377\377\377\377\0\377\377\377\377\0\261\377\377"
  "\377\0\7\0\0\0\10\0\0\0\25\0\0\0\35\0\0\0%\0\0\0-\0\0\0\"\0\0\0\11\327"
  "\377\377\377\0\6\0\0\0\"\0\0\0_\0\0\0\213\0\0\0\266\0\0\0\341\0\0\0\376"
  "\206\0\0\0\377\6\0\0\0\356\0\0\0\324\0\0\0\265\0\0\0~\0\0\0@\0\0\0\10"
  "\315\377\377\377\0\4\0\0\0\2\0\0\0;\0\0\0\210\0\0\0\325\221\0\0\0\377"
  "\4\0\0\0\371\0\0\0\303\0\0\0w\0\0\0\31\310\377\377\377\0\3\0\0\0\6\0"
  "\0\0m\0\0\0\342\227\0\0\0\377\4\0\0\0\374\0\0\0\264\0\0\0Q\0\0\0\5\303"
  "\377\377\377\0\3\0\0\0\4\0\0\0d\0\0\0\341\234\0\0\0\377\3\0\0\0\341\0"
  "\0\0`\0\0\0\2\277\377\377\377\0\3\0\0\0\2\0\0\0[\0\0\0\333\240\0\0\0"
  "\377\2\0\0\0\323\0\0\0K\274\377\377\377\0\3\0\0\0\1\0\0\0R\0\0\0\324"
  "\244\0\0\0\377\2\0\0\0\276\0\0\0#\271\377\377\377\0\2\0\0\0\31\0\0\0"
  "\277\247\0\0\0\377\2\0\0\0\363\0\0\0c\267\377\377\377\0\2\0\0\0/\0\0"
  "\0\343\252\0\0\0\377\2\0\0\0\257\0\0\0\24\264\377\377\377\0\2\0\0\0M"
  "\0\0\0\363\220\0\0\0\377\14\0\0\0\357\0\0\0\304\0\0\0\230\0\0\0v\0\0"
  "\0l\0\0\0c\0\0\0[\0\0\0j\0\0\0\205\0\0\0\240\0\0\0\311\0\0\0\373\220"
  "\0\0\0\377\2\0\0\0\346\0\0\0""4\262\377\377\377\0\2\0\0\0q\0\0\0\375"
  "\215\0\0\0\377\4\0\0\0\373\0\0\0\300\0\0\0t\0\0\0)\213\377\377\377\0"
  "\4\0\0\0\14\0\0\0E\0\0\0\205\0\0\0\334\216\0\0\0\377\2\0\0\0\363\0\0"
  "\0D\257\377\377\377\0\2\0\0\0\4\0\0\0\230\215\0\0\0\377\3\0\0\0\372\0"
  "\0\0\231\0\0\0\34\221\377\377\377\0\4\0\0\0\1\0\0\0C\0\0\0\251\0\0\0"
  "\372\214\0\0\0\377\2\0\0\0\371\0\0\0W\255\377\377\377\0\2\0\0\0\17\0"
  "\0\0\272\214\0\0\0\377\3\0\0\0\375\0\0\0\241\0\0\0\"\226\377\377\377"
  "\0\2\0\0\0\"\0\0\0\252\214\0\0\0\377\2\0\0\0\375\0\0\0k\253\377\377\377"
  "\0\2\0\0\0\25\0\0\0\324\213\0\0\0\377\3\0\0\0\376\0\0\0\252\0\0\0(\232"
  "\377\377\377\0\2\0\0\0""9\0\0\0\312\214\0\0\0\377\1\0\0\0\200\251\377"
  "\377\377\0\2\0\0\0\5\0\0\0\303\213\0\0\0\377\2\0\0\0\332\0\0\0""1\235"
  "\377\377\377\0\3\0\0\0\4\0\0\0\201\0\0\0\374\213\0\0\0\377\1\0\0\0p\250"
  "\377\377\377\0\1\0\0\0\222\213\0\0\0\377\2\0\0\0\301\0\0\0\22\240\377"
  "\377\377\0\2\0\0\0:\0\0\0\336\212\0\0\0\377\2\0\0\0\374\0\0\0I\246\377"
  "\377\377\0\1\0\0\0[\213\0\0\0\377\2\0\0\0\241\0\0\0\6\212\377\377\377"
  "\0\15\0\0\0\2\0\0\0&\0\0\0U\0\0\0\203\0\0\0\242\0\0\0\243\0\0\0\234\0"
  "\0\0\225\0\0\0\215\0\0\0\206\0\0\0}\0\0\0\\\0\0\0!\213\377\377\377\0"
  "\2\0\0\0\22\0\0\0\307\212\0\0\0\377\2\0\0\0\361\0\0\0+\244\377\377\377"
  "\0\2\0\0\0.\0\0\0\365\211\0\0\0\377\2\0\0\0\376\0\0\0|\211\377\377\377"
  "\0\4\0\0\0#\0\0\0d\0\0\0\223\0\0\0\277\214\0\0\0\310\4\0\0\0\253\0\0"
  "\0l\0\0\0-\0\0\0\2\210\377\377\377\0\2\0\0\0\12\0\0\0\267\212\0\0\0\377"
  "\2\0\0\0\336\0\0\0\24\242\377\377\377\0\2\0\0\0\20\0\0\0\334\211\0\0"
  "\0\377\2\0\0\0\367\0\0\0W\210\377\377\377\0\2\0\0\0#\0\0\0\211\223\0"
  "\0\0\310\3\0\0\0\266\0\0\0t\0\0\0\27\207\377\377\377\0\2\0\0\0\5\0\0"
  "\0\244\212\0\0\0\377\2\0\0\0\302\0\0\0\6\240\377\377\377\0\2\0\0\0\1"
  "\0\0\0\264\211\0\0\0\377\2\0\0\0\363\0\0\0""9\207\377\377\377\0\3\0\0"
  "\0\34\0\0\0\201\0\0\0\306\226\0\0\0\310\3\0\0\0\277\0\0\0Y\0\0\0\2\206"
  "\377\377\377\0\2\0\0\0\1\0\0\0\217\212\0\0\0\377\1\0\0\0\203\240\377"
  "\377\377\0\1\0\0\0\177\212\0\0\0\377\1\0\0\0T\206\377\377\377\0\3\0\0"
  "\0\25\0\0\0z\0\0\0\305\232\0\0\0\310\2\0\0\0\242\0\0\0*\207\377\377\377"
  "\0\1\0\0\0\243\211\0\0\0\377\2\0\0\0\372\0\0\0,\236\377\377\377\0\2\0"
  "\0\0D\0\0\0\375\211\0\0\0\377\1\0\0\0\213\206\377\377\377\0\2\0\0\0""8"
  "\0\0\0\274\235\0\0\0\310\3\0\0\0\306\0\0\0u\0\0\0\14\205\377\377\377"
  "\0\2\0\0\0\7\0\0\0\306\211\0\0\0\377\2\0\0\0\306\0\0\0\2\234\377\377"
  "\377\0\2\0\0\0\4\0\0\0\331\211\0\0\0\377\2\0\0\0\276\0\0\0\3\205\377"
  "\377\377\0\2\0\0\0T\0\0\0\306\214\0\0\0\310\10\0\0\0\260\0\0\0\202\0"
  "\0\0v\0\0\0~\0\0\0\207\0\0\0\217\0\0\0\227\0\0\0\264\214\0\0\0\310\2"
  "\0\0\0\264\0\0\0""2\205\377\377\377\0\2\0\0\0\27\0\0\0\341\211\0\0\0"
  "\377\1\0\0\0k\234\377\377\377\0\1\0\0\0c\211\0\0\0\377\2\0\0\0\343\0"
  "\0\0\26\204\377\377\377\0\2\0\0\0\2\0\0\0s\212\0\0\0\310\4\0\0\0\265"
  "\0\0\0s\0\0\0D\0\0\0\26\207\377\377\377\0\4\0\0\0\1\0\0\0+\0\0\0j\0\0"
  "\0\250\212\0\0\0\310\2\0\0\0\303\0\0\0A\205\377\377\377\0\2\0\0\0/\0"
  "\0\0\364\210\0\0\0\377\2\0\0\0\362\0\0\0\33\232\377\377\377\0\2\0\0\0"
  "\7\0\0\0\341\210\0\0\0\377\2\0\0\0\371\0\0\0""7\204\377\377\377\0\2\0"
  "\0\0\12\0\0\0\217\211\0\0\0\310\3\0\0\0\271\0\0\0]\0\0\0\10\216\377\377"
  "\377\0\3\0\0\0\36\0\0\0t\0\0\0\306\210\0\0\0\310\2\0\0\0\306\0\0\0P\205"
  "\377\377\377\0\1\0\0\0a\211\0\0\0\377\1\0\0\0\257\232\377\377\377\0\1"
  "\0\0\0n\211\0\0\0\377\1\0\0\0h\204\377\377\377\0\2\0\0\0\20\0\0\0\245"
  "\210\0\0\0\310\3\0\0\0\274\0\0\0c\0\0\0\12\222\377\377\377\0\2\0\0\0"
  "*\0\0\0\242\211\0\0\0\310\1\0\0\0`\205\377\377\377\0\1\0\0\0\276\211"
  "\0\0\0\377\1\0\0\0:\230\377\377\377\0\2\0\0\0\13\0\0\0\350\210\0\0\0"
  "\377\1\0\0\0\250\204\377\377\377\0\2\0\0\0\3\0\0\0\230\210\0\0\0\310"
  "\2\0\0\0\213\0\0\0\15\225\377\377\377\0\3\0\0\0\2\0\0\0Z\0\0\0\277\210"
  "\0\0\0\310\1\0\0\0U\204\377\377\377\0\2\0\0\0%\0\0\0\370\210\0\0\0\377"
  "\1\0\0\0\265\230\377\377\377\0\1\0\0\0y\210\0\0\0\377\2\0\0\0\372\0\0"
  "\0\40\204\377\377\377\0\1\0\0\0o\210\0\0\0\310\2\0\0\0o\0\0\0\2\230\377"
  "\377\377\0\2\0\0\0\30\0\0\0\226\207\0\0\0\310\2\0\0\0\306\0\0\0""7\204"
  "\377\377\377\0\1\0\0\0|\211\0\0\0\377\1\0\0\0""0\226\377\377\377\0\2"
  "\0\0\0\20\0\0\0\356\210\0\0\0\377\1\0\0\0\226\204\377\377\377\0\1\0\0"
  "\0C\207\0\0\0\310\2\0\0\0\305\0\0\0R\233\377\377\377\0\2\0\0\0\5\0\0"
  "\0\210\207\0\0\0\310\2\0\0\0\273\0\0\0\37\203\377\377\377\0\2\0\0\0\6"
  "\0\0\0\325\210\0\0\0\377\1\0\0\0\251\226\377\377\377\0\1\0\0\0\204\210"
  "\0\0\0\377\2\0\0\0\366\0\0\0\32\203\377\377\377\0\2\0\0\0!\0\0\0\277"
  "\206\0\0\0\310\2\0\0\0\275\0\0\0""8\235\377\377\377\0\2\0\0\0\2\0\0\0"
  "|\207\0\0\0\310\2\0\0\0\254\0\0\0\15\203\377\377\377\0\1\0\0\0J\210\0"
  "\0\0\377\2\0\0\0\375\0\0\0&\224\377\377\377\0\2\0\0\0\26\0\0\0\364\210"
  "\0\0\0\377\1\0\0\0\214\203\377\377\377\0\2\0\0\0\12\0\0\0\251\206\0\0"
  "\0\310\2\0\0\0\305\0\0\0""0\240\377\377\377\0\1\0\0\0r\207\0\0\0\310"
  "\1\0\0\0[\204\377\377\377\0\1\0\0\0\317\210\0\0\0\377\1\0\0\0\236\224"
  "\377\377\377\0\1\0\0\0\204\210\0\0\0\377\2\0\0\0\362\0\0\0\24\203\377"
  "\377\377\0\1\0\0\0\206\207\0\0\0\310\1\0\0\0X\214\377\377\377\0\11\0"
  "\0\0\5\0\0\0$\0\0\0G\0\0\0X\0\0\0T\0\0\0O\0\0\0K\0\0\0B\0\0\0\35\214"
  "\377\377\377\0\2\0\0\0\2\0\0\0\214\206\0\0\0\310\2\0\0\0\307\0\0\0""1"
  "\203\377\377\377\0\1\0\0\0V\210\0\0\0\377\2\0\0\0\372\0\0\0\27\223\377"
  "\377\377\0\1\0\0\0\271\210\0\0\0\377\1\0\0\0\202\203\377\377\377\0\1"
  "\0\0\0@\207\0\0\0\310\1\0\0\0\204\212\377\377\377\0\4\0\0\0\7\0\0\0E"
  "\0\0\0u\0\0\0\222\210\0\0\0\226\4\0\0\0\204\0\0\0T\0\0\0$\0\0\0\1\211"
  "\377\377\377\0\2\0\0\0\12\0\0\0\245\206\0\0\0\310\2\0\0\0\251\0\0\0\5"
  "\202\377\377\377\0\2\0\0\0\2\0\0\0\331\210\0\0\0\377\1\0\0\0C\223\377"
  "\377\377\0\1\0\0\0\342\207\0\0\0\377\2\0\0\0\356\0\0\0\17\202\377\377"
  "\377\0\2\0\0\0\2\0\0\0\246\206\0\0\0\310\2\0\0\0\246\0\0\0\11\210\377"
  "\377\377\0\3\0\0\0\5\0\0\0D\0\0\0\212\216\0\0\0\226\2\0\0\0z\0\0\0\40"
  "\211\377\377\377\0\2\0\0\0\32\0\0\0\274\206\0\0\0\310\1\0\0\0d\203\377"
  "\377\377\0\1\0\0\0a\210\0\0\0\377\1\0\0\0b\222\377\377\377\0\2\0\0\0"
  "\10\0\0\0\375\207\0\0\0\377\1\0\0\0x\203\377\377\377\0\1\0\0\0G\206\0"
  "\0\0\310\2\0\0\0\275\0\0\0\36\210\377\377\377\0\2\0\0\0""3\0\0\0\207"
  "\221\0\0\0\226\3\0\0\0\225\0\0\0X\0\0\0\11\210\377\377\377\0\1\0\0\0"
  "R\206\0\0\0\310\2\0\0\0\302\0\0\0\23\202\377\377\377\0\2\0\0\0\5\0\0"
  "\0\342\207\0\0\0\377\1\0\0\0\201\223\377\377\377\0\1\0\0\0m\206\0\0\0"
  "\377\2\0\0\0\321\0\0\0\12\202\377\377\377\0\2\0\0\0\3\0\0\0\254\206\0"
  "\0\0\310\1\0\0\0J\207\377\377\377\0\2\0\0\0\1\0\0\0O\210\0\0\0\226\1"
  "\0\0\0\206\202\0\0\0h\3\0\0\0m\0\0\0s\0\0\0\214\207\0\0\0\226\2\0\0\0"
  "\210\0\0\0)\207\377\377\377\0\2\0\0\0\1\0\0\0\233\206\0\0\0\310\1\0\0"
  "\0l\203\377\377\377\0\2\0\0\0P\0\0\0\374\205\0\0\0\377\2\0\0\0\337\0"
  "\0\0\"\224\377\377\377\0\1\0\0\0s\204\0\0\0\377\2\0\0\0\315\0\0\0\23"
  "\203\377\377\377\0\1\0\0\0N\206\0\0\0\310\2\0\0\0\245\0\0\0\2\206\377"
  "\377\377\0\2\0\0\0\6\0\0\0f\206\0\0\0\226\3\0\0\0w\0\0\0""7\0\0\0\23"
  "\205\377\377\377\0\4\0\0\0\3\0\0\0*\0\0\0[\0\0\0\212\205\0\0\0\226\2"
  "\0\0\0\222\0\0\0*\207\377\377\377\0\2\0\0\0#\0\0\0\304\205\0\0\0\310"
  "\2\0\0\0\277\0\0\0\16\203\377\377\377\0\2\0\0\0]\0\0\0\376\203\0\0\0"
  "\377\2\0\0\0\332\0\0\0\35\226\377\377\377\0\5\0\0\0;\0\0\0j\0\0\0\223"
  "\0\0\0\244\0\0\0\20\203\377\377\377\0\2\0\0\0\5\0\0\0\260\206\0\0\0\310"
  "\1\0\0\0>\206\377\377\377\0\2\0\0\0\14\0\0\0z\205\0\0\0\226\2\0\0\0|"
  "\0\0\0/\213\377\377\377\0\3\0\0\0\10\0\0\0U\0\0\0\224\204\0\0\0\226\2"
  "\0\0\0\221\0\0\0%\207\377\377\377\0\1\0\0\0s\206\0\0\0\310\1\0\0\0d\204"
  "\377\377\377\0\5\0\0\0a\0\0\0\240\0\0\0\177\0\0\0]\0\0\0\26\237\377\377"
  "\377\0\1\0\0\0U\206\0\0\0\310\1\0\0\0\235\206\377\377\377\0\2\0\0\0\2"
  "\0\0\0r\204\0\0\0\226\3\0\0\0\225\0\0\0J\0\0\0\1\216\377\377\377\0\2"
  "\0\0\0\35\0\0\0w\204\0\0\0\226\2\0\0\0\217\0\0\0\40\206\377\377\377\0"
  "\2\0\0\0\27\0\0\0\304\205\0\0\0\310\2\0\0\0\273\0\0\0\12\247\377\377"
  "\377\0\1\0\0\0\236\206\0\0\0\310\1\0\0\0""5\206\377\377\377\0\1\0\0\0"
  "T\204\0\0\0\226\2\0\0\0\221\0\0\0""3\221\377\377\377\0\2\0\0\0\4\0\0"
  "\0l\204\0\0\0\226\2\0\0\0\215\0\0\0\34\206\377\377\377\0\1\0\0\0}\206"
  "\0\0\0\310\1\0\0\0E\247\377\377\377\0\1\0\0\0\276\205\0\0\0\310\1\0\0"
  "\0\224\206\377\377\377\0\1\0\0\0""4\204\0\0\0\226\2\0\0\0\214\0\0\0\40"
  "\223\377\377\377\0\2\0\0\0\5\0\0\0q\204\0\0\0\226\2\0\0\0\211\0\0\0\14"
  "\205\377\377\377\0\2\0\0\0\37\0\0\0\306\205\0\0\0\310\1\0\0\0`\246\377"
  "\377\377\0\2\0\0\0\12\0\0\0\277\205\0\0\0\310\1\0\0\0+\205\377\377\377"
  "\0\2\0\0\0\30\0\0\0\220\203\0\0\0\226\2\0\0\0\225\0\0\0*\225\377\377"
  "\377\0\2\0\0\0\10\0\0\0v\204\0\0\0\226\1\0\0\0X\206\377\377\377\0\1\0"
  "\0\0\207\205\0\0\0\310\1\0\0\0m\247\377\377\377\0\2\0\0\0""3\0\0\0\301"
  "\203\0\0\0\310\1\0\0\0[\206\377\377\377\0\1\0\0\0n\204\0\0\0\226\1\0"
  "\0\0G\227\377\377\377\0\2\0\0\0\12\0\0\0z\203\0\0\0\226\2\0\0\0\224\0"
  "\0\0\27\205\377\377\377\0\2\0\0\0\20\0\0\0\246\203\0\0\0\310\2\0\0\0"
  "\224\0\0\0\11\250\377\377\377\0\4\0\0\0,\0\0\0h\0\0\0\210\0\0\0R\206"
  "\377\377\377\0\1\0\0\0&\204\0\0\0\226\2\0\0\0f\0\0\0\1\230\377\377\377"
  "\0\2\0\0\0\26\0\0\0\224\203\0\0\0\226\1\0\0\0g\206\377\377\377\0\5\0"
  "\0\0\22\0\0\0\206\0\0\0y\0\0\0]\0\0\0\6\263\377\377\377\0\1\0\0\0t\203"
  "\0\0\0\226\2\0\0\0\216\0\0\0\13\232\377\377\377\0\1\0\0\0X\204\0\0\0"
  "\226\1\0\0\0#\274\377\377\377\0\1\0\0\0-\204\0\0\0\226\1\0\0\0K\233\377"
  "\377\377\0\2\0\0\0\15\0\0\0\217\203\0\0\0\226\1\0\0\0v\274\377\377\377"
  "\0\1\0\0\0t\203\0\0\0\226\2\0\0\0\213\0\0\0\10\213\377\377\377\0\5\0"
  "\0\0\5\0\0\0\30\0\0\0\40\0\0\0\36\0\0\0\22\214\377\377\377\0\1\0\0\0"
  "J\204\0\0\0\226\1\0\0\0*\273\377\377\377\0\1\0\0\0`\203\0\0\0\226\1\0"
  "\0\0E\212\377\377\377\0\3\0\0\0\13\0\0\0@\0\0\0Y\204\0\0\0Z\3\0\0\0Q"
  "\0\0\0""1\0\0\0\5\211\377\377\377\0\2\0\0\0\6\0\0\0\207\203\0\0\0\226"
  "\1\0\0\0\26\273\377\377\377\0\5\0\0\0""1\0\0\0\226\0\0\0\224\0\0\0n\0"
  "\0\0\5\211\377\377\377\0\2\0\0\0$\0\0\0U\202\0\0\0Z\4\0\0\0P\0\0\0E\0"
  "\0\0I\0\0\0X\202\0\0\0Z\2\0\0\0P\0\0\0\33\211\377\377\377\0\4\0\0\0""3"
  "\0\0\0\206\0\0\0\226\0\0\0\201\274\377\377\377\0\3\0\0\0\6\0\0\0""8\0"
  "\0\0\13\211\377\377\377\0\2\0\0\0\7\0\0\0A\202\0\0\0Z\2\0\0\0I\0\0\0"
  "\20\203\377\377\377\0\6\0\0\0\4\0\0\0\37\0\0\0O\0\0\0Z\0\0\0Y\0\0\0\36"
  "\212\377\377\377\0\2\0\0\0\34\0\0\0)\310\377\377\377\0\5\0\0\0<\0\0\0"
  "Z\0\0\0Y\0\0\0.\0\0\0\2\206\377\377\377\0\5\0\0\0\3\0\0\0;\0\0\0Z\0\0"
  "\0X\0\0\0\32\322\377\377\377\0\1\0\0\0\34\202\0\0\0Z\1\0\0\0\30\211\377"
  "\377\377\0\5\0\0\0\1\0\0\0>\0\0\0Z\0\0\0W\0\0\0\13\320\377\377\377\0"
  "\4\0\0\0\5\0\0\0P\0\0\0Z\0\0\0""5\213\377\377\377\0\4\0\0\0\2\0\0\0H"
  "\0\0\0Z\0\0\0:\320\377\377\377\0\4\0\0\0""4\0\0\0Z\0\0\0P\0\0\0\5\214"
  "\377\377\377\0\1\0\0\0\26\202\0\0\0Z\1\0\0\0\22\317\377\377\377\0\3\0"
  "\0\0+\0\0\0X\0\0\0\33\216\377\377\377\0\3\0\0\0>\0\0\0I\0\0\0\23\320"
  "\377\377\377\0\1\0\0\0\12\217\377\377\377\0\2\0\0\0\6\0\0\0\1\377\377"
  "\377\377\0\377\377\377\377\0\377\377\377\377\0\377\377\377\377\0\377"
  "\377\377\377\0\377\377\377\377\0\377\377\377\377\0\377\377\377\377\0"
  "\377\377\377\377\0\377\377\377\377\0\377\377\377\377\0\234\377\377\377"
  "\0"]

known_profile_icon = [ ""
  "GdkP"
  "\0\0\5""0"
  "\2\1\0\2"
  "\0\0\0P"
  "\0\0\0\24"
  "\0\0\0\24"
  "\210\0\0\0\0\4\0\0\0\3\0\0\0\16\0\0\0\23\0\0\0\11\216\0\0\0\0\11\0\0"
  "\0\16\0\0\0h\0\0\0\301\0\0\0\345\0\0\0\352\0\0\0\331\0\0\0\237\0\0\0"
  "9\0\0\0\3\212\0\0\0\0\13\0\0\0@\0\0\0\323\0\0\0\376\0\0\0\350\0\0\0\304"
  "\0\0\0\271\0\0\0\323\0\0\0\367\0\0\0\370\0\0\0\227\0\0\0\17\210\0\0\0"
  "\0\15\0\0\0K\0\0\0\354\0\0\0\365\0\0\0\206\0\0\0#\0\0\0\6\0\0\0\3\0\0"
  "\0\15\0\0\0C\0\0\0\304\0\0\0\376\0\0\0\260\0\0\0\22\206\0\0\0\0\17\0"
  "\0\0""2\0\0\0\346\0\0\0\351\0\0\0L\0\0\0#\0\0\0u\0\0\0\246\0\0\0\257"
  "\0\0\0\223\0\0\0M\0\0\0\27\0\0\0\235\0\0\0\375\0\0\0\242\0\0\0\7\204"
  "\0\0\0\0\20\0\0\0\13\0\0\0\300\0\0\0\372\0\0\0W\0\0\0O\0\0\0\271\0\0"
  "\0\233\0\0\0b\0\0\0V\0\0\0z\0\0\0\267\0\0\0\223\0\0\0$\0\0\0\267\0\0"
  "\0\374\0\0\0X\204\0\0\0\0\7\0\0\0S\0\0\0\374\0\0\0\240\0\0\0H\0\0\0\275"
  "\0\0\0a\0\0\0\12\202\0\0\0\0\10\0\0\0\1\0\0\0%\0\0\0\240\0\0\0\241\0"
  "\0\0""9\0\0\0\352\0\0\0\320\0\0\0\12\203\0\0\0\0\21\0\0\0\262\0\0\0\351"
  "\0\0\0A\0\0\0\272\0\0\0g\0\0\0\6\0\0\0""4\0\0\0e\0\0\0l\0\0\0T\0\0\0"
  "\25\0\0\0\27\0\0\0\251\0\0\0v\0\0\0\214\0\0\0\367\0\0\0<\203\0\0\0\0"
  "\21\0\0\0""6\0\0\0G\0\0\0r\0\0\0\244\0\0\0\17\0\0\0P\0\0\0b\0\0\0#\0"
  "\0\0\27\0\0\0;\0\0\0s\0\0\0\33\0\0\0E\0\0\0\270\0\0\0""6\0\0\0\\\0\0"
  "\0\15\205\0\0\0\0\15\0\0\0T\0\0\0""8\0\0\0""0\0\0\0f\0\0\0\6\0\0\0\0"
  "\0\0\0\1\0\0\0\0\0\0\0(\0\0\0l\0\0\0\13\0\0\0k\0\0\0\33\206\0\0\0\0\16"
  "***;\210\210\210\356\223\223\223\377iii\377\204\204\204\377\216\216\216"
  "\377~~~\377zzz\377\203\203\203\377\215\215\215\377ddd\377\202\202\202"
  "\377xxx\356\40\40\40;\205\0\0\0\0\2&&&#\251\251\251\353\202\374\374\374"
  "\377\202\372\372\372\377\5\335\335\335\377\353\353\353\377\366\366\366"
  "\377\327\327\327\377\357\357\357\377\202\365\365\365\377\3\362\362\362"
  "\377\226\226\226\353\27\27\27)\204\0\0\0\0\21,,,p\354\354\354\377\355"
  "\355\355\377\351\351\351\377\346\346\346\377\342\342\342\377\335\335"
  "\335\377\334\334\334\377\330\330\330\377\324\324\324\377\320\320\320"
  "\377\316\316\316\377\313\313\313\377\307\307\307\377\314\314\314\377"
  "\35\35\35y\0\0\0\1\202\0\0\0\0\14\0\0\0\2(((\203\357\357\357\377\345"
  "\345\345\377\341\341\341\377\337\337\337\377\333\333\333\377\326\326"
  "\326\377\322\322\322\377\316\316\316\377\312\312\312\377\306\306\306"
  "\377\202\302\302\302\377\30\314\314\314\377\311\311\311\377\33\33\33"
  "\204\0\0\0\5\0\0\0\1\0\0\0\2\0\0\0\10&&&\210\356\356\356\377\342\342"
  "\342\377\347\347\347\377\346\346\346\377\324GG\377\337\337\337\377\324"
  "GG\377\333\322\322\377\324GG\377<\341@\377\324GG\377<\341@\377\321\321"
  "\321\377\276\276\276\377\27\27\27\214\0\0\0\15\202\0\0\0\4+\0\0\0\21"
  "$$$\221\355\355\355\377\345\345\345\377\344\344\344\377\340\340\340\377"
  "\334\334\334\377\331\331\331\377\325\325\325\377\321\321\321\377\316"
  "\316\316\377\312\312\312\377\306\306\306\377\307\307\307\377\313\313"
  "\313\377\272\272\272\377\24\24\24\226\0\0\0\30\0\0\0\10\0\0\0\5\0\0\0"
  "\27\"\"\"\231\354\354\354\377\346\346\346\377\342\342\342\377\337\337"
  "\337\377\333\333\333\377\327\327\327\377\324\324\324\377\320\320\320"
  "\377\314\314\314\377\310\310\310\377\305\305\305\377\301\301\301\377"
  "\276\276\276\377\271\271\271\377\23\23\23\235\0\0\0\35\0\0\0\10\0\0\0"
  "\4\0\0\0\32\40\40\40\223\310\310\310\376\202\274\274\274\377\4\272\272"
  "\272\377\271\271\271\377\270\270\270\377\267\267\267\377\202\271\271"
  "\271\377\16\270\270\270\377\266\266\266\377\265\265\265\377\264\264\264"
  "\377\231\231\231\376\16\16\16\240\0\0\0\35\0\0\0\6\0\0\0\2\0\0\0\12\0"
  "\0\0/\0\0\0n\0\0\0|\0\0\0\177\202\0\0\0\200\202\0\0\0\201\1\0\0\0\203"
  "\204\0\0\0\205\12\0\0\0\201\0\0\0y\0\0\0<\0\0\0\15\0\0\0\2\0\0\0\0\0"
  "\0\0\2\0\0\0\6\0\0\0\14\0\0\0\20\204\0\0\0\24\202\0\0\0\25\203\0\0\0"
  "\26\6\0\0\0\25\0\0\0\22\0\0\0\15\0\0\0\7\0\0\0\2\0\0\0\0"]

unknown_profile_icon = [ ""
  "GdkP"
  "\0\0\5\22"
  "\2\1\0\2"
  "\0\0\0P"
  "\0\0\0\24"
  "\0\0\0\24"
  "\210\0\0\0\0\4\0\0\0\1\0\0\0\4\0\0\0\6\0\0\0\3\216\0\0\0\0\11\0\0\0\4"
  "\0\0\0\37\0\0\0""9\0\0\0D\0\0\0F\0\0\0@\0\0\0/\0\0\0\21\0\0\0\1\212\0"
  "\0\0\0\7\0\0\0\23\0\0\0\77\0\0\0K\0\0\0E\0\0\0:\0\0\0""7\0\0\0\77\202"
  "\0\0\0I\2\0\0\0-\0\0\0\4\210\0\0\0\0\15\0\0\0\26\0\0\0F\0\0\0I\0\0\0"
  "(\0\0\0\13\0\0\0\2\0\0\0\1\0\0\0\4\0\0\0\24\0\0\0:\0\0\0K\0\0\0""4\0"
  "\0\0\6\206\0\0\0\0\17\0\0\0\17\0\0\0D\0\0\0E\0\0\0\26\0\0\0\13\0\0\0"
  "#\0\0\0""1\0\0\0""4\0\0\0,\0\0\0\27\0\0\0\7\0\0\0/\0\0\0K\0\0\0""0\0"
  "\0\0\2\204\0\0\0\0\20\0\0\0\3\0\0\0""9\0\0\0J\0\0\0\32\0\0\0\30\0\0\0"
  "7\0\0\0.\0\0\0\35\0\0\0\32\0\0\0$\0\0\0""6\0\0\0,\0\0\0\13\0\0\0""6\0"
  "\0\0K\0\0\0\32\204\0\0\0\0\7\0\0\0\31\0\0\0K\0\0\0""0\0\0\0\25\0\0\0"
  "8\0\0\0\35\0\0\0\3\202\0\0\0\0\2\0\0\0\1\0\0\0\13\202\0\0\0""0\4\0\0"
  "\0\21\0\0\0F\0\0\0>\0\0\0\3\203\0\0\0\0\21\0\0\0""5\0\0\0E\0\0\0\23\0"
  "\0\0""7\0\0\0\37\0\0\0\2\0\0\0\20\0\0\0\36\0\0\0\40\0\0\0\31\0\0\0\6"
  "\0\0\0\7\0\0\0""2\0\0\0#\0\0\0)\0\0\0I\0\0\0\22\203\0\0\0\0\21\0\0\0"
  "\20\0\0\0\25\0\0\0\"\0\0\0""1\0\0\0\4\0\0\0\30\0\0\0\35\0\0\0\13\0\0"
  "\0\7\0\0\0\21\0\0\0\"\0\0\0\10\0\0\0\25\0\0\0""6\0\0\0\20\0\0\0\33\0"
  "\0\0\4\205\0\0\0\0\15\0\0\0\31\0\0\0\21\0\0\0\16\0\0\0\36\0\0\0\2\0\0"
  "\0\0\0\0\0\1\0\0\0\0\0\0\0\14\0\0\0\40\0\0\0\3\0\0\0\40\0\0\0\10\206"
  "\0\0\0\0\16***\21\210\210\210G\223\223\223LiiiL\204\204\204L\34=n\300"
  "\14""1i\361\12""0i\374\20""4j\342CXx}dddL\202\202\202LxxxG\40\40\40\21"
  "\205\0\0\0\0\2&&&\13\251\251\251F\202\374\374\374L\202\372\372\372L\5"
  "\"Cv\310Lf\217\226@]\211\245\12""0i\377\22""7n\353\202\365\365\365L\3"
  "\362\362\362L\226\226\226F\27\27\27\14\204\0\0\0\0\21,,,!\354\354\354"
  "L\355\355\355L\351\351\351L\346\346\346L\342\342\342L\335\335\335L\334"
  "\334\334L\210\227\255h\12""0i\377\21""6l\352\316\316\316L\313\313\313"
  "L\307\307\307L\314\314\314L\35\35\35$\0\0\0\1\202\0\0\0\0\14\0\0\0\1"
  "((('\357\357\357L\345\345\345L\341\341\341L\337\337\337L\333\333\333"
  "L\326\326\326L|\215\245l\20""5l\355\12""0i\374Sj\215\205\202\302\302"
  "\302L\4\314\314\314L\311\311\311L\33\33\33'\0\0\0\2\202\0\0\0\1\22\0"
  "\0\0\2&&&(\356\356\356L\342\342\342L\347\347\347L\346\346\346L\324GG"
  "L\337\337\337L\22""0g\351\12""0i\377^9Z\201<\341@L\324GGL<\341@L\321"
  "\321\321L\276\276\276L\27\27\27)\0\0\0\4\202\0\0\0\1\22\0\0\0\5$$$+\355"
  "\355\355L\345\345\345L\344\344\344L\340\340\340L\334\334\334L\331\331"
  "\331Law\227\177`u\226\177\316\316\316L\312\312\312L\306\306\306L\307"
  "\307\307L\313\313\313L\272\272\272L\24\24\24,\0\0\0\7\202\0\0\0\2\27"
  "\0\0\0\7\"\"\"-\354\354\354L\346\346\346L\342\342\342L\337\337\337L\333"
  "\333\333L\327\327\327LSk\217\212Qi\216\212\314\314\314L\310\310\310L"
  "\305\305\305L\301\301\301L\276\276\276L\271\271\271L\23\23\23/\0\0\0"
  "\10\0\0\0\2\0\0\0\1\0\0\0\10\40\40\40,\310\310\310K\202\274\274\274L"
  "\3\272\272\272L\271\271\271L\270\270\270L\202\12""0i\377\16\271\271\271"
  "L\270\270\270L\266\266\266L\265\265\265L\264\264\264L\231\231\231K\16"
  "\16\16""0\0\0\0\10\0\0\0\2\0\0\0\1\0\0\0\3\0\0\0\16\0\0\0!\0\0\0%\205"
  "\0\0\0&\205\0\0\0'\12\0\0\0&\0\0\0$\0\0\0\22\0\0\0\4\0\0\0\1\0\0\0\0"
  "\0\0\0\1\0\0\0\2\0\0\0\3\0\0\0\4\206\0\0\0\6\203\0\0\0\7\202\0\0\0\6"
  "\4\0\0\0\4\0\0\0\2\0\0\0\1\0\0\0\0"]

signal_xpm_barely = [
"20 20 10 1",
"       c None",
".      c #C6C6C6",
"+      c #CCCCCC",
"@      c #DBDBDB",
"#      c #D3D3D3",
"$      c #A9B099",
"%      c #95A173",
"&      c #6B8428",
"*      c #B4B7AC",
"=      c #80924D",
"               .+++.",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"          .++++#@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"     $%%%%#@@@@@@@@+",
"     %&&&&@@@@@@@@@+",
"     %&&&&@@@@@@@@@+",
"     %&&&&@@@@@@@@@+",
"     %&&&&@@@@@@@@@+",
"*%%%%=&&&&@@@@@@@@@+",
"%&&&&&&&&&@@@@@@@@@+",
"%&&&&&&&&&@@@@@@@@@+",
"%&&&&&&&&&@@@@@@@@@+",
"*%%%%%%%%%+++++++++."
]


signal_xpm_best = [
"20 20 6 1",
"       c None",
".      c #9DAABF",
"+      c #7B96BF",
"@      c #386EBF",
"#      c #5982BF",
"$      c #AEB4BF",
"               .+++.",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"          .++++#@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"     .++++#@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"$++++#@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"$++++++++++++++++++."
]

signal_xpm_none = [
"20 20 6 1",
"       c None",
".      c #C6C6C6",
"+      c #CCCCCC",
"@      c #DBDBDB",
"#      c #D3D3D3",
"$      c #C2C2C2",
"               .+++.",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"          .++++#@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"     .++++#@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"$++++#@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"+@@@@@@@@@@@@@@@@@@+",
"$++++++++++++++++++."
]

signal_xpm_ok = [
"20 20 10 1",
"       c None",
".      c #C6C6C6",
"+      c #CCCCCC",
"@      c #DBDBDB",
"#      c #A1A5B2",
"$      c #848DA5",
"%      c #D3D3D3",
"&      c #4A5B8C",
"*      c #677498",
"=      c #B0B2B8",
"               .+++.",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"          #$$$$%@@@+",
"          $&&&&@@@@+",
"          $&&&&@@@@+",
"          $&&&&@@@@+",
"          $&&&&@@@@+",
"     #$$$$*&&&&@@@@+",
"     $&&&&&&&&&@@@@+",
"     $&&&&&&&&&@@@@+",
"     $&&&&&&&&&@@@@+",
"     $&&&&&&&&&@@@@+",
"=$$$$*&&&&&&&&&@@@@+",
"$&&&&&&&&&&&&&&@@@@+",
"$&&&&&&&&&&&&&&@@@@+",
"$&&&&&&&&&&&&&&@@@@+",
"=$$$$$$$$$$$$$$++++."
]


signal_xpm_low = [
"20 20 8 1",
"       c None",
".      c #C6C6C6",
"+      c #CCCCCC",
"@      c #DBDBDB",
"#      c #D3D3D3",
"$      c #BFB0B5",
"%      c #C18799",
"&      c #C54F74",
"               .+++.",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"               +@@@+",
"          .++++#@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"          +@@@@@@@@+",
"     .++++#@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"     +@@@@@@@@@@@@@+",
"$%%%%#@@@@@@@@@@@@@+",
"%&&&&@@@@@@@@@@@@@@+",
"%&&&&@@@@@@@@@@@@@@+",
"%&&&&@@@@@@@@@@@@@@+",
"$%%%%++++++++++++++."
]
signal_none_pb  = None
signal_low_pb   = None
signal_barely_pb= None
signal_ok_pb    = None
signal_best_pb  = None

####################################################################################################
# Make so we can be imported
if __name__ == "__main__":
        if len( sys.argv ) > 1 and ( sys.argv[1] == '--version' or sys.argv[1] == '-v' ):
                print "WiFi-Radar version %s" % WIFI_RADAR_VERSION
        else:
                import gtk, gobject
                gtk.gdk.threads_init()
                apQueue = Queue.Queue(100)
                commQueue = Queue.Queue(2)
                threading.Thread( None, scanning_thread, None, ( confFile, apQueue, commQueue ) ).start()
                main_radar_window = radar_window(confFile, apQueue, commQueue)
                gobject.timeout_add( 500, main_radar_window.update_plist_items )
                main_radar_window.main()