Add files via upload

Menu/GameShell/10_Settings/Wifi/__init__.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*- 
+
+
+## local UI import
+import pages
+import myvars
+"""
+try:
+    from icons import preload
+except:
+    print("No icons package")
+"""
+from icons import preload
+
+def Init(main_screen):
+    
+    preload.load_icons()
+    pages.InitPasswordPage(main_screen)
+    pages.InitScanPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen != None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.ScanPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+
+

Menu/GameShell/10_Settings/Wifi/icons/preload.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from pygame.locals import *
+from sys import exit
+import os
+import sys
+
+from beeprint import pp
+
+ICONS_PRELOAD={}
+
+
+def load_icons():
+    basepath = os.path.dirname(os.path.realpath(__file__))
+
+    files = os.listdir(basepath)
+    for i in files:
+        if os.path.isfile(basepath+"/"+i) and i.endswith(".png"):
+            keyname = i.split(".")[0]
+            ICONS_PRELOAD[keyname] = pygame.image.load(basepath+"/"+i).convert_alpha()

Menu/GameShell/10_Settings/Wifi/keyboard.py

@@ -0,0 +1,340 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+from libs import easing
+
+## local UI import
+from UI.constants  import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.fonts  import fonts
+from UI.util_funcs import midRect
+from UI.keys_def import CurKeys
+from UI.icon_item import IconItem
+
+from textarea  import Textarea
+from text_item import TextItem
+from icons     import preload
+
+import myvars
+
+class KeyboardIcon(IconItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 0
+    _Color = pygame.Color(83,83,83)
+    _MyType  = ICON_TYPES["NAV"] 
+    _Parent  = None
+    _Str     = ""
+    
+    def Draw(self):
+        self._Parent._CanvasHWND.blit(self._ImgSurf, \
+            midRect(self._PosX,self._PosY,self._Width,self._Height,Width,Height))
+
+
+class KeyboardSelector(PageSelector):
+    
+    def Draw(self):
+        sec_idx = self._Parent._SectionIndex
+        row_idx = self._Parent._RowIndex
+        idx     = self._Parent._PsIndex
+        
+        x       = self._Parent._SecsKeys[sec_idx][row_idx][idx]._PosX
+        y       = self._Parent._SecsKeys[sec_idx][row_idx][idx]._PosY
+        w       = self._Parent._SecsKeys[sec_idx][row_idx][idx]._Width
+        h       = self._Parent._SecsKeys[sec_idx][row_idx][idx]._Height
+
+        rect    = midRect(x,y,w,h,self._Parent._Width,self._Parent._Height)
+        if rect.width <=0 or rect.height <= 0 :
+            return
+
+        pygame.draw.rect(self._Parent._CanvasHWND,(0,0,0),rect,1)
+
+class Keyboard(Page):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 0
+    _SectionNumbers = 3
+    _SectionIndex = 1
+
+    _Icons = {}
+    _Secs = {}
+    _SecsKeys = {}
+    _KeyboardLayoutFile = "UI/keyboard_keys.layout"
+    _Textarea = None
+    _Selector = None
+    _LeftOrRight = 1
+    _FootMsg           = ["Nav.","ABC","Done","Backspace","Enter"]
+
+    _RowIndex    = 0
+    
+    def __init__(self):
+        self._Secs     = {}
+        self._SecsKeys = {}
+        self._Icons    = {}
+
+    def ReadLayoutFile(self,fname):
+        LayoutIndex = 0
+        with open(fname) as f:
+            content = f.readlines()
+
+        content = [ x.strip() for x in content]
+        content = [ x.split(" ") for x in content]
+
+        for i in content:
+            i = [ x.strip() for x in i]
+            if len(i) > 2:
+                if LayoutIndex in self._Secs:
+                    self._Secs[LayoutIndex].append(i)
+                else:
+                    self._Secs[LayoutIndex] = []
+                    self._Secs[LayoutIndex].append(i)
+            else:
+                LayoutIndex+=1
+
+    def SetPassword(self,pwd):
+        
+        pwd_list = list(pwd)
+        self._Textarea.ResetMyWords()
+        for i in pwd_list:
+            self._Textarea.AppendText(i)
+            #self._Textarea.BlitText()
+        
+    def Init(self):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self.ReadLayoutFile(self._KeyboardLayoutFile) ## assign to _Secs
+        self._SectionNumbers = len(self._Secs)
+        self._PosX = self._Index*self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        fontobj = fonts["veramono24"]
+        word_margin = 15
+
+        start_x = (self._Width - fontobj.size( "".join(self._Secs[0][0]))[0]-len(self._Secs[0][0])*word_margin)/2+word_margin/2
+        start_y = 0
+        cnt = 0
+        for i in range(0,self._SectionNumbers):
+            self._SecsKeys[i] = []
+            for j in range(0,len(self._Secs[i])):
+                self._SecsKeys[i].append( [] )
+                
+                start_x = (self._Width - fontobj.size( "".join(self._Secs[i][j]))[0]-len(self._Secs[i][j])*word_margin)/2+word_margin/2
+                start_x = start_x + i*Width
+                start_y = 84+j*(word_margin+14)
+                for idx,val in enumerate(self._Secs[i][j]):
+                    ti = TextItem()
+                    ti._FontObj = fontobj
+                    ti._Parent = self
+
+                    if val == "_L" or val == "_R":
+                        it  = KeyboardIcon()
+                        it._ImgSurf = preload.ICONS_PRELOAD[val]
+                        it._Parent = self
+                        it._Str = val
+                        it.Init(start_x+it._ImgSurf.get_width()/2  ,start_y,it._ImgSurf.get_width(),it._ImgSurf.get_height(),0)
+                        #self._Icons[val] = it
+                        self._SecsKeys[i][j].append(it)
+                        self._IconNumbers+=1
+                        start_x = start_x + it._ImgSurf.get_width()+word_margin
+                        
+                    else:
+                        if val == "_S":
+                            val = "Space"
+                            ti._FontObj = fonts["veramono15"]
+                            ti._Bold = True
+                        
+                        cur_alpha_size  = ti._FontObj.size( val)
+                        ti.Init(start_x + cur_alpha_size[0]/2,start_y,cur_alpha_size[0],cur_alpha_size[1],0)
+                        ti._Str = val
+                    
+                        start_x = start_x + cur_alpha_size[0]+word_margin # prepare for next alpha
+                        self._SecsKeys[i][j].append(ti)
+    
+        self._SectionIndex = 0
+
+        self._Textarea = Textarea()
+        
+        self._Textarea._PosX = 4
+        self._Textarea._PosY = 4
+        self._Textarea._Width= self._Width - 4*2
+        self._Textarea._Height = 60
+        self._Textarea._CanvasHWND = self._CanvasHWND
+        self._Textarea.Init()
+
+
+        ps = KeyboardSelector()
+        ps._Parent = self
+        ps.Init(start_x,start_y,25,25,128)
+        self._Ps = ps
+        self._PsIndex = 0
+        self._Ps._OnShow = True
+
+    def SelectUpChar(self):
+        sec_idx = self._SectionIndex
+        self._RowIndex-=1
+        if self._RowIndex <0:
+            self._RowIndex = len(self._SecsKeys[sec_idx])-1
+
+        if self._PsIndex >=len(self._SecsKeys[sec_idx][self._RowIndex]):
+            self._PsIndex = len(self._SecsKeys[sec_idx][self._RowIndex])-1
+
+
+        self.ClearCanvas()
+        self.Draw()
+        self._Screen.SwapAndShow()
+            
+    def SelectDownChar(self):
+        sec_idx = self._SectionIndex
+        self._RowIndex+=1
+        if self._RowIndex >= len(self._SecsKeys[sec_idx]):
+            self._RowIndex = 0
+
+        if self._PsIndex >=len(self._SecsKeys[sec_idx][self._RowIndex]):
+            self._PsIndex = len(self._SecsKeys[sec_idx][self._RowIndex])-1
+
+        self.ClearCanvas()
+        self.Draw()
+        self._Screen.SwapAndShow()
+        
+    def SelectNextChar(self):
+        sec_idx = self._SectionIndex
+        row_idx = self._RowIndex
+        self._PsIndex+=1
+        if self._PsIndex >= len(self._SecsKeys[sec_idx][row_idx]):
+            self._PsIndex = 0
+            self._RowIndex+=1
+            if self._RowIndex >= len(self._SecsKeys[sec_idx]):
+                self._RowIndex = 0
+        
+        self.ClearCanvas()
+        self.Draw()
+        self._Screen.SwapAndShow()
+
+    def SelectPrevChar(self):
+        sec_idx = self._SectionIndex    
+        self._PsIndex-=1
+        if self._PsIndex < 0:
+            self._RowIndex-=1
+            if self._RowIndex <=0:
+                self._RowIndex = len(self._SecsKeys[sec_idx])-1
+            self._PsIndex = len(self._SecsKeys[sec_idx][self._RowIndex]) -1
+
+        self.ClearCanvas()
+        self.Draw()
+        self._Screen.SwapAndShow()
+      
+    def ClickOnChar(self):
+        sec_idx = self._SectionIndex        
+        alphabet = self._SecsKeys[sec_idx][self._RowIndex][self._PsIndex]._Str
+
+        if alphabet == "Space":
+            alphabet = " "
+        
+        if alphabet == "_L" or alphabet == "_R":
+            if alphabet == "_L":
+                self._Textarea.SubTextIndex()
+            elif alphabet == "_R":
+                self._Textarea.AddTextIndex()
+        else:
+            self._Textarea.AppendText(alphabet)
+        
+        self._Textarea.Draw()
+        self._Screen.SwapAndShow()
+
+
+    def KeyboardShift(self):
+        current_time = 0.0
+        start_posx   = 0.0
+        current_posx = start_posx
+        final_posx   = 320.0
+        posx_init    = 0.0
+        dur          = 30
+        last_posx    = 0.0 
+        all_last_posx = []
+
+        for i in range(0,Width*dur):
+            current_posx = easing.SineIn(current_time,start_posx,final_posx-start_posx,float(dur))
+            if current_posx >= final_posx:
+                current_posx = final_posx
+
+            dx  = current_posx - last_posx
+            all_last_posx.append(int(dx))
+            current_time +=1
+            last_posx = current_posx
+            if current_posx >= final_posx:
+                break
+        
+        c = 0
+        for i in all_last_posx:
+            c+=i
+        if c < final_posx - start_posx:
+            all_last_posx.append(final_posx - c)
+
+        for i in all_last_posx:
+            for j in range(0,self._SectionNumbers):
+                for u in self._SecsKeys[j]:
+                    for x in u: 
+                        x._PosX += self._LeftOrRight*i
+            
+            self.ResetPageSelector()
+            self.ClearCanvas()
+            self.Draw()
+            self._Screen.SwapAndShow()
+        
+    def KeyDown(self,event):# event from pygame.event.get()
+        if event.key == CurKeys["Up"]:
+            self.SelectUpChar()
+        if event.key == CurKeys["Down"]:
+            self.SelectDownChar()
+        if event.key == CurKeys["Right"]:
+            self.SelectNextChar()
+        if event.key == CurKeys["Left"]:
+            self.SelectPrevChar()
+        if event.key == CurKeys["B"] or event.key == CurKeys["Enter"]:
+            self.ClickOnChar()
+        if event.key == CurKeys["X"]:
+            if self._SectionIndex <= 0:
+                self._LeftOrRight = -1
+            if self._SectionIndex >= (self._SectionNumbers -1):
+                self._LeftOrRight = 1
+            self.KeyboardShift()
+
+            self._SectionIndex -= self._LeftOrRight
+
+            #print(self._SectionIndex) # on which keyboard section now
+            self.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Menu"]: # we assume keyboard always be child page
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Y"]: #done 
+            print("".join(self._Textarea._MyWords))
+            self.ReturnToUpLevelPage()
+            self._Screen.SwapAndShow()
+            ## config and connect now
+            myvars.ScanPage.ConfigWireless( "".join(self._Textarea._MyWords)) 
+
+        if event.key == CurKeys["A"]:
+            self._Textarea.RemoveFromLastText()
+            self._Textarea.Draw()
+            self._Screen.SwapAndShow()
+
+    def Draw(self):
+        self.ClearCanvas()
+        for i in range(0,self._SectionNumbers):
+            for j in self._SecsKeys[i]:
+                for u in j:
+                    u.Draw()
+
+        
+        self._Textarea.Draw()
+        self._Ps.Draw()
+
+

Menu/GameShell/10_Settings/Wifi/myvars.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*- 
+
+
+ScanPage = None
+PasswordPage = None

Menu/GameShell/10_Settings/Wifi/net_item.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+## local UI import
+from UI.page   import Page
+from UI.label  import Label
+from UI.fonts  import fonts
+from UI.icon_item import IconItem
+from UI.multi_icon_item  import MultiIconItem
+
+from icons  import preload
+
+class NetItemMultiIcon(MultiIconItem):
+    _CanvasHWND = None
+    _Parent     = None
+    _Width      = 18
+    _Height     = 18
+    
+    def Draw(self):
+        self._CanvasHWND.blit(self._ImgSurf,(self._PosX,self._PosY+(self._Parent._Height-self._Height)/2,self._Width,self._Height),
+                              (0,self._IconIndex*self._IconHeight,self._IconWidth,self._IconHeight))
+    
+class NetItemIcon(IconItem):
+
+    _CanvasHWND = None
+    _Parent     = None
+    _Width      = 18
+    _Height     = 18
+    
+    def Draw(self):
+        self._CanvasHWND.blit(self._ImgSurf,(self._PosX,self._PosY+(self._Parent._Height-self._Height)/2,self._Width,self._Height))
+
+            
+class NetItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Bssid=""    # 50:3A:A0:51:18:3C
+    _Essid=""    # MERCURY_EB88
+
+    ## extra infomations
+    _dhcphostname = "GameShell"
+    _ip   = None      #eg 192.168.31.141
+    _dns_domain = None
+    _gateway    = None  #eg 192.168.31.1
+    _use_global_dns = 0 ## eg 0 == False, 1 == True
+    _netmask    = None ##eg 255.255.255.0
+    _usedhcphostname= 0
+    _bitrate = "auto"
+    _allow_lower_bitrates = 0
+    _dns3 = None
+    _dns2 = None  ## eg 1.1.1.1
+    _dns1 = None  ## eg 8.8.8.8
+    _use_settings_globally = 0 
+    _use_static_dns = 0 # eg: 1 == True
+    _search_domain = None
+    
+    _Encrypt=""  # WPA2
+    _Channel=""  # '10' 
+    _Stren = ""  ## 19%
+    _NetId    = 0   ##  0-n
+    _Mode  = ""  ## Master or AdHoc
+    _Parent = None
+    _IsActive = False
+
+    _Icons  = {} ## wifi strength and security icons
+    _Labels = {}
+    _FontObj = None
+    
+    def __init__(self):
+        self._Labels = {}
+        self._Icons = {}
+
+    def SetActive(self,act):
+        self._IsActive = act
+    
+    def UpdateStrenLabel(self, strenstr): ## strenstr should be 'number',eg:'90'
+        self._Stren = self._Parent._Daemon.FormatSignalForPrinting(strenstr) 
+        self._Labels["stren"]._Text = self._Stren
+
+    def Init(self, i, is_active):
+        # Pick which strength measure to use based on what the daemon says
+        # gap allocates more space to the first module
+        if self._Parent._Daemon.GetSignalDisplayType() == 0:
+            strenstr = 'quality'
+            gap = 4  # Allow for 100%
+        else:
+            strenstr = 'strength'
+            gap = 7  # -XX dbm = 7
+        self._NetId = i
+        # All of that network property stuff
+        self._Stren = self._Parent._Daemon.FormatSignalForPrinting(
+                str(self._Parent._Wireless.GetWirelessProperty(self._NetId, strenstr)))
+        
+        self._Essid = self._Parent._Wireless.GetWirelessProperty(self._NetId, 'essid')
+        self._Bssid = self._Parent._Wireless.GetWirelessProperty(self._NetId, 'bssid')
+
+        if self._Parent._Wireless.GetWirelessProperty(self._NetId, 'encryption'):
+            self._Encrypt = \
+                self._Parent._Wireless.GetWirelessProperty(self._NetId, 'encryption_method')
+        else:
+            self._Encrypt = 'Unsecured'
+
+        self._Mode = \
+            self._Parent._Wireless.GetWirelessProperty(self._NetId, 'mode')  # Master, Ad-Hoc
+        self._Channel = self._Parent._Wireless.GetWirelessProperty(self._NetId, 'channel')
+        theString = '  %-*s %25s %9s %17s %6s %4s' % \
+            (gap, self._Stren, self._Essid, self._Encrypt, self._Bssid, self._Mode,
+                self._Channel)
+        
+        if is_active:
+            theString = ">> "+theString[1:]
+            self.SetActive(is_active)
+        
+
+
+        essid_label = Label()
+        essid_label._PosX = 36
+        #essid_label._PosY = self._PosY +  (self._Height - self._FontObj.render(self._Essid,True,(83,83,83)).get_height())/2
+        essid_label._CanvasHWND = self._Parent._CanvasHWND
+
+        if len(self._Essid) > 19:
+            essid_ = self._Essid[:20]
+        else:
+            essid_ = self._Essid
+        
+        essid_label.Init(essid_,self._FontObj)
+        self._Labels["essid"] = essid_label
+
+        stren_label = Label()
+        #stren_label._PosY = self._PosY +  (self._Height - self._FontObj.render(self._Stren,True,(83,83,83)).get_height())/2
+        stren_label._CanvasHWND = self._Parent._CanvasHWND
+
+        stren_label.Init(self._Stren,self._FontObj)
+        stren_label._PosX = self._Width - 23 - stren_label.Width() - 2
+        self._Labels["stren"] = stren_label
+        
+
+        lock_icon = NetItemIcon()
+        lock_icon._ImgSurf = preload.ICONS_PRELOAD["lock"]
+        lock_icon._CanvasHWND = self._Parent._CanvasHWND
+        lock_icon._Parent = self
+        self._Icons["lock"] = lock_icon
+        
+        done_icon = NetItemIcon()
+        done_icon._ImgSurf = preload.ICONS_PRELOAD["done"]
+        done_icon._CanvasHWND = self._Parent._CanvasHWND
+        done_icon._Parent = self
+        
+        self._Icons["done"] = done_icon
+
+
+        ## reuse the resource from TitleBar
+        nimt = NetItemMultiIcon()
+        nimt._ImgSurf = self._Parent._Screen._TitleBar._Icons["wifistatus"]._ImgSurf
+        nimt._CanvasHWND = self._Parent._CanvasHWND
+        nimt._Parent = self
+        self._Icons["wifistatus"] = nimt
+
+        #pp(theString)
+    
+    
+    def Connect(self,notworkentry=None):
+        """ Execute connection. """
+        self._Parent._Wireless.ConnectWireless(self._NetId)
+
+    
+    def Draw(self):
+        #pygame.draw.line(self._Parent._CanvasHWND,(169,169,169),(self._PosX,self._PosY),(self._PosX+self._Width,self._PosY),1)        
+        for i in self._Labels:
+            self._Labels[i]._PosY = self._PosY + (self._Height - self._Labels[i]._Height)/2
+            self._Labels[i].Draw()
+            
+        if self._IsActive:
+            self._Icons["done"].NewCoord(14,self._PosY)
+            self._Icons["done"].Draw()
+
+        if self._Encrypt != "Unsecured":
+            self._Icons["lock"].NewCoord( self._Width -23 - self._Labels["stren"].Width() - 2 - 18, self._PosY)
+            self._Icons["lock"].Draw()
+        
+        ge = self._Parent._Screen._TitleBar.GetWifiStrength( self._Stren.replace('%',''))
+        
+        if ge > 0:
+            self._Icons["wifistatus"]._IconIndex = ge
+            self._Icons["wifistatus"].NewCoord(self._Width-23,self._PosY)
+            self._Icons["wifistatus"].Draw()
+            
+        else:
+            self._Icons["wifistatus"]._IconIndex = 0
+            self._Icons["wifistatus"].NewCoord(self._Width-23,self._PosY)
+            self._Icons["wifistatus"].Draw()
+        
+        pygame.draw.line(self._Parent._CanvasHWND,(169,169,169),(self._PosX,self._PosY+self._Height-1),(self._PosX+self._Width,self._PosY+self._Height-1),1)        
+        
+

Menu/GameShell/10_Settings/Wifi/pages.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*- 
+
+
+#import dbus
+#import dbus.service
+#from wicd import misc 
+##misc.to_bool
+##misc.misc.noneToString
+##misc.to_unicode
+##misc.Noneify
+#from wicd.translations import _
+#from wicd import wpath
+#from wicd import dbusmanager
+
+
+## local UI import
+from libs.DBUS      import bus,daemon,wireless,wired
+
+from keyboard import Keyboard
+from wifi_list import WifiList
+
+import myvars
+
+
+def InitScanPage(main_screen):
+    global wireless
+    global daemon
+    global bus
+    
+    myvars.ScanPage = WifiList()
+    myvars.ScanPage._Name = "Scan wifi"
+   
+    myvars.ScanPage._Wireless = wireless
+    myvars.ScanPage._Daemon = daemon
+    myvars.ScanPage._Dbus = bus
+   
+
+    myvars.ScanPage._Screen = main_screen
+    myvars.ScanPage.Init()
+
+
+    if daemon != None:
+        #Bind signals
+        myvars.ScanPage._Dbus.add_signal_receiver(myvars.ScanPage.DbusScanFinishedSig, 'SendEndScanSignal',
+                                                  'org.wicd.daemon.wireless')
+        myvars.ScanPage._Dbus.add_signal_receiver(myvars.ScanPage.DbusScanStarted, 'SendStartScanSignal',
+                                                  'org.wicd.daemon.wireless')
+        #
+        myvars.ScanPage._Dbus.add_signal_receiver(myvars.ScanPage.DbusDaemonStatusChangedSig, 'StatusChanged',
+                                                  'org.wicd.daemon')
+        myvars.ScanPage._Dbus.add_signal_receiver(myvars.ScanPage.DbusConnectResultsSent, 'ConnectResultsSent',
+                                                  'org.wicd.daemon')
+
+def InitPasswordPage(main_screen):
+
+    myvars.PasswordPage = Keyboard()
+    myvars.PasswordPage._Name = "Enter wifi password"
+
+    myvars.PasswordPage._Screen = main_screen
+    myvars.PasswordPage.Init()
+

Menu/GameShell/10_Settings/Wifi/text_item.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*- 
+#local import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+
+class TextItem(IconItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 0
+    _Str    = ""
+    _Color = (83,83,83)
+    _FontObj = None
+    _Bold    = False
+    _MyType  = ICON_TYPES["LETTER"] 
+    _Parent  = None
+
+    def Draw(self):
+        self._FontObj.set_bold(self._Bold)
+        my_text = self._FontObj.render(self._Str,True,self._Color)
+        if my_text.get_width() != self._Width:
+            self._Width = my_text.get_width()
+        if my_text.get_height() != self._Height:
+            self._Height = my_text.get_height()
+
+        self._Parent._CanvasHWND.blit(my_text, \
+            midRect(self._PosX,self._PosY,self._Width,self._Height,Width,Height))

Menu/GameShell/10_Settings/Wifi/textarea.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from libs.roundrects import aa_round_rect
+
+
+
+
+## local UI import
+from UI.page         import Page,PageStack,PageSelector
+from UI.label        import Label
+from UI.fonts        import fonts
+
+class Textarea:
+    _PosX =0 
+    _PosY = 0
+    _Width = 0
+    _Height = 0
+    _BackgroundColor = pygame.Color(229,229,229)
+    _CanvasHWND  = None
+    _MyWords     = []
+    _FontObj     = None
+    _LineNumber  = 0
+    _TextFull    = False
+    _TextIndex   = 0
+
+    def __init__(self):
+        pass
+    
+    def Init(self):
+        self._FontObj = fonts["veramono24"] 
+        #pygame.font.Font(fonts_path["veramono"],24)
+
+    def SubTextIndex(self):
+
+        self._TextIndex-=1
+        if self._TextIndex < 0:
+            self._TextIndex = 0
+
+    def AddTextIndex(self):
+        self._TextIndex +=1
+        if self._TextIndex > len(self._MyWords):
+            self._TextIndex = len(self._MyWords)
+        
+    def ResetMyWords(self):
+        self._MyWords = []
+        self._TextIndex = 0
+        
+    def RemoveFromLastText(self):
+        if len(self._MyWords) > 0:
+            self.SubTextIndex()
+            
+            del self._MyWords[self._TextIndex]
+            
+            return self._MyWords
+
+    def AppendText(self,alphabet):
+        
+        self.AppendAndBlitText(alphabet)
+
+    def AppendAndBlitText(self,alphabet):
+        
+        if self._TextFull != True:
+            
+            self._MyWords.insert(self._TextIndex,alphabet)
+            self.BlitText()
+            self.AddTextIndex()
+        else:
+            print("is Full %s" % "".join(self._MyWords))
+
+            
+    def BlitText(self):
+        """
+        blit every single word into surface and calc the width ,check multi line 
+        """
+        w = 0
+        xmargin = 5
+        endmargin = 15
+        x = self._PosX+xmargin
+        y = self._PosY
+        linenumber = 0
+        self._TextFull = False
+        for i,v in enumerate(self._MyWords):
+            t = self._FontObj.render(v,True,(8,135,174))
+            w += t.get_width()
+
+            if w >= self._Width-endmargin and linenumber == 0:
+                x = self._PosX+xmargin
+                y = self._PosY+ t.get_height()
+                w = 0
+                linenumber +=1
+            
+            if w >= self._Width-endmargin*4 and linenumber > 0:
+                self._TextFull = True
+                self._CanvasHWND.blit(t, (x,y))
+                break
+            self._CanvasHWND.blit(t, (x,y))
+            x += t.get_width()
+        
+    def Cursor(self):
+        w = 0
+        xmargin = 5
+        endmargin = 15
+        x = self._PosX+xmargin
+        y = self._PosY
+        linenumber = 0
+        for i,v in enumerate(self._MyWords[:self._TextIndex]):
+            t = self._FontObj.render(v,True,(8,135,174))
+            w += t.get_width()
+
+            if w >= self._Width-endmargin and linenumber == 0:
+                x = self._PosX+xmargin
+                y = self._PosY+ t.get_height()
+                w = 0
+                linenumber +=1
+            
+            if w >= self._Width-endmargin*3 and linenumber > 0:
+                x += t.get_width()
+                break
+            x += t.get_width()
+            
+        self._CanvasHWND.blit(self._FontObj.render("_",True,(0,0,0)),(x+1,y-2))
+    
+    def Draw(self):
+        #aa_round_rect(self._CanvasHWND, (4,24.5+6,312,60),self._BackgroundColor,4,0,self._BackgroundColor)
+
+        aa_round_rect(self._CanvasHWND,  
+                    (self._PosX,self._PosY,self._Width,self._Height),self._BackgroundColor,4,0,self._BackgroundColor)
+
+
+        
+        self.BlitText()
+        self.Cursor()

Menu/GameShell/10_Settings/Wifi/wifi_list.py

@@ -0,0 +1,820 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+from beeprint import pp
+from libs.roundrects import aa_round_rect
+import gobject
+from wicd import misc 
+## local UI import
+from UI.constants import Width,Height
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.fonts  import fonts
+from UI.util_funcs import midRect,SwapAndShow
+from UI.keys_def   import CurKeys
+from UI.scroller   import ListScroller
+from UI.confirm_page import ConfirmPage
+
+from net_item import NetItem
+
+import myvars
+
+
+class InfoPageListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+    
+    def __init__(self):
+        self._Labels = {}
+        self._Icons  = {}
+        self._Fonts  = {}
+
+    def SetSmallText(self,text):
+        
+        l = Label()
+        l._PosX = 40
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+        l.Init(text,self._Fonts["small"])
+        self._Labels["Small"] = l
+        
+    def Init(self,text):
+
+        #self._Fonts["normal"] = fonts["veramono12"]
+        
+        l = Label()
+        l._PosX = 10
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+
+        l.Init(text,self._Fonts["normal"])
+        self._Labels["Text"] = l
+
+    def Draw(self):
+        
+        self._Labels["Text"]._PosY = self._PosY + (self._Height - self._Labels["Text"]._Height)/2
+        self._Labels["Text"].Draw()
+
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width-5
+            
+            self._Labels["Small"]._PosY = self._PosY + (self._Height - self._Labels["Small"]._Height)/2
+            self._Labels["Small"].Draw()
+        
+        pygame.draw.line(self._Parent._CanvasHWND,(169,169,169),(self._PosX,self._PosY+self._Height-1),(self._PosX+self._Width,self._PosY+self._Height-1),1)
+    
+
+
+class WifiDisconnectConfirmPage(ConfirmPage):
+
+    _ConfirmText = "Confirm Disconnect?"
+    
+    def KeyDown(self,event):
+        if event.key == CurKeys["Menu"] or event.key == CurKeys["A"]:
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["B"]:
+            self.SnapMsg("Disconnecting...")
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+            self._Parent._Daemon.Disconnect()
+            
+            pygame.time.delay(400)
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+                    
+    def Draw(self):
+        #self.ClearCanvas()
+        self.DrawBG()
+        for i in self._MyList:
+            i.Draw()
+        
+        self.Reset()
+        
+class WifiInfoPageSelector(PageSelector):
+    _BackgroundColor = pygame.Color(131,199,219)
+
+    def __init__(self):
+        self._PosX = 0
+        self._PosY = 0
+        self._Height = 0
+        self._Width  = Width
+
+    def AnimateDraw(self,x2,y2):
+        pass
+
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        if idx < len(self._Parent._MyList):
+            x = 2
+            y = self._Parent._MyList[idx]._PosY+1
+            h = self._Parent._MyList[idx]._Height -3
+            
+            self._PosX = x
+            self._PosY = y
+            self._Height = h
+            
+            aa_round_rect(self._Parent._CanvasHWND,  
+                          (x,y,self._Width-4,h),self._BackgroundColor,4,0,self._BackgroundColor)
+            
+class WifiInfoPage(Page):
+    _FootMsg =  ["Nav.","Disconnect","","Back",""]
+    _MyList = []
+    _ListFontObj = fonts["varela15"]
+
+    _Wireless = None
+    _Daemon   = None
+    
+    _AList = {}
+    _NetworkId = -1
+    
+    def GenList(self):
+        
+        self._MyList = []
+        if self._NetworkId != -1:
+            self._AList["ip"]["value"] = "Not Connected"
+            
+            if self._Wireless.GetCurrentNetworkID(self._Wireless.GetIwconfig()) == self._NetworkId:
+                ip = self._Wireless.GetWirelessIP('')
+            
+                if ip is not None:
+                    self._AList["ip"]["value"] = ip
+            
+            self._AList["bssid"]["value"] = self._Wireless.GetWirelessProperty(self._NetworkId,"bssid")
+        
+        start_x  = 0
+        start_y  = 0
+        
+        for i,v in enumerate( self._AList):
+            li = InfoPageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*InfoPageListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFontObj
+            li._Fonts["small"] = fonts["varela12"]
+            
+            if self._AList[v]["label"] != "":
+                li.Init(  self._AList[v]["label"] )
+            else:
+                li.Init( self._AList[v]["key"] )
+
+            li._Flag = self._AList[v]["key"]
+
+            li.SetSmallText( self._AList[v]["value"] )
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._CanvasHWND = self._Screen._CanvasHWND
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        ps = WifiInfoPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        ip = {}
+        ip["key"] = "ip"
+        ip["label"] = "IP"
+        ip["value"] = "Not Connected"
+        
+        bssid = {}
+        bssid["key"] = "bssid"
+        bssid["label"] = "BSSID"
+        bssid["value"] = ""
+        
+        self._AList["ip"] = ip
+        self._AList["bssid"] = bssid
+        
+        self.GenList()
+
+        self._DisconnectConfirmPage = WifiDisconnectConfirmPage()
+        self._DisconnectConfirmPage._Screen = self._Screen
+        self._DisconnectConfirmPage._Name   = "Confirm Disconnect"
+        self._DisconnectConfirmPage._Parent = self
+        self._DisconnectConfirmPage.Init()
+        
+    def ScrollUp(self):
+        if len(self._MyList) == 0:
+            return
+        self._PsIndex -= 1
+        if self._PsIndex < 0:
+            self._PsIndex = 0
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._PosY < 0:
+            for i in range(0, len(self._MyList)):
+                self._MyList[i]._PosY += self._MyList[i]._Height
+        
+
+    def ScrollDown(self):
+        if len(self._MyList) == 0:
+            return
+        self._PsIndex +=1
+        if self._PsIndex >= len(self._MyList):
+            self._PsIndex = len(self._MyList) -1
+
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._PosY +cur_li._Height > self._Height:
+            for i in range(0,len(self._MyList)):
+                self._MyList[i]._PosY -= self._MyList[i]._Height
+
+    def Click(self):
+        cur_li = self._MyList[self._PsIndex]
+        print(cur_li._Flag)        
+
+    def TryDisconnect(self):
+        if self._Wireless.GetCurrentNetworkID(self._Wireless.GetIwconfig()) == self._NetworkId \
+           and self._Wireless.GetWirelessIP('') is not None:
+            self._Screen.PushPage(self._DisconnectConfirmPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        else:
+            return
+        
+    def OnLoadCb(self):
+        if self._Wireless.GetCurrentNetworkID(self._Wireless.GetIwconfig()) == self._NetworkId \
+           and self._Wireless.GetWirelessIP('') is not None:
+            self._FootMsg[1] = "Disconnect"
+        else:
+            self._FootMsg[1] =  ""
+
+        self.GenList()
+
+    def OnReturnBackCb(self):
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def KeyDown(self,event):
+        if event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Up"]:
+            self.ScrollUp()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        if event.key == CurKeys["Down"]:
+            self.ScrollDown()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+
+        if event.key == CurKeys["Enter"]:
+            self.Click()
+
+        if event.key == CurKeys["X"]:
+            self.TryDisconnect()
+                                
+    def Draw(self):
+        self.ClearCanvas()
+        self._Ps.Draw()
+
+        for i in self._MyList:
+            i.Draw()
+
+
+        
+    
+class WifiListSelector(PageSelector):
+    _BackgroundColor = pygame.Color(131,199,219)
+
+    def __init__(self):
+        self._PosX = 0
+        self._PosY = 0
+        self._Height = 0
+
+    def AnimateDraw(self,x2,y2):
+        pass 
+
+
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        if idx < len( self._Parent._WirelessList):
+            x = self._Parent._WirelessList[idx]._PosX+11
+            y = self._Parent._WirelessList[idx]._PosY+1
+            h = self._Parent._WirelessList[idx]._Height -3
+        
+            self._PosX = x
+            self._PosY = y
+            self._Height = h
+
+            aa_round_rect(self._Parent._CanvasHWND,  
+                          (x,y,self._Width,h),self._BackgroundColor,4,0,self._BackgroundColor)
+
+
+class WifiListMessageBox(Label):
+    _Parent = None
+
+    def Draw(self):
+        my_text = self._FontObj.render( self._Text,True,self._Color)
+        w  = my_text.get_width()
+        h  = my_text.get_height()
+        x  = (self._Parent._Width - w)/2
+        y =  (self._Parent._Height - h)/2
+        padding = 10 
+        pygame.draw.rect(self._CanvasHWND,(255,255,255),(x-padding,y-padding, w+padding*2,h+padding*2))        
+
+        pygame.draw.rect(self._CanvasHWND,(0,0,0),(x-padding,y-padding, w+padding*2,h+padding*2),1)
+
+        self._CanvasHWND.blit(my_text,(x,y,w,h))
+
+class WifiList(Page):
+    _WirelessList = []
+    #Wicd dbus part
+    _Wireless = None
+    _Daemon   = None
+    _Dbus     = None
+    _WifiPassword = ""
+    _Connecting = False
+    _Scanning   = False 
+    
+    _PrevWicdState = None
+    
+    _Selector = None
+    
+    _ShowingMessageBox = False 
+    _MsgBox            = None
+    _ConnectTry        = 0
+    _BlockingUI        = False
+    _BlockCb           = None
+    
+    _LastStatusMsg     = ""
+    _FootMsg           = ["Nav.","Scan","Info","Back","Enter"]
+    _EncMethods        = None
+    _Scroller          = None
+    _ListFontObj       = fonts["notosanscjk15"]
+
+    _InfoPage          = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._WirelessList = []
+        self._CanvasHWND = None
+    
+    def ShowBox(self,msg):
+        self._MsgBox._Text = msg
+        self._ShowingMessageBox = True
+        self._Screen.Draw()
+        self._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+    
+    def HideBox(self):
+        self.Draw()
+        self._ShowingMessageBox = False
+        self._Screen.SwapAndShow()
+
+    def GenNetworkList(self):
+        self._WirelessList = []
+        start_x = 0
+        start_y = 0
+
+        for network_id in range(0,self._Wireless.GetNumberOfNetworks()):
+            is_active = \
+                self._Wireless.GetCurrentSignalStrength("") != 0 and \
+                self._Wireless.GetCurrentNetworkID(self._Wireless.GetIwconfig()) == network_id \
+                and self._Wireless.GetWirelessIP('') is not None
+
+            ni = NetItem()
+            ni._Parent = self
+            ni._PosX = start_x
+            ni._PosY = start_y + network_id* NetItem._Height
+            ni._Width = Width
+            ni._FontObj = self._ListFontObj
+            #ni._Bssid   = self._Wireless.GetWirelessProperty(network_id,"bssid")
+            
+            ni.Init(network_id,is_active)
+            self._WirelessList.append(ni)
+
+        self._PsIndex = 0
+        
+    def Disconnect(self):
+        self._Connecting= False
+        self._Daemon.Disconnect()
+    ## force to disconnect
+    def ShutDownConnecting(self):
+        print("Shutdownconnecting...",self._ConnectTry)
+        self._Daemon.CancelConnect()
+        self._Daemon.SetForcedDisconnect(True)
+        self._Connecting = False
+
+    def Rescan(self,sync=False):
+        print("start Rescan")
+        if self._Wireless != None:
+            self._Wireless.Scan(sync)
+
+## dbus signal functions
+    def DbusScanFinishedSig(self):
+
+        if self._Screen._CurrentPage != self:
+            return
+        self.ResetPageSelector()
+        
+        self.UpdateNetList(force_check=True)
+
+        self._Scanning = False
+        self.HideBox()
+        self._BlockingUI = False
+        print("dbus says scan finished")
+
+    def DbusScanStarted(self):
+        if self._Screen._CurrentPage !=self:
+            return
+        
+        self._Scanning = True
+        self.ShowBox("Wifi scanning...")
+        self._BlockingUI = True
+        print("dbus says start scan...")
+
+
+    def UpdateNetList(self,state=None,info=None,force_check=False,firstrun=False):
+
+        if self._Daemon == None:
+            return
+        
+        if not state:
+            state,trash = self._Daemon.GetConnectionStatus()
+            print("state")
+            pp(state)
+            print("Trash: ")
+            pp(trash)
+
+        if force_check or self._PrevWicdState != state:
+            self.GenNetworkList() ## refresh the network list 
+        
+        if info != None:
+            if len(info) > 3:
+                _id  = int(info[3])
+                if _id < len(self._WirelessList):
+                    self._WirelessList[_id].UpdateStrenLabel( str(info[2]))
+
+        self._PrevWicdState = state
+        
+    def SetConnectingStatus(self,fast):
+        wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
+
+        """
+        if self._ConnectTry > 5000:
+            #wicd itself will take a very long time to try to connect ,will not block forever,just make it faster to dropout
+            self.ShutDownConnecting()
+            self._ConnectTry = 0
+            self._BlockingUI = False
+            return False
+        """
+        
+        if wireless_connecting:
+            if not fast:
+                iwconfig = self._Wireless.GetIwconfig()
+            else:
+                iwconfig = ''
+            essid = self._Wireless.GetCurrentNetwork(iwconfig)
+            stat = self._Wireless.CheckWirelessConnectingMessage()
+            if self._LastStatusMsg != "%s: %s"%(essid,stat):
+                print("%s: %s" %(essid,stat))
+                self._LastStatusMsg = "%s: %s"%(essid,stat)
+                self.ShowBox(self._LastStatusMsg)
+                
+                self._Screen._FootBar.UpdateNavText(self._LastStatusMsg)
+                SwapAndShow()
+                
+            #self._ConnectTry+=1
+
+            return True
+        else:
+            self._Connecting = False
+            return self._Connecting
+
+    def UpdateStatus(self):
+        print("UpdateStatus")
+        wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
+        fast = not self._Daemon.NeedsExternalCalls()
+        
+        self._Connecting = wireless_connecting
+        
+        if self._Connecting:
+            gobject.timeout_add(250,self.SetConnectingStatus,fast)
+        else:
+            if not fast:
+                iwconfig = self._Wireless.GetIwconfig()
+            else:
+                iwconfig = ''
+
+            if self.CheckForWireless(iwconfig,self._Wireless.GetWirelessIP(''),None):
+                return True
+            else:
+                print("Not Connected")
+                return True
+
+    def DbusDaemonStatusChangedSig(self,state=None,info=None):
+        print("in DbusDaemonStatusChangedSig")
+        """
+        dbus.UInt32(2L)
+        ['192.168.31.141', 'TP-LINK4G', '88', '0', '72.2 Mb/s']
+        """
+        pp(info)
+        self.UpdateNetList(state,info)
+        if info != None:
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+
+    def DbusConnectResultsSent(self,result):
+        print(" in DbusConnectResultsSent")
+        """
+         in DbusConnectResultsSent
+        'dhcp_failed'
+        dbus says start scan...
+
+        """
+        if result != None:
+            print(result)
+            
+        self._Connecting = False
+        self._BlockingUI = False
+        if self._BlockCb != None:
+            self._BlockCb()
+            self._BlockCb = None
+
+        self._Screen._FootBar.ResetNavText()
+    
+    def CheckForWireless(self,iwconfig,wireless_ip,set_status):
+        if not wireless_ip:
+            return False
+        network = self._Wireless.GetCurrentNetwork(iwconfig)
+        if not network:
+            return False
+        network = misc.to_unicode(network)
+        if daemon.GetSignalDisplayType() == 0:
+            strength = self._Wireless.GetCurrentSignalStrength(iwconfig)
+        else:
+            strength = self._Wireless.GetCurrentDBMStrength(iwconfig)
+
+        if strength is None:
+            return False
+        strength = misc.to_unicode(self._Daemon.FormatSignalForPrinting(strength))
+        ip = misc.to_unicode(wireless_ip)
+
+        print(_('Connected to $A at $B (IP: $C)').replace
+                    ('$A', network).replace
+                    ('$B', strength).replace
+                    ('$C', ip))
+        
+        return True
+
+    def ConfigWireless(self,password):
+        netid = self._PsIndex
+        print(netid," ", password)
+        """
+        self._Wireless.SetWirelessProperty(netid,"dhcphostname","GameShell")
+        self._Wireless.SetWirelessProperty(netid,"ip","None")
+        self._Wireless.SetWirelessProperty(netid,"dns_domain","None")
+        self._Wireless.SetWirelessProperty(netid,"gateway","None")
+        self._Wireless.SetWirelessProperty(netid,"use_global_dns",0)
+        self._Wireless.SetWirelessProperty(netid,"netmask","None")
+        self._Wireless.SetWirelessProperty(netid,"usedhcphostname",0) ## set 1 to use hostname above
+        self._Wireless.SetWirelessProperty(netid,"bitrate","auto")
+        self._Wireless.SetWirelessProperty(netid,"allow_lower_bitrates",0)
+        self._Wireless.SetWirelessProperty(netid,"dns3","None")
+        self._Wireless.SetWirelessProperty(netid,"dns2","None")
+        self._Wireless.SetWirelessProperty(netid,"dns1","None")
+        self._Wireless.SetWirelessProperty(netid,"use_settings_globally",0)
+        self._Wireless.SetWirelessProperty(netid,"use_static_dns",0)
+        self._Wireless.SetWirelessProperty(netid,"search_domain","None")
+        """
+        self._Wireless.SetWirelessProperty(netid,"enctype","wpa-psk")
+        self._Wireless.SetWirelessProperty(netid,"apsk",password)
+        self._Wireless.SetWirelessProperty(netid,"automatic",1)
+
+        
+        self._WirelessList[netid].Connect()
+        print("after Connect")
+        self.UpdateStatus()
+
+    def GetWirelessEncrypt(self,network_id):
+        results = []
+        activeID = -1
+        for x,enc_type in enumerate(self._EncMethods):
+            if enc_type["type"] == self._Wireless.GetWirelessProperty(network_id,"enctype"):
+                activeID = x
+                break
+
+        if activeID == -1:
+            return results
+        
+        for type_ in ['required','optional']:
+            fields = self._EncMethods[activeID][type_]
+            for field in fields:
+                try:
+                    text = field[1].lower().replace(' ','_')
+                except KeyError:
+                    text = field[1].replace(' ','_')
+                
+                value = self._Wireless.GetWirelessProperty(network_id, field[0])
+                results.append({text:value})
+        """
+        [{'preshared_key': 'blah blah blah',},]
+
+        or nothing 
+        [{'identity': None,},{'password': None,},]
+
+        """
+        return results
+
+    def ScrollUp(self):
+        if len(self._WirelessList) == 0:
+            return
+        self._PsIndex-=1
+        if self._PsIndex < 0:
+            self._PsIndex = 0
+        
+        cur_ni = self._WirelessList[self._PsIndex]
+        if cur_ni._PosY < 0:
+            for i in range(0,len(self._WirelessList)):
+                self._WirelessList[i]._PosY += self._WirelessList[i]._Height
+            
+    def ScrollDown(self):
+        if len(self._WirelessList) == 0:
+            return
+        self._PsIndex+=1
+        if self._PsIndex >= len(self._WirelessList):
+            self._PsIndex = len(self._WirelessList) -1
+       
+        cur_ni = self._WirelessList[self._PsIndex]
+        if cur_ni._PosY + cur_ni._Height > self._Height:
+            for i in range(0,len(self._WirelessList)):
+                self._WirelessList[i]._PosY -= self._WirelessList[i]._Height
+    
+
+    def AbortedAndReturnToUpLevel(self):
+        self.HideBox()
+        self._Screen._FootBar.ResetNavText()
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def KeyDown(self,event):
+
+        if self._BlockingUI == True:
+            print("UI blocking ...")
+            return
+        
+        if event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
+            if self._Wireless != None:
+                wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
+                if wireless_connecting:
+                    self.ShutDownConnecting()
+                    self.ShowBox("ShutDownConnecting...")
+                    self._BlockingUI=True
+                    self._BlockCb = self.AbortedAndReturnToUpLevel
+                else:
+                    self.AbortedAndReturnToUpLevel()
+            else:
+                self.HideBox()
+                self.ReturnToUpLevelPage()
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+    
+        if event.key == CurKeys["Up"]:
+            self.ScrollUp()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        if event.key == CurKeys["Down"]:
+            self.ScrollDown()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Enter"]: ## enter to set password,enter is B on GM
+            if len(self._WirelessList) == 0:
+                return
+            
+            wicd_wirelss_encrypt_pwd = self.GetWirelessEncrypt(self._PsIndex)
+            
+            if self._WirelessList[self._PsIndex]._IsActive:
+                self.ShowBox( self._Wireless.GetWirelessIP('')    )
+            else:
+                self._Screen.PushCurPage()
+                self._Screen.SetCurPage( myvars.PasswordPage )
+                
+                thepass = ""
+                for i in wicd_wirelss_encrypt_pwd:
+                    if "preshared_key" in i:
+                        if i["preshared_key"] != None:
+                            if len(i["preshared_key"]) > 0:
+                                thepass = i["preshared_key"]
+                                break
+                
+                myvars.PasswordPage.SetPassword(thepass)
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+                
+                """
+                try:
+                    self._Screen.Draw()
+                    self._Screen.SwapAndShow()
+                except Exception as e: 
+                    print(e)
+                    exit(-1)
+                """
+        if event.key == CurKeys["X"]:
+            self.Rescan(False)
+            
+        if event.key == CurKeys["Y"]:
+            if len(self._WirelessList) == 0:
+                return
+
+            self._InfoPage._NetworkId = self._PsIndex
+            self._InfoPage._Wireless  = self._Wireless
+            self._InfoPage._Daemon    = self._Daemon
+            
+            self._Screen.PushPage(self._InfoPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+
+    def Init(self):
+        
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        #self._CanvasHWND = pygame.Surface((self._Width,self._Height))
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = WifiListSelector()
+        ps._Parent = self
+        ps._Width = Width - 12
+        
+        self._Ps = ps
+        self._PsIndex = 0
+        
+        msgbox = WifiListMessageBox()
+        msgbox._CanvasHWND = self._CanvasHWND
+        msgbox.Init(" ",fonts["veramono12"])
+        msgbox._Parent = self
+        
+        self._MsgBox = msgbox 
+
+        self._EncMethods = misc.LoadEncryptionMethods() # load predefined templates from /etc/wicd/...
+
+        """
+  {
+    'fields': [],
+    'name': 'WPA 1/2 (Passphrase)',
+    'optional': [],
+    'protected': [
+      ['apsk', 'Preshared_Key'],
+    ],
+    'required': [
+      ['apsk', 'Preshared_Key'],
+    ],
+    'type': 'wpa-psk',
+  },
+        """
+        
+        self.UpdateNetList(force_check=True,firstrun=True)
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = 2
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+
+
+        self._InfoPage = WifiInfoPage()
+        self._InfoPage._Screen = self._Screen
+        self._InfoPage._Name   = "Wifi info"
+        self._InfoPage.Init()
+        
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._WirelessList) == 0:
+            return
+        
+        self._Ps.Draw()
+        for i in self._WirelessList:
+            i.Draw()
+
+        
+        self._Scroller.UpdateSize( len(self._WirelessList)*NetItem._Height, self._PsIndex*NetItem._Height)
+        self._Scroller.Draw()