clockworkpi/launcher
1
0
Fork 0
mirror of https://github.com/clockworkpi/launcher.git synced 2026-03-23 12:22:47 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update menu content items, icons and the order

Browse Source
This commit is contained in:
cuu
2019-07-16 09:10:42 +08:00
parent 66298985a4
commit 925076fac7
74 changed files with 10 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Menu/GameShell/80_SETTINGS/Wifi/__init__.py Normal file
View File

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

5
Menu/GameShell/80_SETTINGS/Wifi/myvars.py Normal file
View File

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

196
Menu/GameShell/80_SETTINGS/Wifi/net_item.py Normal file
View File

@@ -0,0 +1,196 @@
# -*- coding: utf-8 -*-
import pygame
## local UI import
from UI.page import Page
from UI.label import Label
from UI.icon_item import IconItem
from UI.multi_icon_item import MultiIconItem
from UI.icon_pool import MyIconPool
from UI.skin_manager import MySkinManager
from UI.widget import Widget
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(Widget):
_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 = MyIconPool._Icons["lock"]
lock_icon._CanvasHWND = self._Parent._CanvasHWND
lock_icon._Parent = self
self._Icons["lock"] = lock_icon
done_icon = NetItemIcon()
done_icon._ImgSurf = MyIconPool._Icons["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,MySkinManager.GiveColor('Line'),(self._PosX,self._PosY+self._Height-1),(self._PosX+self._Width,self._PosY+self._Height-1),1)

61
Menu/GameShell/80_SETTINGS/Wifi/pages.py Normal file
View File

@@ -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 UI.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()

722
Menu/GameShell/80_SETTINGS/Wifi/wifi_list.py Normal file
View File

@@ -0,0 +1,722 @@
# -*- 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.util_funcs import midRect,SwapAndShow
from UI.keys_def import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
from UI.scroller import ListScroller
from UI.confirm_page import ConfirmPage
from UI.skin_manager import MySkinManager
from UI.lang_manager import MyLangManager
from UI.info_page_list_item import InfoPageListItem
from UI.info_page_selector import InfoPageSelector
from libs.DBUS import is_wifi_connected_now
from net_item import NetItem
import myvars
class WifiDisconnectConfirmPage(ConfirmPage):
_ConfirmText = MyLangManager.Tr("ConfirmDisconnectQ")
def KeyDown(self,event):
if IsKeyMenuOrB(event.key):
self.ReturnToUpLevelPage()
self._Screen.Draw()
self._Screen.SwapAndShow()
if IsKeyStartOrA(event.key):
self.SnapMsg(MyLangManager.Tr("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 WifiInfoPage(Page):
_FootMsg = ["Nav","","","Back",""]
_MyList = []
_ListFontObj = MyLangManager.TrFont("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"] = MyLangManager.TrFont("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 = InfoPageSelector()
ps._Parent = self
ps._PosX = 2
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 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[2] = "Disconnect"
else:
self._FootMsg[2] = ""
self.GenList()
def OnReturnBackCb(self):
self.ReturnToUpLevelPage()
self._Screen.Draw()
self._Screen.SwapAndShow()
def KeyDown(self,event):
if IsKeyMenuOrB(event.key):
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 IsKeyStartOrA(event.key):
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 = MySkinManager.GiveColor('Line')
def __init__(self):
pass
def AnimateDraw(self,x2,y2):
pass
def Draw(self):
idx = self._Parent._PsIndex
if idx < len( self._Parent._MyList):
x = self._Parent._MyList[idx]._PosX+11
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,h),self._BackgroundColor,4,0,self._BackgroundColor)
pygame.draw.rect(self._Parent._CanvasHWND,self._BackgroundColor,(x,y,self._Width,h),0)
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,MySkinManager.GiveColor('White'),(x-padding,y-padding, w+padding*2,h+padding*2))
pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),(x-padding,y-padding, w+padding*2,h+padding*2),1)
self._CanvasHWND.blit(my_text,(x,y,w,h))
class WifiList(Page):
_MyList = []
#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","Info","Scan","Back","Enter"]
_EncMethods = None
_Scroller = None
_ListFontObj = MyLangManager.TrFont("notosanscjk15")
_InfoPage = None
_CurBssid = ""
def __init__(self):
Page.__init__(self)
self._MyList = []
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._MyList = []
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._MyList.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(MyLangManager.Tr("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._MyList):
self._MyList[_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):
if self._Screen._CurrentPage != self:
return
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
for i,v in enumerate(self._MyList):
if v._Bssid == self._CurBssid:
netid = i
break
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.ShowBox(MyLangManager.Tr("Connecting"))
self._MyList[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 AbortedAndReturnToUpLevel(self):
self.HideBox()
self._Screen._FootBar.ResetNavText()
self.ReturnToUpLevelPage()
self._Screen.Draw()
self._Screen.SwapAndShow()
def OnKbdReturnBackCb(self):
password_inputed = "".join(myvars.PasswordPage._Textarea._MyWords)
if is_wifi_connected_now() == False:
self.ConfigWireless(password_inputed)
def OnReturnBackCb(self):
pass
def KeyDown(self,event):
# if self._BlockingUI == True:
# print("UI blocking ...")
# return
if IsKeyMenuOrB(event.key):
if self._Wireless != None:
wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
if wireless_connecting:
self.ShutDownConnecting()
self.ShowBox(MyLangManager.Tr("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 IsKeyStartOrA(event.key): ## enter to set password,enter is B on GM
if len(self._MyList) == 0:
return
self._CurBssid = self._MyList[self._PsIndex]._Bssid
wicd_wirelss_encrypt_pwd = self.GetWirelessEncrypt(self._PsIndex)
if self._MyList[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(str(i["preshared_key"])) > 0:
thepass = str(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._MyList) == 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(" ",MyLangManager.TrFont("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 = MyLangManager.Tr("Wifi info")
self._InfoPage.Init()
def Draw(self):
self.ClearCanvas()
if len(self._MyList) == 0:
return
self._Ps.Draw()
for i in self._MyList:
i.Draw()
self._Scroller.UpdateSize( len(self._MyList)*NetItem._Height, self._PsIndex*NetItem._Height)
self._Scroller.Draw()