launcher deot

Menu/GameShell/10_Settings/.Airplane.deot/__init__.py

@@ -0,0 +1,285 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+#import math
+import  commands
+
+#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,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multi_icon_item import MultiIconItem
+from UI.lang_manager import MyLangManager
+from UI.skin_manager import MySkinManager
+from UI.multilabel import MultiLabel
+
+class AirplanePage(Page):
+    _FootMsg =  ["Nav","","Rescue","Back","Toggle"]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+
+    _EasingDur = 30
+
+    _airwire_y = 0
+    _dialog_index = 0
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+
+        """
+        airwire = IconItem()
+        airwire._ImgSurf = MyIconPool._Icons["airwire"]
+        airwire._MyType = ICON_TYPES["STAT"]
+        airwire._Parent = self
+        airwire.Adjust(0,0,5,43,0)
+        self._Icons["airwire"] = airwire
+
+        GS = IconItem()
+        GS._ImgSurf = MyIconPool._Icons["GS"]
+        GS._MyType = ICON_TYPES["STAT"]
+        GS._Parent = self
+        GS.Adjust(0,0,72,95,0)
+        self._Icons["GS"] = GS
+        """
+
+        DialogBoxs = MultiIconItem()
+        DialogBoxs._ImgSurf = MyIconPool._Icons["DialogBoxs"]
+        DialogBoxs._MyType = ICON_TYPES["STAT"]
+        DialogBoxs._Parent = self
+        DialogBoxs._IconWidth = 180
+        DialogBoxs._IconHeight = 80
+        DialogBoxs.Adjust(0,0,180,320,0)
+        self._Icons["DialogBoxs"] = DialogBoxs
+
+        
+        """
+        bgpng = MultiIconItem()
+        bgpng._ImgSurf = MyIconPool._Icons["about_bg"]
+        bgpng._MyType = ICON_TYPES["STAT"]
+        bgpng._Parent = self
+        bgpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+        self._Icons["bg"] = bgpng
+        """
+        
+        
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+        
+        self.OnLoadCb()
+        
+    def ScrollDown(self):
+        dis = 10
+        if abs(self._Scrolled) <  (self._BGheight - self._Height)/2 + 0:
+            self._PosY -= dis
+            self._Scrolled -= dis
+        
+    def ScrollUp(self):
+        dis = 10
+        if self._PosY < 0:
+            self._PosY += dis
+            self._Scrolled += dis
+
+    def ToggleModeAni(self): ## with animation
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        if "yes" in out[1]:
+            data = self.EasingData(0,43)
+            for _,v in enumerate(data):
+                self._airwire_y -= v
+                self._dialog_index = 2
+                pygame.time.delay(40)
+
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+                
+            commands.getstatusoutput("sudo rfkill unblock all")
+            self._Screen._TitleBar._InAirPlaneMode = False
+
+        else:
+            data = self.EasingData(0,43)
+            data.reverse()
+            for _,v in enumerate(data):
+                self._airwire_y += v
+                self._dialog_index = 3
+                pygame.time.delay(40)
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+
+            commands.getstatusoutput("sudo rfkill block all")
+            self._Screen._TitleBar._InAirPlaneMode = True
+
+        
+    def ToggleMode(self):
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        print out
+        if "yes" in out[1]:
+            self._Screen._MsgBox.SetText("TurningOn")
+            self._Screen._MsgBox.Draw()
+            commands.getstatusoutput("sudo rfkill unblock all")
+            self._Screen._TitleBar._InAirPlaneMode = False
+        
+        else:
+            self._Screen._MsgBox.SetText("TurningOff")
+            self._Screen._MsgBox.Draw()
+            commands.getstatusoutput("sudo rfkill block all")
+            self._Screen._TitleBar._InAirPlaneMode = True
+    
+    def UnBlockAll(self):
+        self._Screen._MsgBox.SetText("TurningOn")
+        self._Screen._MsgBox.Draw()
+        commands.getstatusoutput("sudo rfkill unblock all")
+        self._Screen._TitleBar._InAirPlaneMode = False
+    
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        if "yes" in out[1]:
+            self._Screen._TitleBar._InAirPlaneMode = True
+            self._airwire_y = 50+43
+            self._dialog_index = 1
+        else:
+            self._airwire_y = 50
+            self._dialog_index = 0
+            self._Screen._TitleBar._InAirPlaneMode = False
+        
+        
+    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 IsKeyStartOrA(event.key):
+            self.ToggleModeAni()
+            """
+            self.ToggleMode()
+            self._Screen.SwapAndShow()
+            
+            pygame.time.delay(1000)
+            
+            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["X"]:
+            self.UnBlockAll()
+            self._Screen.SwapAndShow()
+            pygame.time.delay(1000)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow() 
+        
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        self._Icons["DialogBoxs"].NewCoord(70,58)        
+        #self._Icons["airwire"].NewCoord(80,self._airwire_y)
+        
+        self._Icons["DialogBoxs"]._IconIndex = self._dialog_index
+        
+        self._Icons["DialogBoxs"].DrawTopLeft()
+        #self._Icons["airwire"].Draw()
+
+        #self._Icons["GS"].NewCoord(98,118)
+        #self._Icons["GS"].Draw()
+
+        self.DrawCross(10,10)
+        self.DrawCross(self._Screen._Width-20,10)
+        self.DrawCross(10,self._Screen._Height-20)
+        self.DrawCross(self._Screen._Width-20,self._Screen._Height-20)
+        
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+#            self._Scroller.UpdateSize(self._BGheight,abs(self._Scrolled)*3)
+#            self._Scroller.Draw()
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = AirplanePage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Airplane Mode"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

Menu/GameShell/10_Settings/.Brightness.stock/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*- 
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitBrightnessPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.BrightnessPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+        

Menu/GameShell/10_Settings/.Brightness.stock/brightness_page.py

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+
+#import math
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from UI.slider     import Slider
+from UI.icon_pool  import MyIconPool
+from UI.multi_icon_item import MultiIconItem
+from config import BackLight
+import myvars
+
+class BSlider(Slider):
+
+    
+    OnChangeCB = None
+    _BGpng = None
+    _BGwidth = 179
+    _BGheight = 153
+
+    _NeedleSurf = None
+    _Scale      = None
+    _Parent     = None
+    _Icons      = {}
+    
+    def __init__(self):
+        Slider.__init__(self)
+        self._Icons = {}
+    def Init(self):
+        self._Width = self._Parent._Width
+        self._Height = self._Parent._Height
+        
+        bgpng = IconItem()
+        bgpng._ImgSurf = MyIconPool.GiveIconSurface("light")
+        bgpng._MyType = ICON_TYPES["STAT"]
+        bgpng._Parent = self
+        bgpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+        self._Icons["bg"] = bgpng
+        ##self._NeedleSurf = pygame.Surface( (38,12),pygame.SRCALPHA )
+        
+        scale = MultiIconItem()
+        scale._MyType = ICON_TYPES["STAT"]
+        scale._Parent = self
+        scale._ImgSurf = MyIconPool.GiveIconSurface("scale")
+        scale._IconWidth = 82
+        scale._IconHeight = 63
+        scale.Adjust(0,0,82,63,0)
+        self._Icons["scale"] = scale
+
+    def SetValue(self,brt):
+        self._Value = brt
+        
+    def Further(self):
+        self._Value+=1
+        if self._Value > 9:
+            self._Value = 9
+            
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB(self._Value)
+                    
+    def StepBack(self):
+        self._Value-=1
+
+        if self._Value < 1:
+            self._Value = 1
+
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB(self._Value)
+    
+    def Draw(self):
+
+        self._Icons["bg"].NewCoord(self._Width/2,self._Height/2 +11 )
+        self._Icons["bg"].Draw()
+
+        self._Icons["scale"].NewCoord(self._Width/2,self._Height/2 )
+
+        icon_idx = self._Value - 1
+        if icon_idx < 0:
+            icon_idx = 0
+        
+        self._Icons["scale"]._IconIndex = icon_idx
+        self._Icons["scale"].Draw()
+        """
+        pygame.draw.line(self._CanvasHWND,(255,0,0), (posx,self._PosY),(self._Width,self._PosY),3) ## range line
+        pygame.draw.line(self._CanvasHWND,(0,0,255), (self._PosX,self._PosY),(posx,self._PosY),3) ## range line
+        
+        pygame.draw.circle(self._CanvasHWND,(255,255,255),( posx, self._PosY),7,0)        
+        pygame.draw.circle(self._CanvasHWND,(0,0,0)      ,( posx, self._PosY),7,1)## outer border
+        """
+        
+        
+        
+class BrightnessPage(Page):
+
+    _MySlider = None
+    _FootMsg = ["Nav","","","Back","Enter"]
+
+    
+    def Init(self):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._MySlider = BSlider()
+#        self._MySlider._Width = Width - 20
+#        self._MySlider._Height = 30
+#        self._MySlider._PosX  = (self._Width - self._MySlider._Width)/2
+#        self._MySlider._PosY  = 40
+        self._MySlider._Parent = self
+        self._MySlider.SetCanvasHWND(self._CanvasHWND)
+        self._MySlider.OnChangeCB = self.WhenSliderDrag
+        self._MySlider.Init()
+
+        brt  = self.ReadBackLight()
+        
+        self._MySlider.SetValue( brt)
+
+    
+    def ReadBackLight(self):
+        try:
+            f = open(BackLight)
+        except IOError:
+            return 0
+        else:
+            with f:
+                content = f.readlines()
+                content = [x.strip() for x in content]
+                return int(content[0])
+
+        return 0
+
+    def OnLoadCb(self):
+         brt  = self.ReadBackLight()
+         
+         self._MySlider.SetValue( brt)
+         
+    def SetBackLight(self,newbrt):
+        try:
+            f = open(BackLight,'w')
+        except IOError:
+            print("Open write %s failed %d" % (BackLight,newbrt))
+            return False
+        else:
+            with f:
+                f.write(str(newbrt))
+                return True
+        
+    def WhenSliderDrag(self,value): ##value 
+        self.SetBackLight(value)
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Right"]:
+            self._MySlider.Further()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self._MySlider.StepBack()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._MySlider.Draw()
+
+        
+
+
+    

Menu/GameShell/10_Settings/.Brightness.stock/myvars.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import sys
+
+SoundPage = None

Menu/GameShell/10_Settings/.Brightness.stock/pages.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from brightness_page import BrightnessPage
+
+import myvars
+
+def InitBrightnessPage(main_screen):
+
+    myvars.BrightnessPage = BrightnessPage()
+    
+    myvars.BrightnessPage._Screen = main_screen
+    myvars.BrightnessPage._Name = "Brightness"
+    myvars.BrightnessPage.Init()

Menu/GameShell/10_Settings/.LauncherGo.stock/__init__.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+#import math
+#mport subprocess
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.keys_def     import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.util_funcs import ArmSystem
+from UI.lang_manager import MyLangManager
+from UI.confirm_page import ConfirmPage
+
+class SwitchToLauncherGoConfirmPage(ConfirmPage):
+            
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if IsKeyStartOrA(event.key):
+            self._Screen._MsgBox.SetText("Rebooting to LauncherGo")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            pygame.time.delay(300)
+            ArmSystem("sed -i s/launcher/launchergo/g ~/.bashrc" )
+            ArmSystem("sudo reboot")  
+            
+            
+class APIOBJ(object):
+
+    _Page = None
+    
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = SwitchToLauncherGoConfirmPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Switch To LauncherGo"
+        self._Page.Init()    
+
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()        
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)

Menu/GameShell/10_Settings/.Sound.stock/__init__.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*- 
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitSoundPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.SoundPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+        

Menu/GameShell/10_Settings/.Sound.stock/myvars.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import sys
+
+SoundPage = None

Menu/GameShell/10_Settings/.Sound.stock/pages.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from sound_page import SoundPage
+
+import myvars
+
+def InitSoundPage(main_screen):
+
+    myvars.SoundPage = SoundPage()
+
+    myvars.SoundPage._Screen = main_screen
+    myvars.SoundPage._Name = "Sound Volume"
+    myvars.SoundPage.Init()

Menu/GameShell/10_Settings/.Sound.stock/sound_page.py

@@ -0,0 +1,170 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+#from libs.roundrects import aa_round_rect
+
+import alsaaudio
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.icon_item import IconItem
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from UI.slider     import Slider
+from UI.multi_icon_item import MultiIconItem
+
+
+from UI.icon_pool  import MyIconPool
+
+import myvars
+
+class SoundSlider(Slider):
+    OnChangeCB = None
+    
+    _BGpng = None
+    _BGwidth = 192
+    _BGheight = 173
+
+    _NeedleSurf = None
+    _Scale      = None
+    _Parent     = None
+    
+    snd_segs = [ [0,20],[21,40],[41,50],[51,60],[61,70],[71,85],[86,90],[91,95],[96,100] ]
+
+    
+    def __init__(self):
+        Slider.__init__(self)
+        
+    def Init(self):
+        self._Width = self._Parent._Width
+        self._Height = self._Parent._Height
+        
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("vol")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+        ##self._NeedleSurf = pygame.Surface( (38,12),pygame.SRCALPHA )
+        
+        self._Scale = MultiIconItem()
+        self._Scale._MyType = ICON_TYPES["STAT"]
+        self._Scale._Parent = self
+        self._Scale._ImgSurf = MyIconPool.GiveIconSurface("scale")
+        self._Scale._IconWidth = 82
+        self._Scale._IconHeight = 63
+        self._Scale.Adjust(0,0,82,63,0)
+        
+    def SetValue(self,vol):#pct 0-100
+        for i,v in enumerate(self.snd_segs):
+            if vol  >= v[0] and vol <= v[1]:
+                self._Value = i # self._Value :  0 - 8
+                break
+        
+    def Further(self):
+        self._Value+=1
+
+        if self._Value > len(self.snd_segs)-1:
+            self._Value = len(self.snd_segs) -1
+
+        vol = self.snd_segs[self._Value][0] + (self.snd_segs[self._Value][1] - self.snd_segs[self._Value][0])/2 
+        
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB( vol )
+        
+    def StepBack(self):
+        self._Value-=1
+
+        if self._Value < 0:
+            self._Value = 0
+
+        vol = self.snd_segs[self._Value][0] + (self.snd_segs[self._Value][1] - self.snd_segs[self._Value][0])/2 
+        
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB( vol )
+    
+    def Draw(self):
+        
+        self._BGpng.NewCoord(self._Width/2,self._Height/2 )
+        self._BGpng.Draw()
+
+        self._Scale.NewCoord(self._Width/2,self._Height/2)
+
+        self._Scale._IconIndex = self._Value
+        
+        self._Scale.Draw()
+        
+        
+        
+class SoundPage(Page):
+
+    _MySlider = None
+    _FootMsg = ["Nav","","","Back","Enter"]
+
+    def Init(self):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._MySlider = SoundSlider()
+
+        self._MySlider._Parent = self        
+        self._MySlider.SetCanvasHWND(self._CanvasHWND)
+
+        self._MySlider.OnChangeCB = self.WhenSliderDrag
+
+        self._MySlider.Init()
+        
+        try:
+            m = alsaaudio.Mixer()
+            self._MySlider.SetValue(m.getvolume()[0])
+        except Exception,e:
+            print(str(e))
+            self._MySlider.SetValue(0)
+
+
+    def OnLoadCb(self):
+        try:
+            m = alsaaudio.Mixer()
+            self._MySlider.SetValue(m.getvolume()[0])
+        except Exception,e:
+            print(str(e))
+                
+    def WhenSliderDrag(self,value): ##value 0-100
+        if value < 0 or value > 100:
+            return
+        
+        m = alsaaudio.Mixer()
+        m.setvolume(int(value))
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Right"]:
+            self._MySlider.Further()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self._MySlider.StepBack()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._MySlider.Draw()
+
+        
+
+
+    

Menu/GameShell/10_Settings/.Storage.deot/__init__.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+import os
+
+
+## local UI import
+from UI.page  import Page
+from UI.skin_manager import MySkinManager
+from UI.constants import ICON_TYPES,Width,Height
+from UI.icon_item import IconItem
+from UI.icon_pool import MyIconPool
+from UI.label  import Label
+from UI.util_funcs import midRect
+
+class StoragePage(Page):
+
+    _Icons = {}
+    _BGpng  = None
+    _BGwidth = 96
+    _BGheight = 73
+    _BGlabel  = None
+    _FreeLabel = None
+    
+    _GBmsg    = "%.1fGB of %.1fGB Used"
+    _DskUsg   = None
+
+    _TextColor = MySkinManager.GiveColor('Text')
+    _FootMsg    = ["Nav.","","","Back",""]
+    
+    def __init__(self):
+        Page.__init__(self)
+        
+        self._Icons = {}
+
+
+    def DiskUsage(self):
+        statvfs = os.statvfs('/')
+
+        total_space = (statvfs.f_frsize * statvfs.f_blocks)/1024.0/1024.0/1024.0
+
+        avail_space = ( statvfs.f_frsize * statvfs.f_bavail) / 1024.0 / 1024.0/ 1024.0
+
+        return avail_space,total_space
+        
+    def Init(self):
+
+        self._DskUsg = self.DiskUsage()
+        
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._GBLabel = Label()
+        self._GBLabel.SetCanvasHWND(self._CanvasHWND)
+        self._GBLabel.Init(self._GBmsg % (self._DskUsg[1]-self._DskUsg[0], self._DskUsg[1]),MySkinManager.GiveFont("varela11") )
+        self._GBLabel.SetColor(self._TextColor)
+        
+        self._PctLabel = Label()
+        self._PctLabel.SetCanvasHWND(self._CanvasHWND)
+
+        usage_percent = (self._DskUsg[0]/self._DskUsg[1] )*100.0
+        
+        
+        self._PctLabel.Init("%d%%"% int(usage_percent),MySkinManager.GiveFont("EurostileBold30"))
+        self._PctLabel.SetColor( self._TextColor )
+        
+        self._FreeLabel = Label()
+        self._FreeLabel.SetCanvasHWND(self._CanvasHWND)
+        self._FreeLabel.Init("FREE",MySkinManager.GiveFont("varela12"))
+        self._FreeLabel.SetColor(self._PctLabel._Color)
+
+        
+    def OnLoadCb(self):
+        pass
+    
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._PctLabel.NewCoord(32,102- 33)
+        self._PctLabel.Draw()
+
+        self._FreeLabel.NewCoord(33   ,130-25)
+        self._FreeLabel.Draw()
+
+        self._GBLabel.NewCoord(145,103-29)
+        self._GBLabel.Draw()
+        
+        #bgcolor = (238,238,238), fgcolor = (126,206,244)
+
+        usage_percent = (self._DskUsg[0]/self._DskUsg[1] )
+        if usage_percent < 0.1:
+            usage_percent = 0.1
+
+        rect_ = pygame.Rect(144,118-25, 283-144,139-117)
+
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'), rect_, 1)
+
+        
+        rect2 = pygame.Rect(144,118-25,int((283-144)*(1.0-usage_percent)),139-117)
+
+        rect2.left = rect_.left
+        rect2.top  = rect_.top
+        
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),rect2, 0)   
+        
+        sep_rect = pygame.Rect(129,99-25,2,42)
+        
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Inactive'),sep_rect, 0)   
+        
+        ##4 cross
+        self.DrawCross(10,10)
+        self.DrawCross(self._Screen._Width-20,10)
+        self.DrawCross(10,self._Screen._Height-20)
+        self.DrawCross(self._Screen._Width-20,self._Screen._Height-20)
+        
+        
+class APIOBJ(object):
+
+    _StoragePage = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._StoragePage = StoragePage()
+
+        self._StoragePage._Screen = main_screen
+        self._StoragePage._Name ="Storage"
+        self._StoragePage.Init()
+        
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._StoragePage)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+    
+
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

Menu/GameShell/10_Settings/.list_page.py.stock

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+import sys
+
+from libs.roundrects import aa_round_rect
+
+## 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,FileExists
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+from UI.info_page_selector import InfoPageSelector
+
+from list_item  import ListItem
+
+import myvars
+
+class ListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    
+    _FootMsg = ["Nav","","","Back","Enter"]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela15")
+
+    _Scroller = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = InfoPageSelector()
+        ps._Parent = self
+        ps._PosX = 2
+        self._Ps = ps
+        self._PsIndex = 0
+        
+        #                ""   pkgname, label
+        alist         = [["","Airplane","Airplane Mode"],
+                         ["","PowerOptions","Power Options"],
+                         ["","Wifi","Wi-Fi"],
+                         ["","Bluetooth","Bluetooth"],
+                         ["","Sound","Sound  Volume"],
+                         ["","Brightness","BackLight Brightness"],
+                         ["","Storage",""],
+                         ["","Time","Timezone"],
+                         ["","Languages","Languages"],
+                         ["","Notification","Notification"],
+                         ["","Update", "Update Launcher"],
+                         ["","Cores", "Retroarch cores manager"],
+                         ["","About",  "About"],
+                         ["","PowerOFF","Power OFF"],
+                         ["","ButtonsLayout","Buttons Layout"],
+                         ["","Skins","Theme Manager"],
+                         #["","LauncherGo","Switch to LauncherGo"],
+                         ["","Lima","GPU Driver Switch"],
+                         ["","GateWay","Network Gateway Switch"]]
+
+        start_x  = 0
+        start_y  = 0
+
+        
+        sys.path.append(myvars.basepath)# add self as import path
+        for i,v in enumerate(alist):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFontObj
+
+            if v[2] != "":
+                li.Init(v[2])
+            else:
+                li.Init(v[1])
+            
+            #if v[1] == "Wifi" or v[1] == "Sound" or v[1] == "Brightness" or v[1] == "Storage" or v[1] == "Update" or v[1] == "About" or v[1] == "PowerOFF" or v[1] == "HelloWorld":
+            if FileExists(myvars.basepath+"/"+ v[1]):
+                li._LinkObj = __import__(v[1])
+                init_cb   = getattr(li._LinkObj,"Init",None)
+                if init_cb != None:
+                    if callable(init_cb):
+                        li._LinkObj.Init(self._Screen)
+                
+                self._MyList.append(li)
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+
+    def Click(self):
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._LinkObj != None:
+            api_cb = getattr(cur_li._LinkObj,"API",None)
+            if api_cb != None:
+                if callable(api_cb):
+                    cur_li._LinkObj.API(self._Screen)
+
+        
+    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()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) * ListItem._Height > self._Height:
+            self._Ps._Width = self._Width - 11
+            
+            self._Ps.Draw()
+            
+            for i in self._MyList:
+                i.Draw()
+        
+            self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+            self._Scroller.Draw()
+        else:
+            self._Ps._Width = self._Width
+            self._Ps.Draw()
+            for i in self._MyList:
+                i.Draw()
+
+            

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

@@ -0,0 +1,398 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+#import math
+import subprocess
+
+#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,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.multi_icon_item  import MultiIconItem
+from UI.multilabel import MultiLabel
+from UI.lang_manager import MyLangManager
+from UI.skin_manager import MySkinManager
+
+from config import VERSION
+
+class InfoPageListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 20
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+    
+    def __init__(self):
+        self._Labels = {}
+        self._Icons  = {}
+        self._Fonts  = {}
+
+    def SetSmallText(self,text):
+        
+        l = MultiLabel()
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+        l.Init(text,self._Fonts["small"])
+        
+        self._Labels["Small"] = l
+
+        #if self._Labels["Small"]._Width > self._Width:
+        #    self._Width = self._Labels["Small"]._Width
+        if self._Labels["Small"]._Height >= self._Height:
+            self._Height = self._Labels["Small"]._Height+10
+        
+    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._Labels["Text"].Draw()
+
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Labels["Text"]._Width + 16 
+            self._Labels["Small"]._PosY = self._PosY 
+            self._Labels["Small"].Draw()
+        
+        
+    
+
+class AboutPage(Page):
+    _FootMsg =  ["Nav.","","","Back",""]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 300
+
+    _DrawOnce = False
+    _Scroller = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def Uname(self):
+        
+        out = {}
+        out["key"]="uname"
+        out["label"]= "Kernel:"
+        st = subprocess.check_output(["uname","-srmo"])
+        st = st.strip("\n")
+        st = st.strip("\t")
+        out["value"] = st
+        self._AList["uname"] = out
+
+        return
+    
+    def CpuMhz(self):
+
+        try:
+            with open("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq") as f:
+                content = f.readlines()
+            content = [x.strip() for x in content]
+            
+        except:
+            print("open %s failed" % "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq")
+            content = ["0"]
+        
+        mhz = int(content[0]) / 1000.0
+
+        cpuscalemhz = {}
+        cpuscalemhz["key"] = "cpuscalemhz"
+        cpuscalemhz["label"] = "CPU Mhz:"
+        cpuscalemhz["value"] = str(mhz)
+        self._AList["cpuscalemhz"] = cpuscalemhz
+        
+        return 
+    
+    def CpuInfo(self):
+        last_processor = 0
+        with open("/proc/cpuinfo") as f:
+            for line in f:
+                if line.startswith("processor"):
+                    parts = line.split(":")
+                    cur_processor_number = int( parts[1].strip())
+                    if cur_processor_number > last_processor:
+                        last_processor = cur_processor_number
+                    
+                if line.startswith("model name"):
+                    parts = line.split(":")
+#                    print( parts[1].strip() )
+                    processor = {}
+                    processor["key"]="processor"
+                    processor["label"] = "Processor:"
+                    processor["value"] = parts[1].strip()
+                    
+                    self._AList["processor"] = processor
+                    
+                if line.startswith("cpu MHz"):
+                    parts = line.split(":")
+#                    print(parts[1].strip() )
+                    cpumhz = {}
+                    cpumhz["key"] = "cpumhz"
+                    cpumhz["label"] = "CPU MHz:"
+                    cpumhz["value"] = parts[1].strip()
+
+                    self._AList["cpumhz"] = cpumhz
+                if line.startswith("cpu cores"):
+                    parts = line.split(":")
+#                    print(parts[1].strip() )
+                    cpucores = {}
+                    cpucores["key"] = "cpucores"
+                    cpucores["label"] = "CPU cores:"
+                    cpucores["value"] = parts[1].strip()
+                    self._AList["cpucores"] = cpucores
+                if line.startswith("Features"):
+                    parts = line.split(":")
+#                    print(parts[1].strip() )
+                    f_ = {}
+                    f_["key"] = "features"
+                    f_["label"] = "Features:"
+                    f_["value"] = parts[1].strip()
+                    self._AList["features"] = f_
+                    
+                if line.startswith("flags"):
+                    parts = line.split(":")
+#                    print(parts[1].strip() )
+                    flags = {}
+                    flags["key"] = "flags"
+                    flags["label"] = "Flags:"
+                    flags["value"] = parts[1].strip()
+                    self._AList["flags"] = flags
+                    
+
+        if last_processor > 0:
+            arm_cores = {}
+            arm_cores["key"]= "armcores"
+            arm_cores["label"] = "CPU cores:"
+            arm_cores["value"] = str(last_processor + 1)
+            self._AList["armcores"] = arm_cores
+        
+    def MemInfo(self):
+
+        with open("/proc/meminfo") as f:
+            for line in f:
+                if line.startswith("MemTotal"):
+                    parts = line.split(":")
+                    parts[1] = parts[1].replace("kB","")
+                    print(   parts[1].strip() )
+
+                    memory = {}
+                    memory["key"] = "memory"
+                    memory["label"] = "Memory:"
+                    memory["value"] = str( int(parts[1].strip())/1000.0) +" MB"
+                    self._AList["memory"] = memory                    
+                    break
+                    
+    def LauncherVersion(self):
+        launcher_version = {}
+        launcher_version["key"] = "launcher_ver"
+        launcher_version["label"] = "Launcher:"
+        launcher_version["value"] = VERSION
+        self._AList["launcher_ver"] = launcher_version
+    
+    def OsImageVersion(self):
+        if FileExists("/etc/clockworkpi_os_image_version"):
+            try:
+                with open("/etc/clockworkpi_os_image_version") as f:
+                    content = f.readlines()
+                content = [x.strip() for x in content]
+            
+            except:
+                print("open %s failed" % "/etc/clockworkpi_os_image_version")
+                content = None
+            
+            if content != None and len(content) > 0:
+                os_image_ver = {}
+                os_image_ver["key"] = "os_image_ver"
+                os_image_ver["label"] = "OS Image:"
+                os_image_ver["value"] = content[0][:12]
+                self._AList["os_image_ver"] = os_image_ver
+    
+    def GenList(self):
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 10
+        last_height = 0
+
+        for i,u in enumerate( ["processor","armcores","cpuscalemhz","features","memory","uname","launcher_ver","os_image_ver"] ):
+        #for i,u in enumerate( ["processor","cpucores","cpumhz","flags","memory","uname"] ):
+            if u not in self._AList:
+                continue
+            
+            v = self._AList[u]
+            
+            li = InfoPageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFontObj
+            li._Fonts["small"] = MySkinManager.GiveFont("varela12")
+            
+            if self._AList[u]["label"] != "":
+                li.Init(  self._AList[u]["label"] )
+            else:
+                li.Init( self._AList[u]["key"] )
+
+            li._Flag = self._AList[u]["key"]
+
+            li.SetSmallText( self._AList[u]["value"] )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight+50) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        bgpng = MultiIconItem()
+        bgpng._ImgSurf = MyIconPool.GiveIconSurface("about_bg")
+        bgpng._MyType = ICON_TYPES["STAT"]
+        bgpng._Parent = self
+        bgpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+        self._Icons["bg"] = bgpng
+        
+        self.CpuInfo()
+        self.MemInfo()
+        self.CpuMhz()
+        self.Uname()
+        
+        self.LauncherVersion()
+        self.OsImageVersion()
+        
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+        
+    def ScrollDown(self):
+        dis = 10
+        if abs(self._Scrolled) <  (self._BGheight - self._Height)/2 + 100:
+            self._PosY -= dis
+            self._Scrolled -= dis
+        
+    def ScrollUp(self):
+        dis = 10
+        if self._PosY < 0:
+            self._PosY += dis
+            self._Scrolled += dis
+
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+
+    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()
+        
+                                
+    def Draw(self):
+
+        if self._DrawOnce == False:
+            self.ClearCanvas()
+            #self._Ps.Draw()
+        
+            for i in self._MyList:
+                i.Draw()
+                
+            self._DrawOnce = True
+            
+            self._Icons["bg"].DrawRect((230,0,82,184),(228,0,82,184))
+            
+            y = self._MyList[len(self._MyList)-1]._PosY+30
+            
+            self._Icons["bg"].DrawRect(( (self._Width-191)/2,y,191,68),(65,232,191,68))
+            
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+            self._Scroller.UpdateSize(self._BGheight,abs(self._Scrolled)*3)
+            self._Scroller.Draw()
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = AboutPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="About"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+#import math
+import  commands
+
+#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,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multi_icon_item import MultiIconItem
+from UI.lang_manager import MyLangManager
+
+from UI.multilabel import MultiLabel
+
+class AirplanePage(Page):
+    _FootMsg =  ["Nav","","Rescue","Back","Toggle"]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+
+    _EasingDur = 30
+
+    _airwire_y = 0
+    _dialog_index = 0
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+
+
+        airwire = IconItem()
+        airwire._ImgSurf = MyIconPool.GiveIconSurface("airwire")
+        airwire._MyType = ICON_TYPES["STAT"]
+        airwire._Parent = self
+        airwire.Adjust(0,0,5,43,0)
+        self._Icons["airwire"] = airwire
+
+        GS = IconItem()
+        GS._ImgSurf = MyIconPool.GiveIconSurface("GS")
+        GS._MyType = ICON_TYPES["STAT"]
+        GS._Parent = self
+        GS.Adjust(0,0,72,95,0)
+        self._Icons["GS"] = GS
+
+        DialogBoxs = MultiIconItem()
+        DialogBoxs._ImgSurf = MyIconPool.GiveIconSurface("DialogBoxs")
+        DialogBoxs._MyType = ICON_TYPES["STAT"]
+        DialogBoxs._Parent = self
+        DialogBoxs._IconWidth = 134
+        DialogBoxs._IconHeight = 93
+        DialogBoxs.Adjust(0,0,134,372,0)
+        self._Icons["DialogBoxs"] = DialogBoxs
+
+        
+        """
+        bgpng = MultiIconItem()
+        bgpng._ImgSurf = MyIconPool.GiveIconSurface("about_bg")
+        bgpng._MyType = ICON_TYPES["STAT"]
+        bgpng._Parent = self
+        bgpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+        self._Icons["bg"] = bgpng
+        """
+        
+        
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+        
+        self.OnLoadCb()
+        
+    def ScrollDown(self):
+        dis = 10
+        if abs(self._Scrolled) <  (self._BGheight - self._Height)/2 + 0:
+            self._PosY -= dis
+            self._Scrolled -= dis
+        
+    def ScrollUp(self):
+        dis = 10
+        if self._PosY < 0:
+            self._PosY += dis
+            self._Scrolled += dis
+
+    def ToggleModeAni(self): ## with animation
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        if "yes" in out[1]:
+            data = self.EasingData(0,43)
+            for _,v in enumerate(data):
+                self._airwire_y -= v
+                self._dialog_index = 2
+                pygame.time.delay(40)
+
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+                
+            commands.getstatusoutput("sudo rfkill unblock all")
+            self._Screen._TitleBar._InAirPlaneMode = False
+
+        else:
+            data = self.EasingData(0,43)
+            data.reverse()
+            for _,v in enumerate(data):
+                self._airwire_y += v
+                self._dialog_index = 3
+                pygame.time.delay(40)
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+
+            commands.getstatusoutput("sudo rfkill block all")
+            self._Screen._TitleBar._InAirPlaneMode = True
+
+        
+    def ToggleMode(self):
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        print out
+        if "yes" in out[1]:
+            self._Screen._MsgBox.SetText("TurningOn")
+            self._Screen._MsgBox.Draw()
+            commands.getstatusoutput("sudo rfkill unblock all")
+            self._Screen._TitleBar._InAirPlaneMode = False
+        
+        else:
+            self._Screen._MsgBox.SetText("TurningOff")
+            self._Screen._MsgBox.Draw()
+            commands.getstatusoutput("sudo rfkill block all")
+            self._Screen._TitleBar._InAirPlaneMode = True
+    
+    def UnBlockAll(self):
+        self._Screen._MsgBox.SetText("TurningOn")
+        self._Screen._MsgBox.Draw()
+        commands.getstatusoutput("sudo rfkill unblock all")
+        self._Screen._TitleBar._InAirPlaneMode = False
+    
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
+        if "yes" in out[1]:
+            self._Screen._TitleBar._InAirPlaneMode = True
+            self._airwire_y = 50+43
+            self._dialog_index = 1
+        else:
+            self._airwire_y = 50
+            self._dialog_index = 0
+            self._Screen._TitleBar._InAirPlaneMode = False
+        
+        
+    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 IsKeyStartOrA(event.key):
+            self.ToggleModeAni()
+            """
+            self.ToggleMode()
+            self._Screen.SwapAndShow()
+            
+            pygame.time.delay(1000)
+            
+            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["X"]:
+            self.UnBlockAll()
+            self._Screen.SwapAndShow()
+            pygame.time.delay(1000)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow() 
+        
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        self._Icons["DialogBoxs"].NewCoord(145,23)        
+        self._Icons["airwire"].NewCoord(80,self._airwire_y)
+        
+        self._Icons["DialogBoxs"]._IconIndex = self._dialog_index
+        
+        self._Icons["DialogBoxs"].DrawTopLeft()
+        self._Icons["airwire"].Draw()
+
+        self._Icons["GS"].NewCoord(98,118)
+        self._Icons["GS"].Draw()
+        
+        if self._HWND != None:
+            self._HWND.fill((255,255,255))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+#            self._Scroller.UpdateSize(self._BGheight,abs(self._Scrolled)*3)
+#            self._Scroller.Draw()
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = AirplanePage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Airplane Mode"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,813 @@
+# -*- coding: utf-8 -*- 
+import re
+import pygame
+#import math
+import  commands
+import dbus
+from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+from libs.DBUS import  bus, adapter,devices
+
+#import gobject
+#from wicd import misc 
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multi_icon_item import MultiIconItem
+from UI.skin_manager import MySkinManager
+from UI.confirm_page import ConfirmPage
+from UI.info_page_list_item import InfoPageListItem
+
+from UI.multilabel import MultiLabel
+from UI.lang_manager import MyLangManager
+from UI.keyboard import Keyboard
+
+from net_item import NetItem
+
+from agent import BleAgent,BleAgentPairPage
+
+class BleForgetConfirmPage(ConfirmPage):
+
+    _ConfirmText = MyLangManager.Tr("ConfirmForgetQ")
+    
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if IsKeyStartOrA(event.key):
+            self.SnapMsg(MyLangManager.Tr("Deleting"))
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+            try:
+                #self._Parent._Adapter.RemoveDevice()
+                print("try to RemoveDevice")
+            except Exception,e:
+                print(str(e))
+            
+            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 BleInfoPageSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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._MyList):
+            x = self._PosX+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 BleInfoPage(Page):
+    _FootMsg =  ["Nav","Forget","Disconnect","Back",""]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela15")
+    _ListSmFontObj = MySkinManager.GiveFont("varela12")  # small font
+    _ListSm2FontObj= MySkinManager.GiveFont("varela11")
+    
+    _AList = {}
+    _Path = ""
+    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 = BleInfoPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+         
+        #_AList is an object 
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = 2
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+        self._ConfirmPage1 = BleForgetConfirmPage()
+        self._ConfirmPage1._Screen = self._Screen
+        self._ConfirmPage1._Name   = "ConfirmForget"
+        self._ConfirmPage1._Parent = self
+        self._ConfirmPage1.Init() 
+        
+    def GenList(self):
+        if self._AList== None:
+            return
+        self._MyList = []
+        self._PsIndex = 0
+        start_x  = 0
+        start_y  = 0
+         
+        for i,v in enumerate( self._AList):
+            #print(i,v) # (0, dbus.String(u'AddressType'))
+            
+            li = InfoPageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*InfoPageListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFontObj
+            
+            if v == "UUIDs":
+                li._Fonts["small"] = self._ListSm2FontObj
+            else:
+                li._Fonts["small"] = self._ListSmFontObj
+            
+            li.Init( str(v) )
+            li._Flag = v
+            
+            if v =="UUIDs":
+                if len(self._AList[v]) > 1:
+                    pp(self._AList[v][0])
+                    sm_text = str(self._AList[v][0])
+                else:
+                    sm_text = "<empty>"
+            else:
+                sm_text = str(self._AList[v]) 
+            
+            if sm_text == "0":
+                sm_text="No"
+            elif sm_text == "1":
+                sm_text="Yes"
+            
+            sm_text = sm_text[:20]
+            li.SetSmallText(sm_text)
+            
+            li._PosX = 2
+            self._MyList.append(li)                      
+
+    def TryToForget(self):
+        global adapter
+        proxy_obj = bus.get_object("org.bluez", self._Path)
+        dev = dbus.Interface(proxy_obj, "org.bluez.Device1")
+        
+        self._Screen._MsgBox.SetText("Forgeting")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()        
+        
+        try:
+            adapter.RemoveDevice(dev)
+        except Exception,e:
+            err_name = e.get_dbus_name()
+            if err_name == "org.freedesktop.DBus.Error.NoReply":
+                self._Screen._MsgBox.SetText("DBus noreply")
+            else:
+                self._Screen._MsgBox.SetText("Forget failed")
+            
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+        
+        pygame.time.delay(500)
+        
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()    
+    
+    def TryToDisconnect(self):
+        global bus
+        
+        if "Connected" in self._AList:
+            if self._AList["Connected"] == 0:
+                return
+        
+        proxy_obj = bus.get_object("org.bluez", self._Path)
+        dev = dbus.Interface(proxy_obj, "org.bluez.Device1")
+        
+        self._Screen._FootBar.UpdateNavText("Disconnecting")
+        self._Screen._MsgBox.SetText("Disconnecting")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+        
+        try:
+            dev.Disconnect()
+        except Exception,e:
+            err_name = e.get_dbus_name()
+            if err_name == "org.freedesktop.DBus.Error.NoReply":
+                self._Screen._MsgBox.SetText("DBus noreply")
+            else:
+                self._Screen._MsgBox.SetText("Disconnect failed")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+        
+        pygame.time.delay(500)
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+        self._Screen._FootBar.ResetNavText()        
+        
+    
+    def Click(self):
+        if self._PsIndex >= len(self._MyList):
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        print(cur_li._Flag)
+        if cur_li._Flag in self._AList:
+            print(self._AList[ cur_li._Flag ])
+        
+    def OnLoadCb(self):
+        if self._AList != None:
+            if "Connected" in self._AList:
+                if self._AList["Connected"] == 1:
+                    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 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.TryToDisconnect()
+        
+        if event.key == CurKeys["Y"]:
+            self.TryToForget()
+        
+        
+    def Draw(self):
+        if len(self._MyList) == 0:
+            return
+        
+        self.ClearCanvas()
+
+        if len(self._MyList) * InfoPageListItem._Height > self._Height:
+            self._Ps._Width = self._Width - 10
+            self._Ps._PosX  = 9
+            self._Ps.Draw()        
+            for i in self._MyList:
+                i.Draw()
+            
+            self._Scroller.UpdateSize(len(self._MyList)*InfoPageListItem._Height, self._PsIndex*InfoPageListItem._Height)
+            self._Scroller.Draw()
+        
+        else:
+            self._Ps._Width = self._Width
+            self._Ps.Draw()
+            for i in self._MyList:
+                i.Draw() 
+        
+
+            
+
+class BleListSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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._MyList):
+            x = self._Parent._MyList[idx]._PosX+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 BleListMessageBox(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('Black'),(x-padding,y-padding, w+padding*2,h+padding*2),1)
+
+        self._CanvasHWND.blit(my_text,(x,y,w,h))
+
+
+
+class BluetoothPage(Page):
+    _MyList = []
+    #Wicd dbus part
+    _Adapter = None
+    _Dbus     = None
+    _Devices  = None
+    
+    _BlePassword = ""
+    _Connecting = False
+    _Scanning   = False 
+    
+    _PrevState = None
+    _Selector = None
+    
+    _ShowingMessageBox = False 
+    _MsgBox            = None
+    _ConnectTry        = 0
+    _BlockCb           = None
+    
+    _LastStatusMsg     = ""
+    _FootMsg           = ["Nav","Info","Scan","Back","TryConnect"]
+    _Scroller          = None
+    _ListFontObj       = MyLangManager.TrFont("notosanscjk15")
+
+    _InfoPage          = None
+    
+    _ADAPTER_DEV  = "hci0"
+    
+    _Offline = False
+    
+    _Leader = None
+    
+    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 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 = BleListSelector()
+        ps._Parent = self
+        ps._Width = Width - 12
+        
+        self._Ps = ps
+        self._PsIndex = 0
+        
+        msgbox = BleListMessageBox()
+        msgbox._CanvasHWND = self._CanvasHWND
+        msgbox.Init(" ",MyLangManager.TrFont("veramono12"))
+        msgbox._Parent = self
+        
+        self._MsgBox = msgbox     
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = 2
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+        self.GenNetworkList()
+        
+        self._InfoPage = BleInfoPage()
+        self._InfoPage._Screen = self._Screen
+        self._InfoPage._Name   = "BluetoothInfo"
+        self._InfoPage.Init()        
+
+    def print_normal(self,address, properties):
+        print("[ " + address + " ]")
+
+        for key in properties.keys():
+            value = properties[key]
+            if type(value) is dbus.String:
+                value = unicode(value).encode('ascii', 'replace')
+            if (key == "Class"):
+                print("    %s = 0x%06x" % (key, value))
+            else:
+                print("    %s = %s" % (key, value))
+
+        print()
+
+	properties["Logged"] = True
+
+    def skip_dev(self,old_dev, new_dev):
+        if not "Logged" in old_dev:
+            return False
+        if "Name" in old_dev:
+            return True
+        if not "Name" in new_dev:
+            return True
+        return False
+
+    def DbusPropertiesChanged(self, interface, changed, invalidated, path):
+        global devices
+        print("DbusPropertiesChanged")
+        if interface != "org.bluez.Device1":
+            return
+
+        if path in devices:
+            dev = devices[path]
+
+            if self.skip_dev(dev, changed):
+                return
+            devices[path] = dict(devices[path].items() + changed.items())
+        else:
+            devices[path] = changed
+
+        if "Address" in devices[path]:
+            address = devices[path]["Address"]
+        else:
+            address = "<unknown>"
+        
+        self._Devices = devices
+        self.print_normal(address, devices[path])
+        
+        self.RefreshDevices()
+        self.GenNetworkList()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def ShutDownConnecting(self):
+        print("Bluetooth Shutdown connecting...")
+    
+    def AbortedAndReturnToUpLevel(self):
+        self.HideBox()
+        self._Screen._FootBar.ResetNavText()
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+    
+    
+    def CheckIfBluetoothConnecting(self):
+        return True
+
+    def TryConnect(self):
+        global bus
+        
+        if self._PsIndex >= len(self._MyList):
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        print(cur_li._Path)
+        
+        if "Connected" in cur_li._Atts:
+            if cur_li._Atts["Connected"] == 1:
+                return
+        
+        proxy_obj = bus.get_object("org.bluez", cur_li._Path)
+        dev = dbus.Interface(proxy_obj, "org.bluez.Device1")
+        
+        self._Screen._FootBar.UpdateNavText("Connecting")
+        self.ShowBox(MyLangManager.Tr("Connecting"))
+        
+        self._Leader._MyAgent.device_obj = dev
+        self._Leader._MyAgent.dev_path = cur_li._Path
+        
+        try:
+            dev.Pair(reply_handler=self._Leader._MyAgent.pair_reply, 
+                                error_handler=self._Leader._MyAgent.pair_error,timeout=60000)
+        except Exception,e:
+            print(str(e))        
+        
+        
+        #self.HideBox()
+        #self._Screen._FootBar.ResetNavText()
+        
+    def RefreshDevices(self):
+        global devices
+        devices = {}
+        try:
+            proxy_obj = bus.get_object("org.bluez", "/")
+            manager = dbus.Interface(proxy_obj,"org.freedesktop.DBus.ObjectManager")
+            objects = manager.GetManagedObjects()
+            for path, interfaces in objects.iteritems():
+                if "org.bluez.Device1" in interfaces:
+                    devices[path] = interfaces["org.bluez.Device1"] ## like /org/bluez/hci0/dev_xx_xx_xx_yy_yy_yy
+        except Exception,e:
+            print(str(e))
+            devices={}
+        
+        self._Devices = devices
+        
+    
+    def GenNetworkList(self):
+        self._MyList = []
+        start_x = 0
+        start_y = 0
+        
+        counter = 0
+        for i,v in enumerate(self._Devices):
+            if "Name" in self._Devices[v]:
+                if len(self._Devices[v]["Name"]) < 2:
+                    continue
+                if re.match("[0-9a-f]{2}([-:]?)[0-9a-f]{2}(\\1[0-9a-f]{2}){4}$", self._Devices[v]["Name"].lower()): ## skip xx:xx:xx:xx:xx
+                    continue
+            else:
+                continue
+            
+            ni = NetItem()
+            ni._Parent = self
+            ni._PosX = start_x
+            ni._PosY = start_y + counter* NetItem._Height
+            ni._Width = Width
+            ni._FontObj = self._ListFontObj
+            
+            ni.Init(v,self._Devices[v])
+            
+            counter += 1
+            self._MyList.append(ni)
+
+        self._PsIndex = 0   
+    
+    def Rescan(self):
+        if self._Screen._CurrentPage != self:
+            return
+        
+        self._Scanning = True
+        self.ShowBox(MyLangManager.Tr("BluetoothScanning"))
+        self._Screen._FootBar.UpdateNavText("Scanning")
+        
+        proxy_obj = self._Dbus.get_object("org.bluez", "/org/bluez/" + self._ADAPTER_DEV)
+        adapter_props = dbus.Interface(proxy_obj,"org.freedesktop.DBus.Properties")
+        discoverying = adapter_props.Get("org.bluez.Adapter1", "Discovering") 
+        print("discoverying", discoverying)
+        
+        
+        if self._Adapter!= None:
+            try:
+                self._Adapter.StopDiscovery()
+            except Exception,e:
+                print(str(e))
+            
+            try:
+                self._Adapter.StartDiscovery()
+            except Exception,e:
+                err_name = e.get_dbus_name()
+                if err_name == "org.freedesktop.DBus.Error.NoReply":
+                    print("start discovery timeout")
+                else:
+                    print("start discovery unknown err: ", str(e))
+            
+    def OnReturnBackCb(self):
+        self.RefreshDevices()
+        self.GenNetworkList()
+    
+    def OnLoadCb(self):
+        self._Offline = False
+        if self._Screen._TitleBar._InAirPlaneMode == False:
+            out = commands.getstatusoutput("hcitool dev | grep hci0 |cut -f3") ## bluetooth maybe dead after airplane mode
+            if len(out[1]) < 17:
+                self._Offline = True
+                print("Bluetooth OnLoadCb ,can not find hci0 alive,try to reboot")
+            else:
+                self.RefreshDevices()
+                self.GenNetworkList()
+        else:
+            self._Offline = True
+            
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            if self._Offline == True:
+                self.AbortedAndReturnToUpLevel()
+                return
+            
+            if self._Adapter != None:
+                try:
+                    self._Adapter.StopDiscovery()
+                except Exception,e:
+                    print(str(e))
+                
+                _connecting = self.CheckIfBluetoothConnecting()
+                if _connecting:
+                    self.ShutDownConnecting()
+                    self.ShowBox(MyLangManager.Tr("ShutDownConnecting"))
+                    self.AbortedAndReturnToUpLevel()
+                else:
+                    self.AbortedAndReturnToUpLevel()
+            else:
+                self.HideBox()
+                self.ReturnToUpLevelPage()
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+            
+            self._Screen._FootBar.ResetNavText()
+            
+        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["X"]:
+            if self._Offline == False:
+                self.Rescan()   
+
+        if event.key == CurKeys["Y"]:
+            if len(self._MyList) == 0:
+                return
+            if self._Offline == True:
+                return
+            
+            self._InfoPage._AList = self._MyList[self._PsIndex]._Atts
+            self._InfoPage._Path  = self._MyList[self._PsIndex]._Path
+            self._Screen.PushPage(self._InfoPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if IsKeyStartOrA(event.key):
+            if self._Offline == False:
+                self.TryConnect()
+
+    def Draw(self):
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+                
+        if len(self._MyList) * NetItem._Height > self._Height:
+            self._Ps._Width = self._Width - 11
+            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()
+        else:
+            self._Ps._Width = self._Width
+            self._Ps.Draw()
+
+            for i in self._MyList:
+                i.Draw()
+
+
+
+BUS_NAME = 'org.bluez'
+AGENT_INTERFACE = 'org.bluez.Agent1'
+AGENT_PATH = "/gameshell/bleagent"
+
+class APIOBJ(object):
+
+    _Page = None
+    _PairPage = None
+    _Page3 = None
+    _Prompts = {} # string key,string value
+    _PromptType = None
+    _MyAgent = None
+    
+    def __init__(self):
+        self._Prompts["PIN"]=""
+        self._Prompts["PASS"]=""
+
+    def OnKbdReturnBackCb(self):
+        if self._PromptType == None:
+            return
+        else:
+            if self._PromptType in self._Prompts:
+                inputed = "".join(self._Page3._Textarea._MyWords)
+                self._Prompts[self._PromptType] = inputed
+            
+            self._PromptType = None ##clear 
+                
+        
+    def Ask(self,prompt,prompt_type=None):
+        
+        self._Screen.PushPage(self._Page3)
+        self._Page3.SetPassword("")
+        self._Page3._Name = prompt
+        self._Page3._Caller = self
+        
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+        if prompt_type != None:
+            self._PromptType = prompt_type
+        
+    def RegisterMyAgent(self):
+        global AGENT_PATH, bus,devices,adapter
+        
+        capability = "KeyboardDisplay"
+        self._MyAgent = BleAgent(bus, AGENT_PATH)
+        self._MyAgent._Leader = self
+        
+        obj = bus.get_object(BUS_NAME, "/org/bluez");
+        manager = dbus.Interface(obj, "org.bluez.AgentManager1")
+        manager.RegisterAgent(AGENT_PATH, capability)
+        print("BleAgent %s registered" % AGENT_PATH)
+        
+    def Init(self,main_screen):
+        global bus,devices,adapter
+        
+        self._Page = BluetoothPage()
+        self._Page._Dbus = bus
+        self._Page._Devices = devices
+        self._Page._Adapter = adapter
+        
+        self._Page._Screen = main_screen
+        self._Page._Name ="Bluetooth"
+        
+        self._Page._Leader = self
+        
+        self._Page.Init()
+        
+        self._PairPage = BleAgentPairPage()
+        self._PairPage._Screen = main_screen
+        self._PairPage._Name = "Bluetooth"
+        self._PairPage.Init()
+        
+        self._Page3= Keyboard()
+        self._Page3._Name = "Enter"
+        self._Page3._Screen = main_screen
+        self._Page3.Init()
+        
+        bus.add_signal_receiver(self._Page.DbusPropertiesChanged,
+            dbus_interface = "org.freedesktop.DBus.Properties",
+            signal_name = "PropertiesChanged",
+            arg0 = "org.bluez.Device1",
+            path_keyword = "path")
+        
+        self.RegisterMyAgent()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)

Menu/GameShell/10_Settings/Bluetooth/agent.py

@@ -0,0 +1,224 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+#import math
+#import  commands
+import dbus
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+from UI.page   import Page,PageSelector
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from libs.DBUS import  bus, adapter,devices
+
+
+BUS_NAME = 'org.bluez'
+AGENT_INTERFACE = 'org.bluez.Agent1'
+AGENT_PATH = "/gameshell/bleagent"
+
+class Rejected(dbus.DBusException):
+	_dbus_error_name = "org.bluez.Error.Rejected"
+
+class BleAgent(dbus.service.Object):
+    device_obj = None
+    _Leader = None
+    dev_path = ""
+    
+    def set_trusted(self,path):
+        global BUS_NAME
+        props = dbus.Interface(bus.get_object(BUS_NAME, path),
+                        "org.freedesktop.DBus.Properties")
+        props.Set("org.bluez.Device1", "Trusted", True)    
+        
+    def dev_connect(self,path):
+        global BUS_NAME
+        dev = dbus.Interface(bus.get_object(BUS_NAME, path),
+                                "org.bluez.Device1")
+                                
+        print("dev_connect %s" % path)
+        try:
+            dev.Connect() 
+        except Exception,e:
+            print(str(e))
+    
+    @dbus.service.method(AGENT_INTERFACE,in_signature="", out_signature="")
+    def Release(self):
+        print("Agent release")
+        
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="os", out_signature="")
+    def AuthorizeService(self, device, uuid):
+        print("AuthorizeService (%s, %s)" % (device, uuid)) ## directly authrized
+        return
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="o", out_signature="s")
+    def RequestPinCode(self, device):
+        print("RequestPinCode (%s)" % (device))
+        set_trusted(device)
+        return "0000"
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="o", out_signature="u")
+    def RequestPasskey(self, device):
+        print("RequestPasskey (%s)" % (device))
+        set_trusted(device)
+        passkey = "000000"
+        return dbus.UInt32(passkey)
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="ouq", out_signature="")
+    def DisplayPasskey(self, device, passkey, entered):
+        print("DisplayPasskey (%s, %06u entered %u)" % (device, passkey, entered))
+        self._Leader._PairPage.ShowPassKey(device,passkey,entered)
+        
+    @dbus.service.method(AGENT_INTERFACE,in_signature="os", out_signature="")
+    def DisplayPinCode(self, device, pincode):
+        print("DisplayPinCode (%s, %s)" % (device, pincode))
+        self._Leader._PairPage.ShowPinCode(device,pincode)
+        
+    @dbus.service.method(AGENT_INTERFACE,in_signature="ou", out_signature="")
+    def RequestConfirmation(self, device, passkey):
+        print("RequestConfirmation (%s, %06d)" % (device, passkey))
+        set_trusted(device)
+        return
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="o", out_signature="")
+    def RequestAuthorization(self, device):
+        print("RequestAuthorization (%s)" % (device))
+        
+        return
+
+    @dbus.service.method(AGENT_INTERFACE,in_signature="", out_signature="")
+    def Cancel(self):
+        print("Cancel")
+    
+    
+    def pair_reply(self):
+        print("Device paired under Agent")
+        self.set_trusted(self.dev_path)
+        self.dev_connect(self.dev_path)
+        
+        self._Leader._PairPage._dev_obj = self.device_obj
+        self._Leader._PairPage.PairReplyCb()
+        
+    def pair_error(self,error):
+        global adapter
+        err_msg = ""
+        err_name = error.get_dbus_name()
+        print(err_name)
+        if err_name == "org.freedesktop.DBus.Error.NoReply" and self.device_obj:
+            err_msg = "Timed out. Cancelling pairing"
+            print(err_msg)
+            self.device_obj.CancelPairing()
+        elif err_name == "org.bluez.Error.AuthenticationCanceled":
+            err_msg = "Authentication Canceled"
+        elif err_name == "org.bluez.Error.ConnectionAttemptFailed":
+            err_msg = "Page Timeout"
+        elif err_name == "org.bluez.Error.AlreadyExists":
+            err_msg ="Already Exists"
+            try:
+                adapter.RemoveDevice(self.device_obj)
+            except Exception,e:
+                print("pair_error forget err:",str(e))
+        
+        elif err_name == "org.bluez.Error.AuthenticationFailed":
+            err_msg = "Authentication Failed"
+        else:    
+            err_msg = "Pair error"
+            print( err_name,str(error) )
+            
+        self.device_obj = None
+        self._Leader._PairPage.PairErrorCb(err_msg)
+
+class BleAgentPairPage(Page):
+    
+    ##show pin/password 
+    ##show prompt 
+    _Pin = ""
+    _Pass = ""
+    _dev_obj = None
+    _FootMsg    = ["Nav","","","Back",""]
+    
+    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
+    
+    def ShowPinCode(self,device,pincode):
+        print("ShowPinCode %s %s" % (device,pincode))
+        if self._Screen.CurPage() != self:
+            self._Screen.PushPage(self)
+            self.ClearCanvas()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        self._Pin = "%s" % pincode
+        txt = self.Pin
+        if len(self._Pin) > 0:
+            txt = "Pin code: %s" % self._Pin
+        self._Screen._MsgBox.SetText(txt)
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow() 
+        
+    def ShowPassKey(self,device,passkey,entered):
+        print("ShowPassKey %06u %u" % (passkey,entered))
+        if self._Screen.CurPage() != self:
+            self._Screen.PushPage(self)
+            self.ClearCanvas()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        self._Pass = "%06u" % passkey
+        if len(self._Pass) > 0:
+            txt = "Pair code: %s" % self._Pass
+        self._Screen._MsgBox.SetText(txt)
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow() 
+        
+    def PairReplyCb(self):
+        self.ClearCanvas()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+        self._Screen._MsgBox.SetText("Device paired")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+        pygame.time.delay(1500)
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()        
+        self._Screen._FootBar.ResetNavText()
+        
+    def PairErrorCb(self,error=None):
+        self.ClearCanvas()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+            
+        self._Screen._MsgBox.SetText(error)
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+        pygame.time.delay(1500)
+        self.ReturnToUpLevelPage()
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()         
+        self._Screen._FootBar.ResetNavText()        
+        
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            if self._dev_obj != None:
+                try:
+                    self._dev_obj.CancelPairing()
+                except Exception,e:
+                    print(str(e))
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+    
+    
+    def Draw(self):
+        pass
+        #self.ClearCanvas()
+        
+    
+    

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

@@ -0,0 +1,128 @@
+# -*- 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
+
+
+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
+    
+    _Atts  = {}
+    
+    _Channel=""  # '10' 
+    _Stren = ""  ## 19%
+
+    _Parent = None
+    _IsActive = False
+
+    _Icons  = {} ## wifi strength and security icons
+    _Labels = {}
+    _FontObj = None
+    
+    _RSSI = 0
+    _MacAddr=""
+    _Path  = "" #/org/bluez/hci0/dev_34_88_5D_97_FF_26
+    
+    def __init__(self):
+        self._Labels = {}
+        self._Icons = {}
+
+    def SetActive(self,act):
+        self._IsActive = act
+    
+    def Init(self, path, object):
+        self._Path = path
+        self._Atts = object 
+        
+        is_active=False
+        if "Address" in object:
+            self._MacAddr = object["Address"]
+        
+        if  "Connected" in object:
+            if object["Connected"] == 1:
+                is_active=True
+        
+        if is_active:
+            self.SetActive(is_active)
+        
+
+        name_label = Label()
+        name_label._PosX = 12
+        name_label._CanvasHWND = self._Parent._CanvasHWND
+
+        mac_addr = self._MacAddr
+        
+        if "Name" in object:
+            if len(object["Name"]) > 3:
+                mac_addr = object["Name"]
+        
+        if "RSSI" in object:
+            print(object["RSSI"])
+            self._RSSI = int(object["RSSI"])
+        
+        mac_addr = mac_addr[:34]
+        
+        name_label.Init(mac_addr,self._FontObj)
+        
+        self._Labels["mac_addr"] = name_label
+
+        done_icon = NetItemIcon()
+        done_icon._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done_icon._CanvasHWND = self._Parent._CanvasHWND
+        done_icon._Parent = self
+        
+        self._Icons["done"] = done_icon
+        ## reuse the resource from TitleBar
+        #pp(theString)
+    
+    
+    def Connect(self,notworkentry=None):
+        """ Execute connection. """
+        #dev = dbus.Interface(bus.get_object("org.bluez", "/org/bluez/hci0/dev_"+"34_88_5D_97_FF_26"), "org.bluez.Device1")
+        proxy_obj = self._Parent._Dbus.get_object("org.bluez",self._Path)
+        dev = self._Parent._Dbus.Interface(proxy_obj, "org.bluez.Device1")
+        dev.Connect()
+
+    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(320-22,self._PosY)
+            self._Icons["done"].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)

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

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*- 
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitBrightnessPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.BrightnessPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+        

Menu/GameShell/10_Settings/Brightness/brightness_page.py

@@ -0,0 +1,187 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+
+#import math
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from UI.slider     import Slider
+from UI.icon_pool  import MyIconPool
+from UI.multi_icon_item import MultiIconItem
+from UI.skin_manager import MySkinManager
+
+
+from config import BackLight
+
+
+import myvars
+
+class BSlider(Slider):
+
+    
+    OnChangeCB = None
+    _Parent     = None
+    _Icons      = {}
+    
+    def __init__(self):
+        Slider.__init__(self)
+        self._Icons = {}
+    def Init(self):
+        self._Width = self._Parent._Width
+        self._Height = self._Parent._Height
+        
+        self._BrightnessLabel = Label()
+        self._BrightnessLabel.SetCanvasHWND(self._CanvasHWND)
+        self._BrightnessLabel.Init("BRIGHT",MySkinManager.GiveFont("EurostileBold13"))
+        self._BrightnessLabel.SetColor(MySkinManager.GiveColor('Text'))
+        
+
+    def SetValue(self,brt):
+        self._Value = brt
+        
+    def Further(self):
+        self._Value+=1
+        if self._Value > 9:
+            self._Value = 9
+            
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB(self._Value)
+                    
+    def StepBack(self):
+        self._Value-=1
+
+        if self._Value < 1:
+            self._Value = 1
+
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB(self._Value)
+    
+    def Draw(self):
+        start_x = 82
+        start_y = self._Parent._Screen._Height/2-5
+        height = 30
+        width = 4
+        padding = 15
+        seg = self._Value-1
+
+        for i in range(0,9):
+            rect = pygame.Rect(start_x+i*(width+padding),start_y,width,height)
+            if i > seg:
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),rect, 1)
+                #aa_round_rect(self._CanvasHWND,rect, MySkinManager.GiveColor('Text'),1,1, MySkinManager.GiveColor('White'))
+            else:
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),rect, 0)   
+                #aa_round_rect(self._CanvasHWND,rect, MySkinManager.GiveColor('Text'),1,0, MySkinManager.GiveColor('White'))
+        
+        self._BrightnessLabel.NewCoord(118,self._Parent._Screen._Height/2-30)
+        self._BrightnessLabel.Draw(True)
+        
+        minus_box_rect = pygame.Rect(start_x- (4+6)*4,start_y,6*4,30)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),minus_box_rect, 0) 
+        
+        minus_rect     = pygame.Rect(start_x-8*4,start_y+14,2*4,2)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),minus_rect, 0) 
+        
+        plus_box_rect = pygame.Rect(start_x + 39*4 +4*4,start_y,6*4,30)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),plus_box_rect, 0) 
+        
+        cross1_rect     = pygame.Rect(start_x+39*4+4*4+2*4,start_y+14,2*4,2)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),cross1_rect, 0) 
+        cross2_rect     = pygame.Rect(start_x+39*4+4*4+2*4+3,start_y+14-3,2,2*4)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),cross2_rect, 0) 
+
+
+        
+class BrightnessPage(Page):
+
+    _MySlider = None
+    _FootMsg = ["Nav","","","Back","Enter"]
+
+    
+    def Init(self):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._MySlider = BSlider()
+#        self._MySlider._Width = Width - 20
+#        self._MySlider._Height = 30
+#        self._MySlider._PosX  = (self._Width - self._MySlider._Width)/2
+#        self._MySlider._PosY  = 40
+        self._MySlider._Parent = self
+        self._MySlider.SetCanvasHWND(self._CanvasHWND)
+        self._MySlider.OnChangeCB = self.WhenSliderDrag
+        self._MySlider.Init()
+
+        brt  = self.ReadBackLight()
+        
+        self._MySlider.SetValue( brt)
+
+    
+    def ReadBackLight(self):
+        try:
+            f = open(BackLight)
+        except IOError:
+            return 0
+        else:
+            with f:
+                content = f.readlines()
+                content = [x.strip() for x in content]
+                return int(content[0])
+
+        return 0
+
+    def OnLoadCb(self):
+         brt  = self.ReadBackLight()
+         
+         self._MySlider.SetValue( brt)
+         
+    def SetBackLight(self,newbrt):
+        try:
+            f = open(BackLight,'w')
+        except IOError:
+            print("Open write %s failed %d" % (BackLight,newbrt))
+            return False
+        else:
+            with f:
+                f.write(str(newbrt))
+                return True
+        
+    def WhenSliderDrag(self,value): ##value 
+        self.SetBackLight(value)
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Right"]:
+            self._MySlider.Further()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self._MySlider.StepBack()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._MySlider.Draw()
+
+        
+
+
+    

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

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import sys
+
+SoundPage = None

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from brightness_page import BrightnessPage
+
+import myvars
+
+def InitBrightnessPage(main_screen):
+
+    myvars.BrightnessPage = BrightnessPage()
+    
+    myvars.BrightnessPage._Screen = main_screen
+    myvars.BrightnessPage._Name = "Brightness"
+    myvars.BrightnessPage.Init()

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

@@ -0,0 +1,267 @@
+# -*- coding: utf-8 -*-
+
+import pygame
+import commands
+import shutil
+import os
+
+from libs.roundrects import aa_round_rect
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, GetButtonsLayoutMode, SetButtonsLayoutMode, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multi_icon_item import MultiIconItem
+from UI.multilabel import MultiLabel
+from UI.confirm_page import ConfirmPage
+
+class UpdateConfirmPage(ConfirmPage):
+    _ConfirmText = "Apply to RetroArch?"
+    _RetroArchConf = "/home/cpi/.config/retroarch/retroarch.cfg"
+    _LayoutMode = "Unknown"
+
+    def ModifyRetroArchConf(self,keys):
+
+        try:
+            with open(self._RetroArchConf, mode="r") as f:
+                confarr = f.readlines()
+        except:
+            return "retroarch.cfg cannot open."
+
+        bka = bkb = bkx = bky = False
+        try:
+            for i, ln in enumerate(confarr):
+                lnk = ln.split("=")[0].strip()
+                if lnk == "input_player1_a":
+                    confarr[i] = "input_player1_a = \"" + keys[0] + "\"\n"
+                    bka = True
+                if lnk == "input_player1_b":
+                    confarr[i] = "input_player1_b = \"" + keys[1] + "\"\n"
+                    bkb = True
+                if lnk == "input_player1_x":
+                    confarr[i] = "input_player1_x = \"" + keys[2] + "\"\n"
+                    bkx = True
+                if lnk == "input_player1_y":
+                    confarr[i] = "input_player1_y = \"" + keys[3] + "\"\n"
+                    bky = True
+        except:
+            return "retroarch.cfg cannot parse."
+
+        if bka and bkb and bkx and bky:
+            None
+        else:
+            return "retroarch.cfg validation error."
+
+        try:
+            with open(self._RetroArchConf, mode="w") as f:
+                confarr = f.writelines(confarr)
+        except:
+            return "retroarch.cfg cannot write."
+
+        return "Completed! Your RA keymap: " + self._LayoutMode.upper()
+
+    def KeyDown(self,event):
+
+        def finalizeWithDialog(msg):
+            self._Screen._MsgBox.SetText(msg)
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            return
+
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if IsKeyStartOrA(event.key):
+
+            if self._LayoutMode == "xbox":
+                keymap = ["j","k","u","i"]
+            elif self._LayoutMode == "snes":
+                keymap = ["k","j","i","u"]
+            else:
+                finalizeWithDialog("Internal error.")
+                return
+            print("mode: " + self._LayoutMode)
+
+            if not os.path.isfile(self._RetroArchConf):
+                finalizeWithDialog("retroarch.cfg was not found.")
+                return
+
+            try:
+                shutil.copyfile(self._RetroArchConf, self._RetroArchConf + ".blbak")
+            except:
+                finalizeWithDialog("Cannot create .blbak")
+                return
+
+            finalizeWithDialog(self.ModifyRetroArchConf(keymap))
+            return
+
+    def OnReturnBackCb(self):
+        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 ButtonsLayoutPage(Page):
+    _FootMsg =  ["Nav.","","UpdateRetroArch","Back","Toggle"]
+    _MyList = []
+
+    _AList = {}
+
+    _Scrolled = 0
+
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _ConfirmPage = None
+
+    _EasingDur = 30
+
+    _dialog_index = 0
+
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+
+        self._MyList = []
+
+
+
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        DialogBoxs = MultiIconItem()
+        DialogBoxs._ImgSurf = MyIconPool.GiveIconSurface("buttonslayout")
+        DialogBoxs._MyType = ICON_TYPES["STAT"]
+        DialogBoxs._Parent = self
+        DialogBoxs._IconWidth = 300
+        DialogBoxs._IconHeight = 150
+        DialogBoxs.Adjust(0,0,134,372,0)
+        self._Icons["DialogBoxs"] = DialogBoxs
+
+        self.GenList()
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+        self._ConfirmPage = UpdateConfirmPage()
+        self._ConfirmPage._LayoutMode = GetButtonsLayoutMode()
+        self._ConfirmPage._Screen = self._Screen
+        self._ConfirmPage._Name  = "Overwrite RA conf"
+        self._ConfirmPage._Parent = self
+        self._ConfirmPage.Init()
+
+
+    def ScrollDown(self):
+        dis = 10
+        if abs(self._Scrolled) <  (self._BGheight - self._Height)/2 + 0:
+            self._PosY -= dis
+            self._Scrolled -= dis
+
+    def ScrollUp(self):
+        dis = 10
+        if self._PosY < 0:
+            self._PosY += dis
+            self._Scrolled += dis
+
+    def ToggleMode(self):
+
+        if GetButtonsLayoutMode() == "xbox":
+            SetButtonsLayoutMode("snes")
+
+            self._dialog_index = 1
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        else:
+            SetButtonsLayoutMode("xbox")
+
+            self._dialog_index = 0
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+
+        self._dialog_index = 0 if GetButtonsLayoutMode() == "xbox" else 1
+
+    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 IsKeyStartOrA(event.key):
+            self.ToggleMode()
+
+        if event.key == CurKeys["X"]:
+            self._ConfirmPage._LayoutMode = GetButtonsLayoutMode()
+            self._Screen.PushPage(self._ConfirmPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+    def Draw(self):
+        self.ClearCanvas()
+
+        self._Icons["DialogBoxs"].NewCoord(0,30)
+        self._Icons["DialogBoxs"]._IconIndex = self._dialog_index
+        self._Icons["DialogBoxs"].DrawTopLeft()
+
+        if self._HWND != None:
+            self._HWND.fill((255,255,255))
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = ButtonsLayoutPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Buttons Layout"
+        self._Page.Init()
+
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+

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

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+
+import os
+import platform
+import pygame
+import glob
+#import math
+import  commands
+
+#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,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists,IsExecutable,ArmSystem,CmdClean
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.confirm_page import ConfirmPage
+from UI.multi_icon_item import MultiIconItem
+from UI.lang_manager  import MyLangManager
+from UI.multilabel import MultiLabel
+from UI.info_page_list_item import InfoPageListItem
+from UI.info_page_selector  import InfoPageSelector
+from UI.skin_manager import MySkinManager
+
+
+class DeleteCoreConfirmPage(ConfirmPage):
+    
+    _ConfirmText = MyLangManager.Tr("Awaiting Input")
+    _FootMsg = ["Nav","","","Cancel","OK"]
+    CallbackA = None
+    
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if IsKeyStartOrA(event.key):
+            self._Screen._MsgBox.SetText("Applying")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            
+            pygame.time.delay(638)
+            
+            self.CallbackA()
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+    
+class CoresPage(Page):
+    _FootMsg =  ["Nav","Del","Scan","Back",""]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+
+    _EasingDur = 30
+    
+    _CORES_PATH = "%s/.config/retroarch/cores" % os.path.expanduser('~') 
+
+    _Config =None
+    _AllowedExts = [".so",".bin"]
+    _HiddenSos   = ["GBA.BIOS","gba_bios.bin"]
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        
+        if "arm" in platform.machine():
+            pass
+        
+    def GenList(self):
+
+        self._MyList = []
+        ## map ini to self._AList
+        files_path = glob.glob(self._CORES_PATH+"/*")
+        
+        start_x  = 10
+        start_y  = 0
+        counter = 0 
+        for i,v in enumerate( files_path):
+            if os.path.basename(v) in self._HiddenSos:
+                continue
+            
+            filename, file_extension = os.path.splitext(v)
+
+            alias_file = filename+file_extension + ".alias"
+            
+            if file_extension in self._AllowedExts:
+                li = InfoPageListItem()
+                li._Parent = self
+                li._PosX   = start_x
+                li._PosY   = start_y + counter*InfoPageListItem._Height
+                li._Width  = Width-10
+                li._Fonts["normal"] = self._ListFontObj
+                li._Fonts["small"] = MySkinManager.GiveFont("varela12")
+                li._ReadOnly = True
+                
+                if os.path.isfile(alias_file):
+                    fp = open(alias_file, "r")
+                    alias = fp.read()
+                    alias = alias.strip()
+                    label_text = alias.decode("utf8")
+                    li.Init( label_text )
+                    fp.close()
+                else:
+                    li.Init( os.path.basename(v) )
+                li._Flag = v
+                ##li.SetSmallText( v )
+                
+                self._MyList.append(li)
+                counter += 1
+    
+    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._PosX = 11
+        ps._Parent = self
+        ps._Width = self._Width-10
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = 2
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+        self._ConfirmBox = DeleteCoreConfirmPage()
+        self._ConfirmBox._Screen = self._Screen
+        self._ConfirmBox._Name = "Confirm to Delete?"
+        self._ConfirmBox._Parent = self
+        self._ConfirmBox.Init()
+        
+    def ReScan(self):
+        self.GenList()
+        self.RefreshPsIndex()
+      
+    def ConfirmBoxCallbackA(self):
+        if len(self._MyList) == 0:
+            return
+            
+        cur_li = self._MyList[self._PsIndex]
+        
+        os.system("rm %s" % CmdClean(cur_li._Flag))
+        self.GenList()
+        self.RefreshPsIndex()
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False    
+        self.GenList()
+    
+    def OnReturnBackCb(self):
+        pass
+        
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["X"]: #Scan current
+           self.ReScan() 
+           self._Screen.Draw()
+           self._Screen.SwapAndShow()
+                       
+        if event.key == CurKeys["Y"]: #del
+            if len(self._MyList) == 0:
+                return
+            
+            self._ConfirmBox.CallbackA = self.ConfirmBoxCallbackA
+            
+            self._Screen.PushPage(self._ConfirmBox)
+            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()
+
+ 
+
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) > 0:
+            self._Ps.Draw()
+            for i in self._MyList:
+                i.Draw()
+        
+            self._Scroller.UpdateSize( len(self._MyList)*InfoPageListItem._Height,
+                                   self._PsIndex*InfoPageListItem._Height) 
+            self._Scroller.Draw()
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = CoresPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Retroarch cores manager"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,349 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+import platform
+import commands
+#import glob
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES,RESTARTUI
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multilabel import MultiLabel
+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
+import config
+
+class ListPageSelector(InfoPageSelector):
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        
+        if idx < len(self._Parent._MyList):
+            x = self._Parent._MyList[idx]._PosX+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 PageListItem(InfoPageListItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+
+    _Active  = False
+    _Value = ""
+    
+    def Draw(self):
+        
+        self._Labels["Text"]._PosY = self._PosY+ (self._Height-  self._Labels["Text"]._Height)/2
+        
+        if self._Active == True:
+            self._Parent._Icons["done"].NewCoord( self._Parent._Width-30,self._PosY+5)
+            self._Parent._Icons["done"].Draw()
+            
+        self._Labels["Text"].Draw(self._Active)
+            
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width -10
+            self._Labels["Small"]._PosY = self._PosY + (self._Height-  self._Labels["Small"]._Height)/2
+            self._Labels["Small"].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)        
+    
+class GateWayPage(Page):
+    _FootMsg =  ["Nav","Clear All","","Back","Select"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _InfoPage = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        last_height = 0
+
+        drivers = [["usb0","USB Ethernet"],
+                    ["wlan0","Wi-Fi"]]
+                
+        
+        for i,u in enumerate( drivers ):            
+            #print(i,u)
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._Active = False
+            li._Value = u[0]
+            li.Init( u[1] )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        done = IconItem()
+        done._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done._MyType = ICON_TYPES["STAT"]
+        done._Parent = self
+        self._Icons["done"] = done
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+    def Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._Active == True:
+            out = commands.getstatusoutput("sudo ip route | grep default | cut -d \" \" -f3")
+            if len(out[1]) > 7:
+                self._Screen._MsgBox.SetText(out[1])
+                self._Screen._MsgBox.Draw()
+                self._Screen.SwapAndShow()      
+            return
+
+        print(cur_li._Value)
+        
+        if "arm" in platform.machine():
+            for i in self._MyList:
+                i._Active = False
+            
+            self._Screen._MsgBox.SetText("Applying")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            
+            cur_li._Active = self.ApplyGateWay(cur_li._Value)
+            
+            pygame.time.delay(1000)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        else:
+            self._Screen._MsgBox.SetText("Do it in GameShell")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+    
+    def ClearAllGateways(self):
+        self._Screen._MsgBox.SetText("Cleaning up")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()          
+        os.system("sudo ip route del 0/0")
+        pygame.time.delay(800)
+        
+        for i in self._MyList:
+            i._Active = False 
+        
+        self._Screen.Draw()
+        self._Screen.SwapAndShow() 
+    
+    def ApplyGateWay(self,gateway):
+        os.system("sudo ip route del 0/0")
+        if gateway== "usb0":
+            out = commands.getstatusoutput("sudo ifconfig usb0 | grep inet | tr -s \" \"| cut -d \" \" -f3")
+            if len(out[1]) > 7:
+                if "error" not in out[1]:
+                    parts = out[1].split(".")
+                    if len(parts) == 4:##IPv4
+                        tp3 = int(parts[3])
+                        tmp = tp3
+                        if tp3 == 0:
+                            tmp = int(parts[3]) + 1
+                        elif tp3 == 1:
+                            tmp = int(parts[3]) + 1
+                        elif tp3 > 1:
+                            tmp = int(parts[3]) - 1
+                        
+                        parts[3] = str(tmp)
+                        ipaddress = ".".join(parts)
+                        os.system("sudo route add default gw "+ipaddress)
+                        return True
+        else:
+            if is_wifi_connected_now():
+                os.system("sudo dhclient wlan0")
+                return True
+            else:
+                self._Screen._MsgBox.SetText("Wi-Fi is not connected")
+                self._Screen._MsgBox.Draw()
+                self._Screen.SwapAndShow()            
+                return False
+        
+        return False
+        
+
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        
+        ## grep Driver /etc/xorg.conf | tr -s " " | cut -d " " -f3
+        ## "fbturbo"
+        ## "modesetting"
+        thedrv = ""
+        
+        if "arm" in platform.machine():
+            out = commands.getstatusoutput("sudo ip route | grep default")
+            if len(out[1]) > 7:
+                if "usb0" in out[1]:
+                    thedrv = "usb0"
+                elif "wlan0" in out[1]:
+                    thedrv = "wlan0"
+                
+        for i in self._MyList:
+            i._Active = False
+        
+        if thedrv != "":
+            for i in self._MyList:
+                if thedrv in i._Value:
+                    i._Active = True 
+        ## if usb0 and wlan0 all actived, clear all
+        
+    def OnReturnBackCb(self):
+        pass
+        """
+        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 IsKeyStartOrA(event.key):
+            self.Click()
+            
+        if event.key == CurKeys["Y"]:
+            self.ClearAllGateways()
+                        
+        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()
+
+    
+    def Draw(self):
+
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+        
+        else:
+            if len(self._MyList) * PageListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*PageListItem._Height, self._PsIndex*PageListItem._Height)
+                self._Scroller.Draw()
+                
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()                
+
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = GateWayPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Gateway switch"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,309 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+#import math
+#mport subprocess
+import glob
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES,RESTARTUI
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multilabel import MultiLabel
+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
+
+import config
+
+class ListPageSelector(InfoPageSelector):
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        
+        if idx < len(self._Parent._MyList):
+            x = self._Parent._MyList[idx]._PosX+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 PageListItem(InfoPageListItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+
+    _Active  = False
+    _Value = ""
+    
+    def Draw(self):
+        
+        self._Labels["Text"]._PosY = self._PosY+ (self._Height-  self._Labels["Text"]._Height)/2
+        
+        if self._Active == True:
+            self._Parent._Icons["done"].NewCoord( self._Parent._Width-30,self._PosY+5)
+            self._Parent._Icons["done"].Draw()
+            
+        self._Labels["Text"].Draw(self._Active)
+            
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width -10
+            self._Labels["Small"]._PosY = self._PosY + (self._Height-  self._Labels["Small"]._Height)/2
+            self._Labels["Small"].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)        
+    
+class LanguagesPage(Page):
+    _FootMsg =  ["Nav","","","Back","Select"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _InfoPage = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        last_height = 0
+
+        files_path = [os.path.basename(x) for x in sorted(glob.glob('langs/*.ini'))]
+        
+        for i,u in enumerate( files_path ):            
+            #print(i,u)
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._Active = False
+            li._Value = u.decode("utf8")
+            lang_name = u.split("_")[1]
+            lang_name = lang_name.split(".")[0]
+            
+            li.Init( lang_name.decode("utf8") )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        done = IconItem()
+        done._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done._MyType = ICON_TYPES["STAT"]
+        done._Parent = self
+        self._Icons["done"] = done
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+        
+    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 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 Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._Active == True:
+            return
+        
+        for i in self._MyList:
+            i._Active = False
+
+        cur_li._Active = True
+        print(cur_li._Value)
+        with open(".lang","w") as f:
+            f.write(cur_li._Value)
+        
+        self._Screen._MsgBox.SetText("Applying")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+        
+        MyLangManager.UpdateLang()
+        
+        pygame.event.post( pygame.event.Event(RESTARTUI, message="")) ##Restart Launcher
+        
+        pygame.time.delay(1000)
+        
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        with open(".lang", "r") as f:
+            thelang = f.read()
+
+        thelang = thelang.strip()
+
+        if thelang == "":
+            thelang = "English"
+
+        for i in self._MyList:
+            if thelang in i._Value:
+                i._Active = True
+        
+    def OnReturnBackCb(self):
+        pass
+        """
+        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 IsKeyStartOrA(event.key):
+            self.Click()
+            
+        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()
+
+    
+    def Draw(self):
+
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+        
+        else:
+            if len(self._MyList) * PageListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*PageListItem._Height, self._PsIndex*PageListItem._Height)
+                self._Scroller.Draw()
+                
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()                
+
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = LanguagesPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Languages"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,302 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+import platform
+#import commands
+import glob
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES,RESTARTUI
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists,ArmSystem
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multilabel import MultiLabel
+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
+
+import config
+
+class ListPageSelector(InfoPageSelector):
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        
+        if idx < len(self._Parent._MyList):
+            x = self._Parent._MyList[idx]._PosX+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 PageListItem(InfoPageListItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+
+    _Active  = False
+    _Value = ""
+    
+    def Draw(self):
+        
+        self._Labels["Text"]._PosY = self._PosY+ (self._Height-  self._Labels["Text"]._Height)/2
+        
+        if self._Active == True:
+            self._Parent._Icons["done"].NewCoord( self._Parent._Width-30,self._PosY+5)
+            self._Parent._Icons["done"].Draw()
+            
+        self._Labels["Text"].Draw(self._Active)
+            
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width -10
+            self._Labels["Small"]._PosY = self._PosY + (self._Height-  self._Labels["Small"]._Height)/2
+            self._Labels["Small"].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)        
+    
+class GPUDriverPage(Page):
+    _FootMsg =  ["Nav","","","Back","Select"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk12")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _InfoPage = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        last_height = 0
+
+        drivers = [["fbturbo","FBTURBO driver (Software Rendering)"],
+                    ["modesetting","LIMA driver (Experimental GPU Rendering)"]]
+                
+        
+        for i,u in enumerate( drivers ):            
+            #print(i,u)
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._Active = False
+            li._Value = u[0]
+            li.Init( u[1] )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        done = IconItem()
+        done._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done._MyType = ICON_TYPES["STAT"]
+        done._Parent = self
+        self._Icons["done"] = done
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+    def Click(self):
+        if self._PsIndex > len(self._MyList) -1:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._Active == True:
+            return
+
+        print(cur_li._Value)
+        
+        if "arm" in platform.machine():
+            for i in self._MyList:
+                i._Active = False
+            
+            cur_li._Active = True
+            self._Screen._MsgBox.SetText("Applying")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            
+            if "modesetting" in cur_li._Value: ## enable lima
+                os.system("touch %s/.lima" % os.path.expanduser('~') )
+                ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima  /usr/lib/xorg/modules/drivers/modesetting_drv.so")
+                ArmSystem("sudo sed -i '/^#.*lima/s/^#//' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf")
+                ArmSystem("sudo ldconfig")
+            else: #disable lima
+                os.system("rm %s/.lima" % os.path.expanduser('~') )
+                ArmSystem("sudo mv /usr/lib/xorg/modules/drivers/modesetting_drv.so /usr/lib/xorg/modules/drivers/modesetting_drv.so.lima")
+                ArmSystem("sudo sed -i 's/^[^#]*lima/#&/' /etc/ld.so.conf.d/00-arm-linux-gnueabihf.conf")
+                ArmSystem("sudo ldconfig")
+            
+            pygame.time.delay(800)
+            os.system("sudo reboot")
+        
+        else:
+            self._Screen._MsgBox.SetText("Do it in GameShell")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        
+        ## grep Driver /etc/xorg.conf | tr -s " " | cut -d " " -f3
+        ## "fbturbo"
+        ## "modesetting"
+        thedrv = ""
+        
+        if "arm" in platform.machine():
+            if FileExists("%s/.lima" % os.path.expanduser('~')):
+                thedrv = "modesetting"
+            else:
+                thedrv = "fbturbo"
+        
+        if thedrv == "":
+                thedrv = "fbturbo"
+        
+        for i in self._MyList:
+            i._Active = False
+        
+        for i in self._MyList:
+            if thedrv in i._Value:
+                i._Active = True
+        
+    def OnReturnBackCb(self):
+        pass
+        """
+        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 IsKeyStartOrA(event.key):
+            self.Click()
+            
+        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()
+
+    
+    def Draw(self):
+
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+        
+        else:
+            if len(self._MyList) * PageListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*PageListItem._Height, self._PsIndex*PageListItem._Height)
+                self._Scroller.Draw()
+                
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()                
+
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = GPUDriverPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="GPU Driver Switch"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+
+import os
+import platform
+import pygame
+import glob
+#import math
+import  commands
+
+#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,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists,IsExecutable
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multi_icon_item import MultiIconItem
+from UI.lang_manager  import MyLangManager
+from UI.multilabel import MultiLabel
+from UI.info_page_list_item import InfoPageListItem
+from UI.info_page_selector  import InfoPageSelector
+from UI.skin_manager import MySkinManager
+
+class NotifyJobListItem(InfoPageListItem):
+    
+    _CanvasHWND = None
+    
+    def Init(self,text):
+
+        #self._Fonts["normal"] = fonts["veramono12"]
+        self._CanvasHWND = self._Parent._CanvasHWND
+        
+        l = Label()
+        l._PosX = 10
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+
+        l.Init(text,self._Fonts["normal"])
+        self._Labels["Text"] = l    
+        
+        done_icon = IconItem()
+        done_icon._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done_icon._CanvasHWND = self._Parent._CanvasHWND
+        done_icon._Parent = self
+        
+        self._Icons["done"] = done_icon
+    
+    def Draw(self):
+        if self._ReadOnly == False:
+            self._Labels["Text"].SetColor(MySkinManager.GiveColor("ReadOnlyText"))
+        else:
+            self._Labels["Text"].SetColor(MySkinManager.GiveColor("Text"))
+
+        
+        self._Labels["Text"]._PosX = self._Labels["Text"]._PosX + self._PosX
+        self._Labels["Text"]._PosY = self._PosY + (self._Height - self._Labels["Text"]._Height)/2
+        self._Labels["Text"].Draw()
+        self._Labels["Text"]._PosX = self._Labels["Text"]._PosX - self._PosX
+
+        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()
+        
+        if self._ReadOnly:
+            self._Icons["done"].NewCoord(self._Width - 25,5)
+            self._Icons["done"].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)    
+    
+    
+class NotificationPage(Page):
+    _FootMsg =  ["Nav","","","Back","Toggle"]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+
+    _EasingDur = 30
+    
+    _GSNOTIFY_JOBS = "gsnotify/Jobs"
+    _GSNOTIFY_SOCKET="/tmp/gsnotify.sock"
+    _Config =None
+    _AllowedExts = [".sh",".lsp",".lua",".bin",".py",".js"]
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        
+        if "arm" in platform.machine():
+            os.system( "git config --global core.filemode false" )
+        
+    def GenList(self):
+
+        self._MyList = []
+        ## map ini to self._AList
+        files_path = glob.glob(self._GSNOTIFY_JOBS+"/*")
+        
+                
+        start_x  = 10
+        start_y  = 0
+        counter = 0 
+        for i,v in enumerate( files_path):
+            filename, file_extension = os.path.splitext(v)
+            alias_file = filename + ".alias"
+            
+            if file_extension in self._AllowedExts:
+                li = NotifyJobListItem()
+                li._Parent = self
+                li._PosX   = start_x
+                li._PosY   = start_y + counter*InfoPageListItem._Height
+                li._Width  = Width-10
+                li._Fonts["normal"] = self._ListFontObj
+                li._Fonts["small"] = MySkinManager.GiveFont("varela12")
+                
+                if IsExecutable(v):
+                    li._ReadOnly = True
+                
+                if os.path.isfile(alias_file):
+                    fp = open(alias_file, "r")
+                    alias = fp.read()
+                    alias = alias.strip()
+                    label_text = alias.decode("utf8")
+                    li.Init( label_text )
+                    fp.close()
+                else:
+                    li.Init( os.path.basename(v) )
+                li._Flag = v
+                ##li.SetSmallText( v )
+                
+                self._MyList.append(li)
+                counter += 1
+    
+    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._PosX = 11
+        ps._Parent = self
+        ps._Width = self._Width-10
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = 2
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+    def Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        #print("Click ",cur_li._Flag)
+        if IsExecutable(cur_li._Flag):
+            os.system("chmod -x "+cur_li._Flag)
+        else:
+            os.system("chmod +x "+cur_li._Flag)
+        
+        self.GenList()
+        
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False    
+        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 IsKeyStartOrA(event.key):
+            
+            self._Screen._MsgBox.SetText("Applying")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()
+            
+            pygame.time.delay(638)
+            
+            self.Click()
+            
+            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()
+
+ 
+
+    def Draw(self):
+        self.ClearCanvas()
+        self._Ps.Draw()
+
+        if len(self._MyList) > 0:
+            for i in self._MyList:
+                i.Draw()
+        
+            self._Scroller.UpdateSize( len(self._MyList)*InfoPageListItem._Height,
+                                   self._PsIndex*InfoPageListItem._Height) 
+            self._Scroller.Draw()
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = NotificationPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Notify"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+#UI lib
+from UI.constants    import RUNSYS
+from UI.keys_def     import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.confirm_page import ConfirmPage
+from UI.lang_manager import MyLangManager
+from UI.skin_manager import MySkinManager
+
+import config
+
+class PowerOffConfirmPage(ConfirmPage):
+    
+    _ConfirmText = MyLangManager.Tr("Confirm Power OFF?")
+    
+    def CheckBattery(self):
+        try:
+            f = open(config.Battery)
+        except IOError:
+            print( "PowerOFF open %s failed" % config.Battery)
+            return 0
+        else:
+            with f:
+                bat_uevent = {}
+                content = f.readlines()
+                content = [x.strip() for x in content]
+                for i in content:
+                    pis = i.split("=")
+                    if len(pis) > 1:
+                        bat_uevent[pis[0]] = pis[1]
+
+                if "POWER_SUPPLY_CAPACITY" in bat_uevent:
+                    cur_cap = int(bat_uevent["POWER_SUPPLY_CAPACITY"])
+                else:
+                    cur_cap = 0
+                
+                return cur_cap
+                    
+        return 0
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if IsKeyStartOrA(event.key):
+            if self.CheckBattery() < 20:
+                cmdpath = "feh --bg-center %s;" % MySkinManager.GiveWallpaper("gameover.png")
+            else:
+                cmdpath = "feh --bg-center %s;" % MySkinManager.GiveWallpaper("seeyou.png")
+            
+            cmdpath += "sleep 3;"
+            
+            #cmdpath += "echo 'halt -p' > /tmp/halt_cmd"
+            
+            cmdpath += "sudo halt -p"
+            pygame.event.post( pygame.event.Event(RUNSYS, message=cmdpath))
+
+
+
+class APIOBJ(object):
+
+    _StoragePage = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = PowerOffConfirmPage()
+
+        self._Page._Screen = main_screen
+        self._Page._Name ="Power OFF"
+        self._Page.Init()
+        
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    

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

@@ -0,0 +1,555 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+#import math
+#mport subprocess
+
+#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,ICON_TYPES,POWEROPT
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multilabel import MultiLabel
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+import config
+
+class ListPageSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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 = self._Parent._MyList[idx]._PosX+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 PageListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+
+    _Active  = False
+    _Value = ""
+    
+    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):
+
+        l = Label()
+        l._PosX = 10
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+        text = MyLangManager.Tr(text)
+        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
+        
+        if self._Active == True:
+            self._Parent._Icons["done"].NewCoord( self._Parent._Width-30,self._PosY+5)
+            self._Parent._Icons["done"].Draw()
+            
+        self._Labels["Text"].Draw(self._Active)
+            
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width -10
+            self._Labels["Small"]._PosY = self._PosY + (self._Height-  self._Labels["Small"]._Height)/2
+            self._Labels["Small"].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)        
+    
+
+class InfoPage(Page):
+    _FootMsg =  ["Nav","","","Back",""]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela15")
+    _AList = {}
+
+    _Time1 = 40
+    _Time2 = 120
+    _Time3 = 300
+
+    def ConvertSecToMin(self, secs):
+        sec_str = ""
+        min_str = ""
+        if secs > 60:
+            m = int(secs/60)
+            s = secs % 60
+            if m > 1:
+                min_str =  ("%d "+MyLangManager.Tr("minutes")+" ") % m
+            else:
+                min_str =  ("%d "+MyLangManager.Tr("minute")+" ") % m
+            
+            if s == 1:
+                sec_str = ("%d "+MyLangManager.Tr("second")) % s
+            elif s > 1:
+                sec_str = ("%d "+MyLangManager.Tr("seconds")) % s
+        elif secs > 0:
+            if secs > 1:
+                sec_str = ("%d "+MyLangManager.Tr("seconds")) % secs
+            else:
+                sec_str = ("%d "+MyLangManager.Tr("second")) % secs
+        
+        elif secs == 0:
+            sec_str = MyLangManager.Tr("Never")
+        
+        return min_str + sec_str
+
+    def RefreshList(self):
+        ## after GenList ,reuse
+        self._AList["time1"]["value"] = self.ConvertSecToMin(self._Time1)
+        self._AList["time2"]["value"] = self.ConvertSecToMin(self._Time2)
+        self._AList["time3"]["value"] = self.ConvertSecToMin(self._Time3)
+
+        for i,v in enumerate( self._AList ):
+            self._MyList[i].SetSmallText(  self._AList[v]["value"] )
+        
+    def GenList(self):
+
+        time1 = {}
+        time1["key"] = "time1"
+        if self._Time1 == 0:
+            time1["value"] = MyLangManager.Tr("Never")
+        else:
+            time1["value"] = "%d secs" % self._Time1
+        time1["label"] = "Screen dimming"
+        
+        time2 = {}
+        time2["key"] = "time2"
+        if self._Time2 == 0:
+            time2["value"] = MyLangManager.Tr("Never")
+        else:
+            time2["value"] = "%d secs" % self._Time2
+            
+        time2["label"] = "Screen OFF"
+
+        time3 = {}
+        time3["key"] = "time3"
+        
+        if self._Time3 == 0:
+            time3["value"] = MyLangManager.Tr("Never")
+        else:
+            time3["value"] = "%d secs" % self._Time3
+        time3["label"] = "Power OFF"
+        
+        self._AList["time1"] = time1
+        self._AList["time2"] = time2
+        self._AList["time3"] = time3
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        
+        for i,v in enumerate( self._AList):
+            #print(v)
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*PageListItem._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 = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+        
+        self.GenList()
+
+        
+    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 OnLoadCb(self):
+        self.RefreshList()
+
+    def OnReturnBackCb(self):
+        pass
+        """
+        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()
+                                        
+    def Draw(self):
+        self.ClearCanvas()
+        self._Ps.Draw()
+
+        for i in self._MyList:
+            i.Draw()
+
+class PowerOptionsPage(Page):
+    _FootMsg =  ["Nav","Detail","","Back","Select"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _InfoPage = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        last_height = 0
+
+        
+        supersaving = {}
+        supersaving["key"] = "super"
+        supersaving["label"] = "Power saving"
+        supersaving["value"] = "supersaving"
+
+        powersaving = {}
+        powersaving["key"] = "saving"
+        powersaving["label"] = "Balanced"
+        powersaving["value"] = "powersaving"
+
+        balance_saving = {}
+        balance_saving["key"] = "balance"
+        balance_saving["label"] = "Performance"
+        balance_saving["value"] = "balance_saving"
+
+        server_saving = {}
+        server_saving["key"] = "server"
+        server_saving["label"] = "Server"
+        server_saving["value"] = "server"
+        
+        
+        self._AList["supersaving"] = supersaving
+        self._AList["powersaving"] = powersaving
+        self._AList["server"]      = server_saving
+        self._AList["balance_saving"] = balance_saving
+        
+        for i,u in enumerate( ["supersaving","powersaving","server","balance_saving"] ):
+            if u not in self._AList:
+                continue
+            
+            v = self._AList[u]
+            
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._Active = False
+            li._Value = self._AList[u]["value"]
+            
+            if self._AList[u]["label"] != "":
+                li.Init(  self._AList[u]["label"] )
+            else:
+                li.Init( self._AList[u]["key"] )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        done = IconItem()
+        done._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done._MyType = ICON_TYPES["STAT"]
+        done._Parent = self
+        self._Icons["done"] = done
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+        self._InfoPage = InfoPage()
+        self._InfoPage._Screen = self._Screen
+        self._InfoPage._Name   = "Power option detail"
+        self._InfoPage.Init()
+
+    def Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._Active == True:
+            return
+        
+        for i in self._MyList:
+            i._Active = False
+
+        cur_li._Active = True
+        print(cur_li._Value)
+        with open(".powerlevel","w") as f:
+            f.write(cur_li._Value)
+
+        config.PowerLevel = cur_li._Value
+
+        if config.PowerLevel!= "supersaving":
+            os.system("sudo iw wlan0 set power_save off > /dev/null")
+        else:
+            os.system("sudo iw wlan0 set power_save on > /dev/null")
+        
+        self._Screen._MsgBox.SetText("Applying")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+
+        pygame.event.post( pygame.event.Event(POWEROPT, message=""))
+        
+        pygame.time.delay(1000)
+        
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+        with open(".powerlevel", "r") as f:
+            powerlevel = f.read()
+
+        powerlevel = powerlevel.strip()
+
+        if powerlevel == "":
+            powerlevel = "balance_saving"
+
+        for i in self._MyList:
+            if i._Value == powerlevel:
+                i._Active = True
+        
+    def OnReturnBackCb(self):
+        pass
+        """
+        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 IsKeyStartOrA(event.key):
+            self.Click()
+            
+        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["Y"]:
+            cur_li = self._MyList[self._PsIndex]
+            time1 = config.PowerLevels[cur_li._Value][0]
+            time2 = config.PowerLevels[cur_li._Value][1]
+            time3 = config.PowerLevels[cur_li._Value][2]
+            
+            self._InfoPage._Time1 = time1
+            self._InfoPage._Time2 = time2
+            self._InfoPage._Time3 = time3
+            
+            self._Screen.PushPage(self._InfoPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()            
+    
+    def Draw(self):
+
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+        
+        else:
+            if len(self._MyList) * PageListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*PageListItem._Height, self._PsIndex*PageListItem._Height)
+                self._Scroller.Draw()
+                
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()                
+
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+        
+        
+
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = PowerOptionsPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Power Options"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,294 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+#import commands
+import glob
+#from beeprint import pp
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES,RESTARTUI
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect,FileExists
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.icon_pool  import MyIconPool
+from UI.icon_item  import IconItem
+from UI.multilabel import MultiLabel
+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
+
+import config
+
+class ListPageSelector(InfoPageSelector):
+    def Draw(self):
+        idx = self._Parent._PsIndex
+        
+        if idx < len(self._Parent._MyList):
+            x = self._Parent._MyList[idx]._PosX+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 PageListItem(InfoPageListItem):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+
+    _Active  = False
+    _Value = ""
+    
+    def Draw(self):
+        
+        self._Labels["Text"]._PosY = self._PosY+ (self._Height-  self._Labels["Text"]._Height)/2
+        
+        if self._Active == True:
+            self._Parent._Icons["done"].NewCoord( self._Parent._Width-30,self._PosY+5)
+            self._Parent._Icons["done"].Draw()
+            
+        self._Labels["Text"].Draw(self._Active)
+            
+        if "Small" in self._Labels:
+            self._Labels["Small"]._PosX = self._Width - self._Labels["Small"]._Width -10
+            self._Labels["Small"]._PosY = self._PosY + (self._Height-  self._Labels["Small"]._Height)/2
+            self._Labels["Small"].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)        
+    
+class SkinsPage(Page):
+    _FootMsg =  ["Nav","","Scan","Back","Select"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = None
+    _InfoPage = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def GenList(self):
+        self._MyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        last_height = 0
+
+
+        skins = [["../skin/default","Default"]]
+        files_path = glob.glob("/home/cpi/skins/*")
+        
+        for i ,v in enumerate(files_path):
+            if os.path.isdir(v):
+                bname = os.path.basename(v)
+                print(v,bname)
+                skins.append([v,bname])
+        
+        for i,u in enumerate( skins ):            
+            #print(i,u)
+            li = PageListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + last_height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._Active = False
+            li._Value = u[0]
+            li.Init( u[1] )
+            
+            last_height += li._Height
+            
+            self._MyList.append(li)
+            
+    def Init(self):
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._BGheight) )
+
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        done = IconItem()
+        done._ImgSurf = MyIconPool.GiveIconSurface("done")
+        done._MyType = ICON_TYPES["STAT"]
+        done._Parent = self
+        self._Icons["done"] = done
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.GenList()
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        self._Scroller.SetCanvasHWND(self._HWND)
+
+    def Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._Active == True:
+            return
+
+        print(cur_li._Value)
+        
+        for i in self._MyList:
+            i._Active = False
+            
+        cur_li._Active = True
+        self._Screen._MsgBox.SetText("Applying")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+            
+        if "../skin/default" in cur_li._Value:
+            os.system("rm %s/.gameshell_skin" % os.path.expanduser('~') )
+        else:
+            os.system("echo %s > %s/.gameshell_skin" % (cur_li._Value,os.path.expanduser('~') ))
+        
+        pygame.time.delay(700)
+        pygame.event.post( pygame.event.Event(RESTARTUI, message=""))
+        
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+                        
+        for i in self._MyList:
+            i._Active = False
+        
+        for i in self._MyList:
+            if config.SKIN in i._Value:
+                i._Active = True
+        
+    def OnReturnBackCb(self):
+        pass
+        """
+        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 IsKeyStartOrA(event.key):
+            self.Click()
+            
+        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["X"]:
+            self.GenList()
+            
+            for i in self._MyList:
+                i._Active = False
+        
+            for i in self._MyList:
+                if config.SKIN in i._Value:
+                    i._Active = True
+                
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()            
+    
+    def Draw(self):
+
+        self.ClearCanvas()
+        if len(self._MyList) == 0:
+            return
+        
+        else:
+            if len(self._MyList) * PageListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*PageListItem._Height, self._PsIndex*PageListItem._Height)
+                self._Scroller.Draw()
+                
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+                    if i._PosY < 0:
+                        continue
+                    i.Draw()                
+
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor("White"))
+            
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = SkinsPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Skin selection"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*- 
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitSoundPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.SoundPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+        

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

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import sys
+
+SoundPage = None

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from sound_page import SoundPage
+
+import myvars
+
+def InitSoundPage(main_screen):
+
+    myvars.SoundPage = SoundPage()
+    
+    myvars.SoundPage._Screen = main_screen
+    myvars.SoundPage._Name = "Sound volume"
+    myvars.SoundPage.Init()

Menu/GameShell/10_Settings/Sound/sound_page.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+#from libs.roundrects import aa_round_rect
+
+import alsaaudio
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.icon_item import IconItem
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyMenuOrB
+from UI.slider     import Slider
+from UI.multi_icon_item import MultiIconItem
+from UI.skin_manager import MySkinManager
+
+from UI.icon_pool  import MyIconPool
+
+from libs.roundrects import aa_round_rect
+
+import myvars
+
+class SoundSlider(Slider):
+    OnChangeCB = None
+    
+    _Parent     = None
+    _VolumeLabel =None
+    
+    def __init__(self):
+        Slider.__init__(self)
+        
+    def Init(self):
+        self._Width = self._Parent._Width
+        self._Height = self._Parent._Height
+        
+        self._VolumeLabel = Label()
+        self._VolumeLabel.SetCanvasHWND(self._CanvasHWND)
+        self._VolumeLabel.Init("VOLUME",MySkinManager.GiveFont("EurostileBold13"))
+        self._VolumeLabel.SetColor(MySkinManager.GiveColor('Text'))
+        
+    def SetValue(self,vol):#pct 0-100
+        if vol  >= 0 and vol <= 100:
+            self._Value = vol
+        
+    def Further(self):
+        self._Value+=5
+
+        if self._Value > 100:
+            self._Value = 100
+        
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB( self._Value )
+        
+    def StepBack(self):
+        self._Value-=5
+
+        if self._Value < 0:
+            self._Value = 0
+            
+        if self.OnChangeCB != None:
+            if callable(self.OnChangeCB):
+                self.OnChangeCB( self._Value )
+    
+    def Draw(self):
+        start_x = 82
+        start_y = self._Parent._Screen._Height/2-5
+        height = 30
+        width = 4
+        seg = self._Value / 5
+
+        for i in range(0, 20):
+            rect = pygame.Rect(start_x+i*(width*2),start_y,width,height)
+            if i > seg:
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),rect, 1)
+                #aa_round_rect(self._CanvasHWND,rect, MySkinManager.GiveColor('Text'),1,1, MySkinManager.GiveColor('White'))
+            else:
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),rect, 0)   
+                #aa_round_rect(self._CanvasHWND,rect, MySkinManager.GiveColor('Text'),1,0, MySkinManager.GiveColor('White'))
+        
+        self._VolumeLabel.NewCoord(118,self._Parent._Screen._Height/2-30)
+        self._VolumeLabel.Draw(True)
+        
+        minus_box_rect = pygame.Rect(start_x- (4+6)*4,start_y,6*4,30)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),minus_box_rect, 0) 
+        
+        minus_rect     = pygame.Rect(start_x-8*4,start_y+14,2*4,2)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),minus_rect, 0) 
+        
+        plus_box_rect = pygame.Rect(start_x + 39*4 +4*4,start_y,6*4,30)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('Text'),plus_box_rect, 0) 
+        
+        cross1_rect     = pygame.Rect(start_x+39*4+4*4+2*4,start_y+14,2*4,2)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),cross1_rect, 0) 
+        cross2_rect     = pygame.Rect(start_x+39*4+4*4+2*4+3,start_y+14-3,2,2*4)
+        pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),cross2_rect, 0) 
+        
+class SoundPage(Page):
+
+    _MySlider = None
+    _FootMsg = ["Nav","","","Back","Enter"]
+
+    def Init(self):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._MySlider = SoundSlider()
+
+        self._MySlider._Parent = self        
+        self._MySlider.SetCanvasHWND(self._CanvasHWND)
+
+        self._MySlider.OnChangeCB = self.WhenSliderDrag
+
+        self._MySlider.Init()
+        
+        try:
+            m = alsaaudio.Mixer()
+            self._MySlider.SetValue(m.getvolume()[0])
+        except Exception,e:
+            print(str(e))
+            self._MySlider.SetValue(0)
+
+
+    def OnLoadCb(self):
+        try:
+            m = alsaaudio.Mixer()
+            self._MySlider.SetValue(m.getvolume()[0])
+        except Exception,e:
+            print(str(e))
+                
+    def WhenSliderDrag(self,value): ##value 0-100
+        if value < 0 or value > 100:
+            return
+        
+        m = alsaaudio.Mixer()
+        m.setvolume(int(value))
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Right"]:
+            self._MySlider.Further()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self._MySlider.StepBack()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._MySlider.Draw()
+
+        
+
+
+    

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

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+import os
+
+
+## local UI import
+from UI.page  import Page
+from UI.skin_manager import MySkinManager
+from UI.constants import ICON_TYPES,Width,Height
+from UI.icon_item import IconItem
+from UI.icon_pool import MyIconPool
+from UI.label  import Label
+from UI.util_funcs import midRect
+
+from libs.roundrects import aa_round_rect
+
+class StoragePage(Page):
+
+    _Icons = {}
+    _BGpng  = None
+    _BGwidth = 96
+    _BGheight = 73
+    _BGlabel  = None
+    _FreeLabel = None
+    
+    _BGmsg    = "%.1fGB of %.1fGB Used"
+    _DskUsg   = None
+
+    _HighColor = MySkinManager.GiveColor('High')
+    _FootMsg    = ["Nav.","","","Back",""]
+    
+    def __init__(self):
+        Page.__init__(self)
+        
+        self._Icons = {}
+
+
+    def DiskUsage(self):
+        statvfs = os.statvfs('/')
+
+        total_space = (statvfs.f_frsize * statvfs.f_blocks)/1024.0/1024.0/1024.0
+
+        avail_space = ( statvfs.f_frsize * statvfs.f_bavail) / 1024.0 / 1024.0/ 1024.0
+
+        return avail_space,total_space
+        
+    def Init(self):
+
+        self._DskUsg = self.DiskUsage()
+        
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+        
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("icon_sd")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        
+        self._BGpng.AddLabel(self._BGmsg % (self._DskUsg[1]-self._DskUsg[0], self._DskUsg[1]), MySkinManager.GiveFont("varela15"))
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+        
+        self._BGlabel = Label()
+        self._BGlabel.SetCanvasHWND(self._CanvasHWND)
+
+        usage_percent = (self._DskUsg[0]/self._DskUsg[1] )*100.0
+        
+        self._BGlabel.Init("%d%%"% int(usage_percent),MySkinManager.GiveFont("varela25"))
+        self._BGlabel.SetColor( self._HighColor )
+        
+        self._FreeLabel = Label()
+        self._FreeLabel.SetCanvasHWND(self._CanvasHWND)
+        self._FreeLabel.Init("Free",MySkinManager.GiveFont("varela13"))
+        self._FreeLabel.SetColor(self._BGlabel._Color)
+
+        
+    def OnLoadCb(self):
+        pass
+    
+    def Draw(self):
+        self.ClearCanvas()
+        
+        self._BGpng.NewCoord(self._Width/2,self._Height/2-10)
+        self._BGpng.Draw()
+        self._BGlabel.NewCoord(self._Width/2-28,self._Height/2-30)
+        self._BGlabel.Draw()
+
+        self._FreeLabel.NewCoord(self._BGlabel._PosX+10   ,self._Height/2)
+        self._FreeLabel.Draw()
+
+        #bgcolor = (238,238,238), fgcolor = (126,206,244)
+        #aa_round_rect
+        usage_percent = (self._DskUsg[0]/self._DskUsg[1] )
+        if usage_percent < 0.1:
+            usage_percent = 0.1
+
+        rect_ = midRect(self._Width/2,self._Height-30,170,17, Width,Height)
+
+        aa_round_rect(self._CanvasHWND, rect_, MySkinManager.GiveColor('Line'), 5, 0, MySkinManager.GiveColor('Line'))
+
+        
+        rect2 = midRect(self._Width/2,self._Height-30,int(170*(1.0-usage_percent)),17, Width,Height)
+
+        rect2.left = rect_.left
+        rect2.top  = rect_.top
+        
+        aa_round_rect(self._CanvasHWND,rect2, MySkinManager.GiveColor('Front'),5,0,MySkinManager.GiveColor('Front'))        
+        
+class APIOBJ(object):
+
+    _StoragePage = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._StoragePage = StoragePage()
+
+        self._StoragePage._Screen = main_screen
+        self._StoragePage._Name ="Storage"
+        self._StoragePage.Init()
+        
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._StoragePage)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+    
+
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitTimezoneListPage(main_screen)
+    
+def API(main_screen):
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.TimezoneListPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+
+

Menu/GameShell/10_Settings/Time/list_item.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import ICON_TYPES
+from UI.page   import Page
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.skin_manager import MySkinManager
+
+# a item for List
+# - - - - - - - - - - - -- 
+# | Icon  Text.....    > |
+# ------------------------
+
+import myvars # icons_path
+
+class ListItemIcon(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 ListItemLabel(Label):
+
+    _ActiveColor = MySkinManager.GiveColor('Active')
+    _Active = False
+    def Draw(self):
+
+        self._FontObj.set_bold(self._Active)
+        
+        my_text = self._FontObj.render( self._Text,True,self._Color)
+        self._CanvasHWND.blit(my_text,(self._PosX,self._PosY,self._Width,self._Height))
+
+    
+class ListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+    _MyType = ICON_TYPES["EXE"]
+    _LinkObj = None
+    _Path    = ""
+    _Active  = False
+    _Parent  = None
+    
+    _Text = ""
+    def __init__(self):
+        self._Labels = {}
+        self._Icons  = {}
+        self._Fonts  = {}
+
+
+    def Init(self,text):
+        
+        self._Text = text
+        
+        l = ListItemLabel()
+        l._PosX = 22
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+
+        if self._MyType == ICON_TYPES["DIR"]:
+            l.Init(text,self._Fonts["normal"])
+            self._Path = text
+        else:
+            l.Init(text,self._Fonts["normal"])
+            self._Path = text
+
+
+        self._Labels["Text"] = l
+        
+        
+    def NewCoord(self,x,y):
+        self._PosX = x
+        self._PosY = y
+
+    def Draw(self):
+
+        if self._MyType == ICON_TYPES["DIR"] and self._Path != "[..]":
+            self._Parent._Icons["sys"]._IconIndex = 0
+            self._Parent._Icons["sys"].NewCoord(self._PosX+12,self._PosY+ (self._Height - self._Parent._Icons["sys"]._Height)/2+self._Parent._Icons["sys"]._Height/2)
+            self._Parent._Icons["sys"].Draw()
+
+        if self._MyType == ICON_TYPES["FILE"]:
+            self._Parent._Icons["sys"]._IconIndex = 1
+            self._Parent._Icons["sys"].NewCoord(self._PosX+12,self._PosY+ (self._Height - self._Parent._Icons["sys"]._Height)/2+self._Parent._Icons["sys"]._Height/2)
+            self._Parent._Icons["sys"].Draw()
+        
+        if self._Active == True:
+            self._Labels["Text"]._Active = True
+        else:
+            self._Labels["Text"]._Active = False
+
+        
+        self._Labels["Text"]._PosY = self._PosY + (self._Height - self._Labels["Text"]._Height)/2
+            
+        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)
+
+        self._Labels["Text"].Draw()
+

Menu/GameShell/10_Settings/Time/logger.py

@@ -0,0 +1,16 @@
+import logzero
+
+def get_logger():
+    # Set a custom formatter
+    log_format = '%(color)s[%(levelname)1.1s ' \
+                    '%(asctime)s.%(msecs)03d %(module)s:%(lineno)d]' \
+                    '%(end_color)s %(message)s'
+    formatter = logzero.LogFormatter(fmt=log_format)
+    logzero.setup_default_logger(formatter=formatter)
+
+    logzero.logfile(
+        'logzero.log',
+        maxBytes=1e6,
+        backupCount=3
+    )
+    return logzero.logger

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

@@ -0,0 +1,5 @@
+
+
+TimePage = None
+TimezoneListPage = None
+

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

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from timezone_lib_list_page import TimezoneListPage
+import myvars
+
+def InitTimePage(main_screen):
+    myvars.TimePage = None
+
+def InitTimezoneListPage(main_screen):
+    myvars.TimezoneListPage = TimezoneListPage()
+    myvars.TimezoneListPage._Screen = main_screen
+    myvars.TimezoneListPage._Name   = "Timezone Selection"
+    myvars.TimezoneListPage.Init()

Menu/GameShell/10_Settings/Time/timezone_lib_list_page.py

@@ -0,0 +1,304 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import subprocess
+import pygame
+
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.multi_icon_item import MultiIconItem
+from UI.icon_pool           import MyIconPool
+from UI.scroller   import ListScroller
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+from list_item  import ListItem
+
+
+import myvars
+
+
+class TimeLibStack:
+    def __init__(self):
+        self.stack = list()
+
+    def Push(self,data):
+        if data not in self.stack:
+            self.stack.append(data)
+            return True
+        return False
+
+    def Pop(self):
+        if len(self.stack)<=0:
+            return None,False
+        return self.stack.pop(),True
+
+    def Last(self):
+        idx = len(self.stack) -1
+        if idx < 0:
+            return "/usr/share/zoneinfo/posix"
+        else:
+            return self.stack[ idx ]
+    
+    def Length(self):
+        return len(self.stack)
+
+class ListPageSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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 = self._Parent._MyList[idx]._PosX+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 TimezoneListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    _FootMsg = ["Nav","","","Back","Select"]
+    _MyList = []
+    _SwapMyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    _MyStack = None
+
+    _Scroller = None
+    
+    _BGpng = None
+    _BGwidth = 56
+    _BGheight = 70
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        self._SwapMyList = []
+        self._MyStack = TimeLibStack()
+    
+    def buildDirectoryList(self, path):
+        elements = [
+            {
+                'name': f,
+                'file_path': os.path.join(path, f),
+                'is_file': os.path.isfile(os.path.join(path, f))
+            } 
+            for f in os.listdir(path) 
+            ]
+        return elements
+
+    def SyncList(self,path):
+        
+        alist = self.buildDirectoryList(path)
+        if not alist:
+            print("buildDirectoryList empty")
+            return 
+
+        self._MyList = []
+        self._SwapMyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        hasparent = 0
+        if self._MyStack.Length() > 0:
+            hasparent = 1
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._MyType = ICON_TYPES["DIR"]
+            li.Init("[..]")
+            self._MyList.append(li)
+        
+        for i,v in enumerate(sorted(alist)):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + (i+hasparent)*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._MyType  = ICON_TYPES["FILE"]
+            
+            if not v['is_file']:
+                li._MyType = ICON_TYPES["DIR"]
+            else:
+                li._MyType  = ICON_TYPES["FILE"]
+            
+            li.Init( v['name']  )
+            li._Path = v["file_path"]
+            
+            
+            self._MyList.append(li)
+
+        for i in self._MyList:
+            self._SwapMyList.append(i)
+        
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.SyncList("/usr/share/zoneinfo/posix")
+
+        icon_for_list = MultiIconItem()
+        icon_for_list._ImgSurf = MyIconPool.GiveIconSurface("sys")
+        icon_for_list._MyType = ICON_TYPES["STAT"]
+        icon_for_list._Parent = self
+        
+        icon_for_list.Adjust(0,0,18,18,0)        
+        self._Icons["sys"] = icon_for_list
+
+
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("empty")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.AddLabel("No timezones found on system!", MyLangManager.TrFont("varela22"))
+        self._BGpng.SetLableColor(MySkinManager.GiveColor('Disabled'))
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+    def Click(self):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+
+        if cur_li._MyType == ICON_TYPES["DIR"]:
+            if cur_li._Path == "[..]":
+                self._MyStack.Pop()
+                self.SyncList( self._MyStack.Last() )
+                self._PsIndex = 0
+            else:
+                self._MyStack.Push( self._MyList[self._PsIndex]._Path )
+                self.SyncList( self._MyStack.Last() )
+                self._PsIndex = 0
+                
+        if cur_li._MyType == ICON_TYPES["FILE"]: ## set the current timezone
+            subprocess.call(['sudo', 'cp', cur_li._Path, '/etc/localtime'])
+            #copyfile(cur_li._Path, '/etc/localtime')
+            print("add" , cur_li._Path)
+            
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+
+    def Rescan(self):
+        self.SyncList("/usr/share/zoneinfo/posix")
+        self._PsIndex = 0
+        
+    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 event.key == CurKeys["Right"]:
+            self.FScrollDown(Step=5)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self.FScrollUp(Step=5)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+                                     
+        if IsKeyStartOrA(event.key):
+            self.Click()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) == 0:
+            self._BGpng.NewCoord(self._Width/2,self._Height/2)
+            self._BGpng.Draw()
+            return
+        
+        else:
+            if len(self._MyList) * ListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+            
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if False:
+                        i._Active = True
+                    else:
+                        i._Active = False
+
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                    
+                    i.Draw()
+                    
+                self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+                self._Scroller.Draw()
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if False:
+                        i._Active = True
+                    else:
+                        i._Active = False
+
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                        
+                    i.Draw()    

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

@@ -0,0 +1,334 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+import os
+import requests
+import validators
+import gobject
+
+
+## local UI import
+from UI.page  import Page
+from UI.constants import ICON_TYPES,Width,Height,RUNEVT,RUNSH
+from UI.icon_item import IconItem
+from UI.icon_pool import MyIconPool
+from UI.label  import Label
+from UI.util_funcs import midRect,CmdClean,get_git_revision_short_hash
+from UI.keys_def import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.confirm_page import ConfirmPage
+from UI.download     import Download
+from UI.download_process_page import DownloadProcessPage
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+from UI.info_page_list_item import InfoPageListItem
+
+from libs.roundrects import aa_round_rect
+from libs.DBUS       import is_wifi_connected_now
+
+import config
+
+LauncherLoc = "/home/cpi/launcher"
+
+class UpdateDownloadPage(DownloadProcessPage):
+    _MD5 = ""
+
+    def GObjectUpdateProcessInterval(self):
+        if self._Screen.CurPage() == self:
+            if self._Downloader.isFinished():
+                if self._Downloader.isSuccessful():
+                    print("Success!")
+                    # Do something with obj.get_dest()
+                    filename = self._Downloader.get_dest()
+                    
+                    if filename.endswith(".tar.gz"):                    
+                        #/home/cpi/apps/[launcher]
+                        cmdpath = "tar zxf " + CmdClean(filename) + " -C /home/cpi/ ;rm -rf "+ filename
+                        pygame.event.post( pygame.event.Event(RUNEVT, message=cmdpath))
+                        
+                    self.ReturnToUpLevelPage()
+                    self._Screen.Draw()
+                    self._Screen.SwapAndShow()
+                    
+                else:
+                    print("Download failed with the following exceptions:")
+                    for e in self._Downloader.get_errors():
+                        print(unicode(e))
+
+                    try:
+                        self._Downloader.stop()
+                    except:
+                        pass
+
+                    filename = self._Downloader.get_dest()
+                    print(filename)
+                    os.system("rm -rf %s" % CmdClean(filename))
+                    
+                    self._Screen._MsgBox.SetText("DownloadFailed")
+                    self._Screen._MsgBox.Draw()
+                    self._Screen.SwapAndShow()
+                    return False
+            else:
+                self._Value =  self._Downloader.get_progress()
+                print("Progress: %d%%" % (self._Value))
+                self._Screen.Draw()
+                self._Screen.SwapAndShow()
+                return True
+        else:
+            return False
+    
+    def StartDownload(self,url,dst_dir):
+        if validators.url(url) and os.path.isdir(dst_dir):
+            self._URL = url
+            self._DST_DIR = dst_dir
+        else:
+            self._Screen._MsgBox.SetText("Invaid")
+            self._Screen._MsgBox.Draw()
+            self._Screen.SwapAndShow()            
+            return
+        
+        self._Downloader = Download(url,dst_dir,None)
+        if self._MD5 != None:
+            if len(self._MD5) == 32:
+                self._Downloader.add_hash_verification('md5' ,self._MD5) ## hashlib provide algorithms
+
+        self._Downloader.start()
+        
+        self._DownloaderTimer = gobject.timeout_add(100, self.GObjectUpdateProcessInterval)
+
+    
+
+class UpdateConfirmPage(ConfirmPage):
+    _ConfirmText = "Confirm Update ?"
+    
+    _DownloadPage = None
+
+    _URL = ""
+    _MD5 = ""
+    _Version = ""
+    _GIT = False
+    
+    def KeyDown(self,event):
+        global LauncherLoc
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if IsKeyStartOrA(event.key):
+            if self._GIT == True:
+                cmdpath = "%s/update.sh %s" % (LauncherLoc,self._Version)
+                pygame.event.post( pygame.event.Event(RUNSH, message=cmdpath))
+                return
+            
+            if self._DownloadPage == None:
+                self._DownloadPage = UpdateDownloadPage()
+                self._DownloadPage._Screen = self._Screen
+                self._DownloadPage._Name   = "Downloading"
+                self._DownloadPage.Init()
+
+            self._DownloadPage._MD5 = self._MD5
+            self._Screen.PushPage(self._DownloadPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+            if self._URL != None and validators.url(self._URL):
+                self._DownloadPage.StartDownload(self._URL, "/tmp")
+            else:
+                print "error url  %s " % self._URL
+            
+
+    def OnReturnBackCb(self):
+        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 UpdatePage(Page):
+    _Icons = {}
+    _FootMsg = ["Nav","","Check Update","Back",""]
+
+    _ListFontObj = MyLangManager.TrFont("varela15")    
+    _ConfirmPage = None
+    _AList    = {}
+    _MyList   = []
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}    
+
+    def GenList(self):
+        
+        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"] = MySkinManager.GiveFont("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):
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._Width =  self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._ConfirmPage = UpdateConfirmPage()
+        self._ConfirmPage._Screen = self._Screen
+        self._ConfirmPage._Name  = "Update Confirm"
+        self._ConfirmPage._Parent = self
+        self._ConfirmPage.Init()
+
+        it = {}
+        it["key"] = "version"
+        it["label"] = "Version"
+        it["value"] = config.VERSION
+        self._AList["version"] = it
+        
+        self.GenList()
+        
+    def CheckUpdate(self):
+        global LauncherLoc
+        self._Screen._MsgBox.SetText("CheckingUpdate")
+        self._Screen._MsgBox.Draw()
+        self._Screen.SwapAndShow()
+
+        try:
+            r = requests.get(config.UPDATE_URL, verify=False, timeout=8)
+        except:
+            print("requests get error")
+            return
+        else:
+            if r.status_code == requests.codes.ok:
+                try:
+                    json_ = r.json()
+
+                    if "version" in json_ and "updatepath" in json_ and "md5sum" in json_:
+                        if config.VERSION != json_["version"]:
+                            
+                            self._ConfirmPage._URL = json_["updatepath"]
+                            self._ConfirmPage._MD5 = json_["md5sum"]
+                            self._ConfirmPage._GIT = False
+                            
+                            self._Screen.PushPage(self._ConfirmPage)
+                            
+                            self._Screen.Draw()
+                            self._ConfirmPage.SnapMsg(MyLangManager.Tr("ConfirmUpdateToFQ") % json_["version"] )
+                            self._Screen.SwapAndShow()
+                            
+                    elif "gitversion" in json_: ### just use git to  run update
+                        cur_dir = os.getcwd()
+                        os.chdir(LauncherLoc)
+                        current_git_version = get_git_revision_short_hash()
+                        current_git_version = current_git_version.strip("\n")
+                        current_git_version = current_git_version.strip("\t")
+                        os.chdir(cur_dir)
+                        if current_git_version != json_["gitversion"]:
+                            self._ConfirmPage._URL = None
+                            self._ConfirmPage._MD5 = None
+                            self._ConfirmPage._GIT = True
+                            self._ConfirmPage._Version = json_["gitversion"]
+                            
+                            self._Screen.PushPage(self._ConfirmPage)
+                            
+                            self._Screen.Draw()
+                            self._ConfirmPage.SnapMsg(MyLangManager.Tr("UpdateToFQ") % json_["gitversion"] )
+                            self._Screen.SwapAndShow()
+                        else:
+                            self._Screen.Draw()
+                            self._Screen._MsgBox.SetText("LauncherIsUpToDate")
+                            self._Screen._MsgBox.Draw()
+                            self._Screen.SwapAndShow()
+                            pygame.time.delay(765)
+                            
+                    return True
+                except Exception, e:
+                    print("r.json() error %s" % str(e))
+                
+            else:
+                print(" requests get error %d ", r.status_code)
+                    
+
+        return False
+    
+    def OnLoadCb(self):
+        pass
+
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if event.key == CurKeys["X"]:
+            if is_wifi_connected_now():
+                if self.CheckUpdate() == True:
+                    self._Screen.Draw()
+                    self._Screen.SwapAndShow()
+                else:
+                    self._Screen.Draw()
+                    self._Screen._MsgBox.SetText("CheckingUpdateFailed")
+                    self._Screen._MsgBox.Draw()
+                    self._Screen.SwapAndShow()
+            else:
+                self._Screen.Draw()
+                self._Screen._MsgBox.SetText("CheckWifiConnection")
+                self._Screen._MsgBox.Draw()
+                self._Screen.SwapAndShow()
+
+    def Draw(self):
+        self.ClearCanvas()
+#        self._Ps.Draw()
+
+        for i in self._MyList:
+            i.Draw()
+        
+    
+class APIOBJ(object):
+
+    _UpdatePage = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._UpdatePage = UpdatePage()
+
+        self._UpdatePage._Screen = main_screen
+        self._UpdatePage._Name = "Update Launcher"
+        self._UpdatePage.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._UpdatePage)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+    
+
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

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

@@ -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()
+
+

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,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.GiveIconSurface("lock")
+        lock_icon._CanvasHWND = self._Parent._CanvasHWND
+        lock_icon._Parent = self
+        self._Icons["lock"] = lock_icon
+        
+        done_icon = NetItemIcon()
+        done_icon._ImgSurf = MyIconPool.GiveIconSurface("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)        
+        
+

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 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()
+

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

@@ -0,0 +1,738 @@
+# -*- 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('Front')
+
+    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)
+
+
+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('Black'),(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)
+        else:
+            for i in range(0,10):
+                if is_wifi_connected_now() == True:
+                    self.ShowBox(MyLangManager.Tr("Launching"))
+                    self._Daemon.Disconnect()
+                    self._Daemon.SetForcedDisconnect(True)
+                    self._Connecting = False
+                else:
+                    break
+                
+                pygame.time.delay(100)
+                
+            if is_wifi_connected_now() == False:
+                self.ConfigWireless(password_inputed)
+            else:
+                self.ShowBox(MyLangManager.Tr("Disconnect first"))
+        
+    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()

Menu/GameShell/10_Settings/__init__.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from pygame.locals import *
+from sys import exit
+import os
+import sys
+
+from datetime import datetime
+
+import base64
+from beeprint import pp
+
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitListPage(main_screen)
+
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.ListPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+        

Menu/GameShell/10_Settings/list_item.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+
+
+## local UI import
+from UI.page   import Page
+from UI.label  import Label
+from UI.lang_manager import MyLangManager
+from UI.skin_manager import MySkinManager
+
+# a item for List
+# - - - - - - - - - - - -- 
+# | Icon  Text.....    > |
+# ------------------------
+
+import myvars # icons_path
+
+
+class ListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+
+    _LinkObj = None
+    
+    def __init__(self):
+        self._Labels = {}
+        self._Icons  = {}
+        self._Fonts  = {}
+
+    def Init(self,text):
+
+        #self._Fonts["normal"] = fonts["veramono12"]
+        
+        l = Label()
+        l._PosX = 16
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+        text = MyLangManager.Tr(text)
+        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()
+
+        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)
+    
+

Menu/GameShell/10_Settings/list_page.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+import sys
+
+from libs.roundrects import aa_round_rect
+
+## 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,FileExists
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.scroller   import ListScroller
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+from UI.info_page_selector import InfoPageSelector
+
+from list_item  import ListItem
+
+import myvars
+
+class ListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    
+    _FootMsg = ["Nav","","","Back","Enter"]
+    _MyList = []
+    _ListFontObj = MyLangManager.TrFont("varela15")
+
+    _Scroller = None
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = InfoPageSelector()
+        ps._Parent = self
+        ps._PosX = 2
+        self._Ps = ps
+        self._PsIndex = 0
+        
+        #                ""   pkgname, label
+        alist         = [["","Airplane","Airplane Mode"],
+                         ["","PowerOptions","Power Options"],
+                         ["","Wifi","Wi-Fi"],
+                         ["","Bluetooth","Bluetooth"],
+                         ["","Sound","Sound  Volume"],
+                         ["","Brightness","BackLight Brightness"],
+                         ["","Storage",""],
+                         ["","Time","Timezone"],
+                         ["","Languages","Languages"],
+                         ["","Notification","Notification"],
+                         ["","Update", "Update Launcher"],
+                         ["","Cores", "Retroarch cores manager"],
+                         ["","About",  "About"],
+                         ["","PowerOFF","Power OFF"],
+                         ["","ButtonsLayout","Buttons Layout"],
+                         #["","Skins","Theme Manager"],
+                         #["","LauncherGo","Switch to LauncherGo"],
+                         ["","Lima","GPU Driver Switch"],
+                         ["","GateWay","Network Gateway Switch"]]
+
+        start_x  = 0
+        start_y  = 0
+
+        
+        sys.path.append(myvars.basepath)# add self as import path
+        for i,v in enumerate(alist):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFontObj
+
+            if v[2] != "":
+                li.Init(v[2])
+            else:
+                li.Init(v[1])
+            
+            #if v[1] == "Wifi" or v[1] == "Sound" or v[1] == "Brightness" or v[1] == "Storage" or v[1] == "Update" or v[1] == "About" or v[1] == "PowerOFF" or v[1] == "HelloWorld":
+            if FileExists(myvars.basepath+"/"+ v[1]):
+                li._LinkObj = __import__(v[1])
+                init_cb   = getattr(li._LinkObj,"Init",None)
+                if init_cb != None:
+                    if callable(init_cb):
+                        li._LinkObj.Init(self._Screen)
+                
+                self._MyList.append(li)
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+
+    def Click(self):
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._LinkObj != None:
+            api_cb = getattr(cur_li._LinkObj,"API",None)
+            if api_cb != None:
+                if callable(api_cb):
+                    cur_li._LinkObj.API(self._Screen)
+
+        
+    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()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) * ListItem._Height > self._Height:
+            self._Ps._Width = self._Width - 11
+            
+            self._Ps.Draw()
+            
+            for i in self._MyList:
+                i.Draw()
+        
+            self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+            self._Scroller.Draw()
+        else:
+            self._Ps._Width = self._Width
+            self._Ps.Draw()
+            for i in self._MyList:
+                i.Draw()
+
+            

Menu/GameShell/10_Settings/myvars.py

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*- 
+
+from sys import exit
+import os
+import sys
+
+
+basepath = os.path.dirname(os.path.realpath(__file__))
+
+icons_path = basepath+"/icons"
+
+ListPage = None

Menu/GameShell/10_Settings/pages.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*- 
+
+from list_page import ListPage
+
+import myvars
+
+def InitListPage(main_screen):
+
+    myvars.ListPage = ListPage()
+    
+    myvars.ListPage._Screen = main_screen
+    myvars.ListPage._Name = "Setting List"
+    myvars.ListPage.Init()

Menu/GameShell/30_RetroArch.sh

@@ -0,0 +1 @@
+retroarch 

Menu/GameShell/31_CaveStory.sh

@@ -0,0 +1 @@
+retroarch -L /home/cpi/apps/emulators/nxengine_libretro.so /home/cpi/games/nxengine/cavestory/data

Menu/GameShell/32_ChocoDM/action.config

@@ -0,0 +1,6 @@
+ROM=/home/cpi/games/ChocoDM
+ROM_SO=
+EXT=wad
+LAUNCHER=chocolate-doom -iwad
+TITLE=ChocoDM
+SO_URL=

Menu/GameShell/50_PICO-8/PICO-8.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+
+#SDL_VIDEODRIVER=x11 DISPLAY=:0 ./pico-8/pico8_dyn -splore -draw_rect 32,0,256,240
+cd /home/cpi/games/PICO-8/pico-8
+SDL_VIDEODRIVER=x11 DISPLAY=:0 ./pico8_dyn -splore -draw_rect 32,0,256,240

Menu/GameShell/50_PICO-8/Post-Up.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+mkdir ~/.lexaloffle
+
+cp -rf pico-8 ~/.lexaloffle
+
+mkdir ~/.lexaloffle/pico-8/carts
+
+ln -s ~/.lexaloffle/pico-8/carts/ ~/games/PICO-8/carts
+
+touch .done
+

Menu/GameShell/50_PICO-8/compkginfo.json

@@ -0,0 +1,8 @@
+{
+"GameDir":"/home/cpi/games/PICO-8/",
+"InstallDir":"pico-8",
+"NotFoundMsg":["Please purchase the PICO-8 \n|None|varela16",
+"and copy it to the \"~/games/PICO-8\"|None|varela16"],
+"MD5":{"pico-8_0.1.11g_raspi.zip":"a3f2995cf117499f880bd964d6a0e1f2","pico-8_0.1.11g_amd64.zip":"6726141c784afd4a41be6b7414c1b932","pico-8_0.1.12_raspi.zip":"08eda95570e63089a2b9f5531503431e","pico-8_0.1.12c_raspi.zip":"1a62b0d7d4e4be65f89f23ec9757cb66","pico-8_0.1.12c2_raspi.zip":"7a878795472fa39304e9a10128c1f712","pico-8.zip":"whatever it takes"},
+"Post-Up":"bash Post-Up.sh" 
+}

Menu/GameShell/50_PICO-8/pico-8/config.txt

@@ -0,0 +1,99 @@
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+// Configuration for pico-8
+// 
+// config.txt is read on startup and saved on exit.
+// To generate the default config.txt, delete this file.
+// 
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+
+// :: Video Settings
+
+window_size 0 0 // window width, height
+screen_size 0 0 // screen width, height (stretched to window) 
+show_fps 0 // Draw frames per second in the corner
+
+
+// :: Window Settings
+
+windowed 0 // 1 to start up in windowed mode
+window_position -1 -1 // x and y position of window, or -1, -1 to let the window manager decide
+frameless 0 // 1 to use a window with no frame
+fullscreen_method 0 // 0 maximized window (linux)  1 borderless desktop-sized window  2 fullscreen
+
+
+// :: System Settings
+
+foreground_sleep_ms 1 // number of milliseconds to sleep each frame. Try 10 to conserve battery power
+
+background_sleep_ms 20 // number of milliseconds to sleep each frame when running in the background
+
+sessions 4 // number of times program has been run
+
+// (scancode) hold this key down and left-click to simulate right-click
+rmb_key 0 // 0 for none  226 for LALT
+
+// 0:off  1: ignore SDL_TEXTINPUT and use SDL_GetKeyboardState instead (mapped to a US layout)
+emulate_textinput 1 
+
+// Desktop for saving screenshots etc. Defaults to $HOME/Desktop
+desktop_path 
+
+
+
+// :: Audio Settings
+
+sound_volume 256 // 0..256
+music_volume 256 // 0..256
+mix_buffer_size 1024 // usually 1024. Try 2048 if you get choppy sound
+
+
+// :: 
+
+version 0.1.11g
+
+
+// Location of pico-8's root folder
+root_path /home/cpi/.lexaloffle/pico-8/carts/
+
+
+// Location of cartridge save data
+cdata_path /home/cpi/.lexaloffle/pico-8/cdata/
+
+
+// Specify which player index joystick control begins at (0..7)
+joystick_index 0
+
+
+// Custom keyboard scancodes for buttons. player0 0..6, player1 0..5
+button_keys 0 0 0 0 13 14 0 0 0 0 0 0 0 
+
+// Play notes as they are plotted in frequency mode
+live_notes 0
+
+// iff 1: when using keyboard cursor, snap to closest pixel / map cel
+cursor_snap 0
+
+// maximum length of gif in seconds (1..120, default 8)
+gif_len 8
+
+// 0 classic  1 dark blue background in code editor
+gui_theme 0
+
+// scale of screenshots and gifs // 2 means 256x256
+screenshot_scale 3
+gif_scale 2
+
+// when 1 can enter glyphs using shift-A..Z
+shift_glyphs 1
+
+// 0 for off. 1 to notify whenever unsaved changes are backed up
+show_backup_messages 1
+
+// 0 for off. 1 to allow control of a cart's framerate due to host machine's cpu capacity (recommended)
+host_framerate_control 1
+
+// filter splore content
+// 0 for no filter (18+)  1 medium (13+)  2 maximum (kid-friendly)
+content_filter 1
+

Menu/GameShell/50_PICO-8/pico-8/log.txt

@@ -0,0 +1,90 @@
+codo_init
+  platform: Linux
+  Found config.txt
+  
+    01 window_size 0 0 // window width, height
+    02 screen_size 0 0 // screen width, height (stretched to window) 
+    03 show_fps 0 // Draw frames per second in the corner
+    04 windowed 0 // 1 to start up in windowed mode
+    05 window_position -1 -1 // x and y position of window, or -1, -1 to let the window manager decide
+    new window position: -1, -1
+    06 frameless 0 // 1 to use a window with no frame
+    07 fullscreen_method 1 // 0 maximized window (linux)  1 borderless desktop-sized window  2 fullscreen
+    08 foreground_sleep_ms 1 // number of milliseconds to sleep each frame. Try 10 to conserve battery power
+    09 background_sleep_ms 20 // number of milliseconds to sleep each frame when running in the background
+    10 sessions 3 // number of times program has been run
+    11 rmb_key 0 // 0 for none  226 for LALT
+    12 emulate_textinput 1 
+    13 desktop_path 
+    14 sound_volume 256 // 0..256
+    15 music_volume 256 // 0..256
+    16 mix_buffer_size 1024 // usually 1024. Try 2048 if you get choppy sound
+    17 version 0.1.11g
+    18 root_path /home/cpi/.lexaloffle/pico-8/carts/
+    19 cdata_path /home/cpi/.lexaloffle/pico-8/cdata/
+    20 joystick_index 0
+    21 button_keys 0 0 0 0 0 0 0 0 0 0 0 0 0 
+    22 live_notes 0
+    23 cursor_snap 0
+    24 gif_len 8
+    25 gui_theme 0
+    26 screenshot_scale 3
+    27 gif_scale 2
+    28 shift_glyphs 1
+    29 show_backup_messages 1
+    30 host_framerate_control 1
+    31 content_filter 1
+  
+  codo_system_init
+  Compiled against SDL version: 2.0.7
+  Linked against SDL version:   2.0.5
+  Built-in video drivers:   0 x11   1 wayland   2 dummy  
+  Current video driver: x11
+  Built-in render drivers:
+  Renderer opengl:
+    Flags: 0x0000000E ( |  | )
+    Texture formats (1): ARGB8888
+  Renderer opengles2:
+    Flags: 0x0000000E ( |  | )
+    Texture formats (4): ARGB8888, ABGR8888, RGB888, BGR888
+  Renderer software:
+    Flags: 0x00000009 ( | )
+    Texture formats (8): ARGB8888, ABGR8888, RGBA8888, BGRA8888, RGB888, BGR888, RGB565, RGB555
+  codo_reset_timer
+  codo_gui_init
+  codo_keys_init
+  codo_text_init
+  codo_video_init
+  codo_mouse_init
+  codo_joystick_init
+  Reading controller mappings: /home/cpi/.lexaloffle/pico-8/sdl_controllers.txt
+  searching for joysticks
+    found 0 joysticks
+  ok
+ok
+codo_load_pod: /home/cpi/apps/Menu/50_PICO-8/pico8.dat ok 
+codo_set_screen 128 128 8 100
+ set pixel_perfect 1
+ window size: 640 480
+codo_plat_pi: forcing fullscreen mode
+Current renderer:
+  Renderer opengl:
+    Flags: 0x0000000A ( | )
+    Texture formats (5): ARGB8888, YV12, IYUV, 0x3231564e, 0x3132564e
+    Max Texture Size: 8192x8192
+codo_sound_init mix_buffer_size: 1024
+codo_sound_init
+SDL_INIT_AUDIO ok
+SDL_OpenAudio ok
+Built-in audio drivers: 0 pulseaudio 1 alsa 2 sndio 3 dsp 4 disk 5 dummy
+Current audio driver: alsa
+codo_exit
+  cmusic_stop
+  codo_main_exit
+  codo_config_save
+  codo_sound_exit
+  codo_video_exit
+  codo_joystick_exit
+  codo_system_exit
+  codo_items_created: 1023
+ok

Menu/GameShell/50_PICO-8/pico-8/sdl_controllers.txt

@@ -0,0 +1 @@
+// add SDL2 game controller mappings to this file

Menu/GameShell/90_Reload UI.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exit 0

Menu/GameShell/97_Music Player/__init__.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+## local UI import
+import pages
+import myvars
+
+def Init(main_screen):
+    pages.InitPoller()
+
+    pages.InitListPage(main_screen)
+    pages.InitMusicLibPage(main_screen)
+    pages.InitSpectrumPage(main_screen)
+    
+def API(main_screen):
+    
+    if main_screen !=None:
+        main_screen.PushCurPage()
+        main_screen.SetCurPage(myvars.PlayListPage)
+        main_screen.Draw()
+        main_screen.SwapAndShow()
+
+

Menu/GameShell/97_Music Player/list_item.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import ICON_TYPES
+from UI.page   import Page
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.skin_manager import MySkinManager
+
+# a item for List
+# - - - - - - - - - - - -- 
+# | Icon  Text.....    > |
+# ------------------------
+
+import myvars # icons_path
+
+class ListItemIcon(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 ListItemLabel(Label):
+
+    _ActiveColor  = MySkinManager.GiveColor('Active')
+    _Active = False
+    def Draw(self):
+
+        self._FontObj.set_bold(self._Active)
+        
+        """
+        if self._Active == True:
+            my_text = self._FontObj.render( self._Text,True,self._ActiveColor)
+        else:
+            my_text = self._FontObj.render( self._Text,True,self._Color)
+        """
+        
+        my_text = self._FontObj.render( self._Text,True,self._Color)
+        self._CanvasHWND.blit(my_text,(self._PosX,self._PosY,self._Width,self._Height))
+
+    
+class ListItem(object):
+    _PosX = 0
+    _PosY = 0
+    _Width = 0
+    _Height = 30
+
+    _Labels = {}
+    _Icons  = {}
+    _Fonts  = {}
+    _MyType = ICON_TYPES["EXE"]
+    _LinkObj = None
+    _Path    = ""
+    _Active  = False
+    _Playing = False ## play or pause
+    _PlayingProcess = 0 # 0 - 100
+    _Parent  = None
+    
+    _Text = ""
+    def __init__(self):
+        self._Labels = {}
+        self._Icons  = {}
+        self._Fonts  = {}
+
+
+    def Init(self,text):
+
+        #self._Fonts["normal"] = fonts["veramono12"]
+        self._Text = text
+        
+        l = ListItemLabel()
+        l._PosX = 22
+        l.SetCanvasHWND(self._Parent._CanvasHWND)
+
+        if self._MyType == ICON_TYPES["DIR"]:
+            l.Init(text,self._Fonts["normal"])
+            self._Path = text
+        else:
+            l.Init(text,self._Fonts["normal"])
+            self._Path = text
+
+
+        self._Labels["Text"] = l
+        
+        
+    def NewCoord(self,x,y):
+        self._PosX = x
+        self._PosY = y
+
+    def Draw(self):
+
+        if self._MyType == ICON_TYPES["DIR"] and self._Path != "[..]":
+            self._Parent._Icons["sys"]._IconIndex = 0
+            self._Parent._Icons["sys"].NewCoord(self._PosX+12,self._PosY+ (self._Height - self._Parent._Icons["sys"]._Height)/2+self._Parent._Icons["sys"]._Height/2)
+            self._Parent._Icons["sys"].Draw()
+
+        if self._MyType == ICON_TYPES["FILE"]:
+            self._Parent._Icons["sys"]._IconIndex = 1
+            self._Parent._Icons["sys"].NewCoord(self._PosX+12,self._PosY+ (self._Height - self._Parent._Icons["sys"]._Height)/2+self._Parent._Icons["sys"]._Height/2)
+            self._Parent._Icons["sys"].Draw()
+        
+        if self._Active == True:
+            self._Labels["Text"]._Active = True
+        else:
+            self._Labels["Text"]._Active = False
+
+        
+        self._Labels["Text"]._PosY = self._PosY + (self._Height - self._Labels["Text"]._Height)/2
+            
+        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)
+
+        if self._Playing == True:
+            self._Labels["Text"]._Active =True
+            self._Labels["Text"].Draw()
+            #_rect = midRect(10,self._PosY+15,10,10,self._Parent._Width,self._Parent._Height)
+            #aa_round_rect(self._Parent._CanvasHWND,_rect,(0,0,0),3,0,(0,0,0))
+            #pygame.draw.polygon(self._Parent._CanvasHWND, (0,0,0), [[6, self._PosY+7], [11, self._PosY+14],[6, self._PosY+21]], 2)
+            
+            if self._PlayingProcess > 0:
+                seek_posx = int(self._Width * self._PlayingProcess/100.0)
+                pygame.draw.line(self._Parent._CanvasHWND,MySkinManager.GiveColor('Active'),(self._PosX,self._PosY+self._Height-2),(self._PosX+seek_posx,self._PosY+self._Height-2),2)   
+
+        else:
+            self._Labels["Text"].Draw()
+

Menu/GameShell/97_Music Player/mpd_spectrum_page.py

@@ -0,0 +1,420 @@
+# -*- coding: utf-8 -*- 
+
+import os
+import time
+import pygame
+
+import numpy
+import math
+
+import gobject
+
+from beeprint import pp
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.icon_item import IconItem
+from UI.icon_pool  import MyIconPool
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+from threading  import Thread
+
+from list_item  import ListItem
+
+import myvars
+
+class PIFI(object):
+    _MPD_FIFO = "/tmp/mpd.fifo"
+    _SAMPLE_SIZE = 1024
+    _SAMPLING_RATE = 44100
+    _FIRST_SELECTED_BIN = 5
+    _NUMBER_OF_SELECTED_BINS = 1024
+
+    _samples_buffer = None
+    
+    def __init__(self):
+        self.sampleSize = self._SAMPLE_SIZE
+        self.samplingRate = self._SAMPLING_RATE
+        
+    def GetSpectrum(self,fifoFile,trim_by=4,log_scale=False,div_by=100):
+        try:
+            rawSamples = os.read(fifoFile,self.sampleSize)    # will return empty lines (non-blocking)
+            if len(rawSamples) < 1:
+#               print("Read error")
+                pass
+            else:
+                self._samples_buffer = rawSamples
+        except Exception,e:
+            pass
+
+        if self._samples_buffer == None:
+            return ""
+        
+        data = numpy.fromstring(self._samples_buffer, dtype=numpy.int16)
+
+        data = data * numpy.hanning(len(data))
+
+        left,right = numpy.split(numpy.abs(numpy.fft.fft(data)),2)
+        spec_y     = numpy.add(left,right[::-1])
+
+        if log_scale:
+            spec_y=numpy.multiply(20,numpy.log10(spec_y))
+        if trim_by:
+            i=int((self.sampleSize/2)/trim_by)
+            spec_y=spec_y[:i]
+        if div_by:
+            spec_y=spec_y/float(div_by)
+        
+        return spec_y
+    
+    
+class MPDSpectrumPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    _FootMsg = ["Nav","","","Back",""]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("veramono12")
+    _SongFont = MyLangManager.TrFont("notosanscjk12")
+    _PIFI   =  None
+    _FIFO   = None
+    _Color  = MySkinManager.GiveColor('Front')
+    _GobjectIntervalId = -1
+    _Queue = None
+    _KeepReading = True
+    _ReadingThread = None
+    
+    _BGpng = None
+    _BGwidth = 320
+    _BGheight = 200
+
+    _SheepHead = None
+    _SheepHeadW = 69
+    _SheepHeadH = 66
+
+    _SheepBody = None
+    _SheepBodyW = 105
+    _SheepBodyH = 81
+
+    _RollCanvas = None
+    _RollW     = 180
+    _RollH     = 18
+    
+    _freq_count = 0
+    _head_dir = 0
+
+    _Neighbor = None
+
+
+    _bby  = []
+    _bbs  = []
+    _capYPositionArray = []
+    _frames = 0
+    read_retry = 0
+    _queue_data = []
+    _vis_values = []
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        self._PIFI = PIFI()
+            
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+        self._RollCanvas = pygame.Surface(( self._RollW,self._RollH))
+        
+        """
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("sheep_bg")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+        
+        self._SheepHead = IconItem()
+        self._SheepHead._ImgSurf = MyIconPool.GiveIconSurface("sheep_head")
+        self._SheepHead._MyType = ICON_TYPES["STAT"]
+        self._SheepHead._Parent = self
+        self._SheepHead.Adjust(0,0,self._SheepHeadW,self._SheepHeadH,0)
+
+        self._SheepBody = IconItem()
+        self._SheepBody._ImgSurf = MyIconPool.GiveIconSurface("sheep_body")
+        self._SheepBody._MyType = ICON_TYPES["STAT"]
+        self._SheepBody._Parent = self
+        self._SheepBody.Adjust(0,0,self._SheepBodyW,self._SheepBodyH,0)
+        """
+        
+        self._cwp_png = IconItem()
+        self._cwp_png._ImgSurf = MyIconPool.GiveIconSurface("tape")
+        self._cwp_png._MyType = ICON_TYPES["STAT"]
+        self._cwp_png._Parent = self
+        self._cwp_png.Adjust(0,0,79,79,0)
+
+
+        self._song_title = Label()
+        self._song_title.SetCanvasHWND(self._RollCanvas)
+        self._song_title.Init("Untitled",self._SongFont,MySkinManager.GiveColor('White'))
+
+
+        self._title = Label()
+        self._title.SetCanvasHWND(self._CanvasHWND)
+        self._title.Init("Title:",self._ListFont,MySkinManager.GiveColor('White'))
+
+        self._time = Label()
+        self._time.SetCanvasHWND(self._CanvasHWND)
+        self._time.Init("Time:",self._ListFont,MySkinManager.GiveColor('White'))        
+
+
+        self._time2 = Label()
+        self._time2.SetCanvasHWND(self._CanvasHWND)
+        self._time2.Init("00:00-00:00", self._ListFont,
+                         MySkinManager.GiveColor('White'))
+
+        
+        self.Start()
+                
+    def Start(self):
+
+        if self._Screen.CurPage() != self:
+            return
+        
+        try:
+            self._FIFO = os.open(self._PIFI._MPD_FIFO, os.O_RDONLY | os.O_NONBLOCK)
+            
+            t = Thread(target=self.GetSpectrum)
+            t.daemon = True # thread dies with the program
+            t.start()
+            self._ReadingThread = t
+            
+        except IOError:
+            print("open %s failed"%self._PIFI._MPD_FIFO)
+            self._FIFO = None
+            return
+
+
+    def GetSpectrum(self):
+        while self._KeepReading and self._FIFO != None:
+            raw_samples = self._PIFI.GetSpectrum(self._FIFO)
+            if len(raw_samples) < 1:
+                #print("sleeping... 0.01")
+                time.sleep(0.01)
+                self.read_retry+=1
+                if self.read_retry > 20:
+                    os.close(self._FIFO)
+                    self._FIFO = os.open(self._PIFI._MPD_FIFO, os.O_RDONLY | os.O_NONBLOCK)
+                    self.read_retry = 0
+                
+                self.Playing()
+                
+            else:
+                self.read_retry = 0
+                self._queue_data = raw_samples
+                self.Playing()        
+        
+
+    def Playing(self):
+        
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+
+
+    def ClearCanvas(self):
+        self._CanvasHWND.fill(MySkinManager.GiveColor('Black'))
+
+    def SgsSmooth(self):
+        passes = 1
+        points = 3
+        origs = self._bby[:]
+        for p in range(0,passes):
+            pivot = int(points/2.0)
+            
+            for i in range(0,pivot):
+                self._bby[i] = origs[i]
+                self._bby[ len(origs) -i -1 ] = origs[ len(origs) -i -1 ]
+
+            smooth_constant = 1.0/(2.0*pivot+1.0)
+            for i in range(pivot, len(origs)-pivot):
+                _sum = 0.0
+                for j in range(0,(2*pivot)+1):
+                    _sum += (smooth_constant * origs[i+j-pivot]) +j -pivot
+
+                self._bby[i] = _sum
+
+            if p < (passes - 1):
+                origs = self._bby[:]
+    
+    def OnLoadCb(self):
+        if self._Neighbor != None:
+            pass
+        
+        if self._KeepReading == False:
+            self._KeepReading = True
+        
+        if self._FIFO == None:
+            self.Start()
+            
+    
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            try:
+                os.close(self._FIFO)
+                self._FIFO = None
+                    
+            except Exception, e:
+                print(e)
+                
+            self._KeepReading = False
+            self._ReadingThread.join()
+            self._ReadingThread = None
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        
+    def Draw(self):
+        self.ClearCanvas()
+        self._frames+=1
+        
+        bw = 10
+        gap = 2
+        margin_bottom = 72
+
+        spects = None
+        meterNum =  self._Width / float(bw +gap )  ## 320/12= 26
+        meter_left = meterNum - int(meterNum)
+        meter_left = meter_left*int(bw+gap)
+        margin_left = meter_left / 2 + gap
+        meterNum = int(meterNum)
+        
+        self._cwp_png.NewCoord(43,159)
+        self._cwp_png.Draw()
+
+        if self._Neighbor != None:
+            if self._Neighbor._CurSongName != "":
+                self._song_title.SetText(self._Neighbor._CurSongName)
+            if self._Neighbor._CurSongTime != "":
+                times = self._Neighbor._CurSongTime
+                times_ = times.split(":")
+                if len(times_)> 1:
+                    cur = int(times_[0])
+                    end = int(times_[1])
+                    if cur > 3600:
+                        cur_text = time.strftime('%H:%M:%S', time.gmtime(cur))
+                    else:
+                        cur_text = time.strftime('%M:%S', time.gmtime(cur))
+
+                    if end > 3600:
+                        end_text = time.strftime('%H:%M:%S', time.gmtime(end))
+                    else:
+                        end_text = time.strftime('%M:%S', time.gmtime(end))
+                else:
+                    cur_text = ""
+                    end_text = times
+                
+                self._time2.SetText(cur_text+"-"+end_text)
+                
+                
+        self._title.NewCoord(90,167)
+        self._title.Draw()
+
+        self._time.NewCoord(90,140)
+        self._time.Draw()
+
+        self._time2.NewCoord(135,140)
+        self._time2.Draw()
+    
+        if self._RollCanvas != None:
+#            self._RollCanvas.fill((111,22,33))
+            self._RollCanvas.fill(MySkinManager.GiveColor('Black'))
+            if self._song_title._Width > self._RollW:
+                if (self._song_title._PosX + self._song_title._Width) > self._RollW and self._frames % 30 == 0:
+                    self._song_title._PosX -= 1
+                elif (self._song_title._PosX + self._song_title._Width) <= self._RollW and self._frames % 30 == 0:
+                    self._song_title._PosX  = 0
+            else:
+                self._song_title._PosX = 0
+            
+            self._song_title.Draw()
+            
+            self._CanvasHWND.blit(self._RollCanvas,(135,165,self._RollW,self._RollH))
+        
+        
+        try:
+            spects = self._queue_data
+            if len(spects) == 0:
+                return
+#            print("spects:",spects)
+            
+            step = int( round( len( spects ) / meterNum) )
+#            print(len(spects))
+            self._bbs = []
+            a = numpy.logspace(0, 1, num=meterNum,endpoint=True)
+            
+            for i in range(0,meterNum):
+                index = int(a[i] * step)
+                total = 0
+                
+                value = spects[index]
+                self._bbs.append(value)
+            
+            if len(self._bby) < len(self._bbs):
+                self._bby = self._bbs
+            elif len(self._bby) == len(self._bbs):
+                for i in range(0,len(self._bbs)):
+                    self._bby[i] = (self._bby[i]+self._bbs[i])/2
+                    
+            self.SgsSmooth()
+            
+            for i in range(0,meterNum):
+                value = self._bby[ i ]
+                if math.isnan(value) or math.isinf(value):
+                    value = 0
+
+                value = value/32768.0
+                value = value * 123
+                value = value %  (self._Height-gap-margin_bottom)
+                
+                if len(self._vis_values) < len(self._bby):
+                    self._vis_values.append(value)
+                elif len(self._vis_values) == len(self._bby):
+                    if self._vis_values[i] < value:
+                        self._vis_values[i] = value
+
+
+        except Exception,e:
+            print(e)
+            return
+        else: # got line
+            if len(self._vis_values) == 0:
+                return
+
+            for i in range(0,meterNum):
+                value = self._vis_values[i]
+         
+                if len(self._capYPositionArray) < round(meterNum):
+                    self._capYPositionArray.append(value)
+
+                if value < self._capYPositionArray[i]:
+                    self._capYPositionArray[i]-=0.5
+                else:
+                    self._capYPositionArray[i] = value
+
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),(i*(bw+gap)+margin_left,self._Height-gap-self._capYPositionArray[i]-margin_bottom,bw,gap),0)
+                
+                pygame.draw.rect(self._CanvasHWND,MySkinManager.GiveColor('White'),(i*(bw+gap)+margin_left,self._Height-value-gap-margin_bottom,bw,value+gap),0)
+                
+                self._vis_values[i] -= 2       
+
+
+    

Menu/GameShell/97_Music Player/music_lib_list_page.py

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.multi_icon_item import MultiIconItem
+from UI.icon_pool           import MyIconPool
+from UI.scroller   import ListScroller
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+from list_item  import ListItem
+
+
+import myvars
+
+
+class MusicLibStack:
+    def __init__(self):
+        self.stack = list()
+
+    def Push(self,data):
+        if data not in self.stack:
+            self.stack.append(data)
+            return True
+        return False
+
+    def Pop(self):
+        if len(self.stack)<=0:
+            return None,False
+        return self.stack.pop(),True
+
+    def Last(self):
+        idx = len(self.stack) -1
+        if idx < 0:
+            return "/"
+        else:
+            return self.stack[ idx ]
+    
+    def Length(self):
+        return len(self.stack)
+
+class ListPageSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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 = self._Parent._MyList[idx]._PosX+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 MusicLibListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    _FootMsg = ["Nav","","Scan","Back","Add to Playlist"]
+    _MyList = []
+    _SwapMyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+    _MyStack = None
+
+    _Scroller = None
+    
+    _BGpng = None
+    _BGwidth = 56
+    _BGheight = 70
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        self._SwapMyList = []
+        self._MyStack = MusicLibStack()
+        
+    def SyncList(self,path):
+        if myvars.Poller == None:
+            return
+        
+        alist = myvars.Poller.listfiles(path)
+        if alist == False:
+            print("listfiles return false")
+            return 
+
+        self._MyList = []
+        self._SwapMyList = []
+        
+        start_x  = 0
+        start_y  = 0
+        hasparent = 0
+        if self._MyStack.Length() > 0:
+            hasparent = 1
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._MyType = ICON_TYPES["DIR"]
+            li._Parent = self
+            li.Init("[..]")
+            self._MyList.append(li)
+        
+        for i,v in enumerate(sorted(alist)):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + (i+hasparent)*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+            li._MyType  = ICON_TYPES["FILE"]
+            li._Parent  = self
+            
+            if "directory" in v:
+                li._MyType = ICON_TYPES["DIR"]
+                dir_base_name = os.path.basename(v["directory"])
+                li.Init(  dir_base_name )
+                li._Path = v["directory"] 
+            elif "file" in v:
+                bname = os.path.basename(v["file"])
+                li.Init( bname  )
+                li._Path = v["file"]
+                
+            else:
+                li.Init("NoName")
+            
+            self._MyList.append(li)
+
+        for i in self._MyList:
+            self._SwapMyList.append(i)
+        
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.SyncList("/")
+
+        icon_for_list = MultiIconItem()
+        icon_for_list._ImgSurf = MyIconPool.GiveIconSurface("sys")
+        icon_for_list._MyType = ICON_TYPES["STAT"]
+        icon_for_list._Parent = self
+        
+        icon_for_list.Adjust(0,0,18,18,0)        
+        self._Icons["sys"] = icon_for_list
+
+
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("empty")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.AddLabel(MyLangManager.Tr("Please upload data over Wi-Fi"), MyLangManager.TrFont("varela22"))
+        self._BGpng.SetLableColor(MySkinManager.GiveColor('Disabled'))
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+    def Click(self):
+        self.RefreshPsIndex()
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+
+        if cur_li._MyType == ICON_TYPES["DIR"]:
+            if cur_li._Path == "[..]":
+                self._MyStack.Pop()
+                self.SyncList( self._MyStack.Last() )
+                self._PsIndex = 0
+            else:
+                self._MyStack.Push( self._MyList[self._PsIndex]._Path )
+                self.SyncList( self._MyStack.Last() )
+                self._PsIndex = 0
+                
+        if cur_li._MyType == ICON_TYPES["FILE"]: ## add to playlist only
+            myvars.Poller.addfile(cur_li._Path)
+            myvars.PlayListPage.SyncList()            
+            print("add" , cur_li._Path)
+            
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+
+    def Rescan(self):
+        self.SyncList("/")
+        self._PsIndex = 0
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key) or event.key == CurKeys["Left"]:
+            
+            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["Right"]:
+            self.FScrollDown(Step=5)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Left"]:
+            self.FScrollUp(Step=5)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        """
+        
+        if event.key == CurKeys["X"]:
+            self.Rescan()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+                                     
+        if IsKeyStartOrA(event.key):
+            self.Click()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+
+        """
+        start_x = 0
+        start_y = 0
+        counter = 0
+        
+        self._MyList = []
+        
+        for i,v in enumerate(self._SwapMyList):
+            if myvars.PlayListPage.InPlayList(v._Path):
+                v._Active = True
+            else:
+                v._Active = False
+
+            if v._Active == False:
+                v.NewCoord(start_x, start_y+counter* ListItem._Height)
+                counter+=1
+                self._MyList.append(v)
+        """
+
+        if len(self._MyList) == 0:
+            self._BGpng.NewCoord(self._Width/2,self._Height/2)
+            self._BGpng.Draw()
+            return
+        
+        else:
+            if len(self._MyList) * ListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+            
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if myvars.PlayListPage.InPlayList(i._Path):
+                        i._Active = True
+                    else:
+                        i._Active = False
+
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                    
+                    i.Draw()
+                    
+                self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+                self._Scroller.Draw()
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if myvars.PlayListPage.InPlayList(i._Path):
+                        i._Active = True
+                    else:
+                        i._Active = False
+
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                        
+                    i.Draw()    

Menu/GameShell/97_Music Player/myvars.py

@@ -0,0 +1,8 @@
+
+
+Poller = None # MPD Poller
+PlayListPage = None
+MusicLibListPage = None
+
+SpectrumPage = None
+

Menu/GameShell/97_Music Player/pages.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*- 
+
+from libs.MPD import poller
+
+from play_list_page      import PlayListPage
+from music_lib_list_page import MusicLibListPage
+from mpd_spectrum_page   import MPDSpectrumPage
+import myvars
+
+from config import MPD_socket
+
+def InitPoller():
+    try:
+        myvars.Poller = poller.MPDPoller(host=MPD_socket)
+        myvars.Poller.connect()
+    except:
+        myvars.Poller = None
+        
+
+def InitMusicLibPage(main_screen):
+    myvars.MusicLibListPage = MusicLibListPage()
+    myvars.MusicLibListPage._Screen = main_screen
+    myvars.MusicLibListPage._Name   = "Music Library"
+    myvars.MusicLibListPage.Init()
+
+def InitListPage(main_screen):
+
+    myvars.PlayListPage = PlayListPage()
+    
+    myvars.PlayListPage._Screen = main_screen
+    myvars.PlayListPage._Name = "Play List"
+    myvars.PlayListPage.Init()
+
+def InitSpectrumPage(main_screen):
+    myvars.SpectrumPage = MPDSpectrumPage()
+    myvars.SpectrumPage._Screen = main_screen
+    myvars.SpectrumPage._Name   = "GameShell RTA"
+    myvars.SpectrumPage.Init()

Menu/GameShell/97_Music Player/play_list_page.py

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+import gobject
+
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.icon_item import IconItem
+from UI.label  import Label
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.icon_pool  import MyIconPool
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+from UI.scroller   import ListScroller
+
+from list_item  import ListItem
+
+import myvars
+
+class ListPageSelector(PageSelector):
+    _BackgroundColor = MySkinManager.GiveColor('Front')
+
+    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)-1):
+            idx = len(self._Parent._MyList)
+            if idx > 0:
+                idx -=1
+            elif idx == 0: #Nothing
+                return
+
+        x = self._Parent._MyList[idx]._PosX+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 PlayListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    _FootMsg = ["Nav","Remove","RTA","Back","Play/Pause"]
+    _MyList = []
+    _ListFont = MyLangManager.TrFont("notosanscjk15")
+
+    _Scroller = None
+    _CurSongTime="0:0"
+    
+    _BGpng  = None
+    _BGwidth = 75
+    _BGheight = 70
+
+    _Scrolled = 0
+
+    _CurSongName = ""
+    
+    def __init__(self):
+        self._Icons = {}
+        Page.__init__(self)
+        self._CanvasHWND = None
+        self._MyList = []
+
+    def SyncList(self):
+        self._MyList = []
+        start_x  = 0
+        start_y  = 0
+        if myvars.Poller == None:
+            return
+        
+        play_list = myvars.Poller.playlist()
+        for i,v in enumerate(play_list):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+
+            if "title" in v:
+                if isinstance(v["title"], (list,)):
+                    li.Init(" | ".join(v["title"]))
+                else:
+                    li.Init( v["title"])
+                
+                if "file" in v:
+                    li._Path = v["file"]
+                
+            elif "file" in v:
+                li.Init(os.path.basename(v["file"]))
+                li._Path = v["file"] 
+            else:
+                li.Init("NoName")
+
+            li._Labels["Text"]._PosX = 7
+            self._MyList.append(li)
+
+            
+        self.SyncPlaying()
+
+    def GObjectInterval(self): ## 250 ms
+        self.SyncPlaying()
+        
+        if self._Screen.CurPage() == self:
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        return True
+    
+    def SyncPlaying(self):
+        if myvars.Poller == None:
+            return
+        
+        current_song = myvars.Poller.poll()
+        
+        
+        for i ,v in enumerate(self._MyList):
+            self._MyList[i]._Playing = False
+            self._MyList[i]._PlayingProcess = 0
+            
+        if current_song != None:
+            if "song" in current_song:
+                posid = int(current_song["song"])
+                if posid < len(self._MyList): # out of index
+                    self._CurSongName = self._MyList[posid]._Text
+                    
+                    if "state" in current_song:
+                        if current_song["state"] == "stop":
+                            self._MyList[posid]._Playing = False
+                        else:
+                            self._MyList[posid]._Playing = True
+                    if "time" in current_song:
+                        self._CurSongTime = current_song["time"]
+                        times_ = current_song["time"].split(":")
+                        if len(times_)> 1:
+                            cur = float(times_[0])
+                            end = float(times_[1])
+                            pros = int((cur/end)*100.0)
+                            self._MyList[posid]._PlayingProcess = pros
+                            
+                
+    def InPlayList(self,path):
+        for i,v in enumerate(self._MyList):
+            if v._Path == path:
+                return True
+    
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.SyncList()
+        gobject.timeout_add(850,self.GObjectInterval)
+
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool.GiveIconSurface("heart")
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.AddLabel(MyLangManager.Tr("my favorite music"), MyLangManager.TrFont("varela18"))
+        self._BGpng.SetLableColor(MySkinManager.GiveColor('Disabled'))
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.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
+            self._Scrolled +=1
+
+    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
+            self._Scrolled -=1
+
+    def SyncScroll(self):# show where it left
+        if self._Scrolled == 0:
+            return
+
+        if self._PsIndex < len(self._MyList):
+            cur_li = self._MyList[self._PsIndex]
+            if self._Scrolled > 0:
+                if cur_li._PosY < 0:
+                    for i in range(0, len(self._MyList)):
+                        self._MyList[i]._PosY += self._Scrolled * self._MyList[i]._Height
+            elif self._Scrolled < 0:
+                if cur_li._PosY +cur_li._Height > self._Height:
+                    for i in range(0,len(self._MyList)):
+                        self._MyList[i]._PosY += self._Scrolled * self._MyList[i]._Height
+            
+    def Click(self):
+        self.RefreshPsIndex()
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        play_pos_id = myvars.Poller.play(self._PsIndex)
+
+        self.SyncPlaying()
+
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def OnReturnBackCb(self): # return from music_lib_list_page
+        self.SyncList()
+        self.SyncScroll()
+        
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            if myvars.Poller != None:
+                myvars.Poller.stop()
+                self._CurSongTime=""
+                self._CurSongName=""
+            
+            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["Right"]:#add
+            self._Screen.PushCurPage()
+            self._Screen.SetCurPage(myvars.MusicLibListPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Y"]:# del selected songs
+            myvars.Poller.delete(self._PsIndex)
+            self.SyncList()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if IsKeyStartOrA(event.key):
+            self.Click()
+
+        if event.key == CurKeys["X"]: # start spectrum
+            myvars.SpectrumPage._Neighbor = self
+            self._Screen.PushPage(myvars.SpectrumPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) == 0:
+            self._BGpng.NewCoord(self._Width/2,self._Height/2)
+            self._BGpng.Draw()
+            return
+        else:
+            if len(self._MyList) * ListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                    
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+                self._Scroller.Draw()
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    
+                    if i._PosY > self._Height + self._Height/2:
+                        break
+
+                    if i._PosY < 0:
+                        continue
+                    
+                    i.Draw()
+                

Menu/GameShell/98_TinyCloud/__init__.py

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*- 
+import pygame
+import validators
+import  commands
+
+from UI.constants import Width,Height,ICON_TYPES
+from UI.simple_name_space import SimpleNamespace
+from UI.page  import Page
+from UI.label  import Label
+from UI.icon_item import IconItem
+from UI.icon_pool import MyIconPool
+from UI.keys_def  import CurKeys, IsKeyMenuOrB
+from UI.skin_manager import MySkinManager
+from UI.lang_manager import MyLangManager
+
+from libs.DBUS  import is_wifi_connected_now,get_wifi_ip
+
+class TinyCloudPage(Page):
+    _FootMsg =  ["Nav","","","Back",""]
+    _MyList = []
+    
+    _ListFontObj = MyLangManager.TrFont("varela13")
+    
+    _AList = {}
+    _Labels = {}
+
+    _Coords = {}
+    
+    _URLColor  = MySkinManager.GiveColor('URL')
+    _TextColor = MySkinManager.GiveColor('Text')
+    _Scrolled = 0
+    
+    _PngSize = {}
+    
+    _DrawOnce = False
+    _Scroller = None
+    _Scrolled = 0
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+
+    def OnLoadCb(self):
+        self._Scrolled = 0
+        self._PosY = 0
+        self._DrawOnce = False
+
+    def SetCoords(self):
+
+        self._Coords["forID"] = SimpleNamespace()
+        self._Coords["forID"].x = 15
+        self._Coords["forID"].y = 11
+
+        self._Coords["forKey"] = SimpleNamespace()
+        self._Coords["forKey"].x = 71
+        self._Coords["forKey"].y = self._Coords["forID"].y
+
+        self._Coords["key_and_pass"] = SimpleNamespace()
+        self._Coords["key_and_pass"].x = 36 # 141
+        self._Coords["key_and_pass"].y = self._Coords["forID"].y
+
+        self._Coords["forssh"] = SimpleNamespace()
+        self._Coords["forssh"].x = self._Coords["forID"].x
+        self._Coords["forssh"].y = 36
+
+        self._Coords["ssh_addr"] = SimpleNamespace()
+        self._Coords["ssh_addr"].x = self._Coords["forID"].x
+        self._Coords["ssh_addr"].y = 54
+
+        self._Coords["forwin"] = SimpleNamespace()
+        self._Coords["forwin"].x = self._Coords["forID"].x
+        self._Coords["forwin"].y = 80
+
+        self._Coords["samba_games"] = SimpleNamespace()
+        self._Coords["samba_games"].x = self._Coords["forID"].x
+        self._Coords["samba_games"].y = 97
+
+        self._Coords["samba_music"] = SimpleNamespace()
+        self._Coords["samba_music"].x = self._Coords["samba_games"].x
+        self._Coords["samba_music"].y = 115
+
+        self._Coords["for_airplay"] = SimpleNamespace()
+        self._Coords["for_airplay"].x = self._Coords["forID"].x
+        self._Coords["for_airplay"].y = 140
+
+        self._Coords["airplay_name"] = SimpleNamespace()
+        self._Coords["airplay_name"].x = 68
+        self._Coords["airplay_name"].y = self._Coords["for_airplay"].y
+        
+        self._Coords["for-usb-eth"] = SimpleNamespace()
+        self._Coords["for-usb-eth"].x = self._Coords["forID"].x
+        self._Coords["for-usb-eth"].y = 163
+        
+        self._Coords["usb-eth-addr"] = SimpleNamespace()
+        self._Coords["usb-eth-addr"].x = 112
+        self._Coords["usb-eth-addr"].y = self._Coords["for-usb-eth"].y
+
+        self._Coords["bg"]          = SimpleNamespace()
+        self._Coords["bg"].x        = self._Width/2
+        self._Coords["bg"].y        = self._Height/2
+
+        self._Coords["online"]          = SimpleNamespace()
+        self._Coords["online"].x        = 266
+        self._Coords["online"].y        = 99
+
+    def SetLabels(self):
+        if is_wifi_connected_now():
+            self._IP = get_wifi_ip()
+            print("TinyCould : %s" % self._IP)
+            try:
+                if validators.ip_address.ipv4(self._IP) == False:
+                    self._IP = "xxx.xxx.xxx.xxx"
+            except:
+                print("ip error %s " % self._IP)
+                self._IP = "xxx.xxx.xxx.xxx"
+            
+        else:
+            self._IP = "xxx.xxx.xxx.xxx"
+        
+        hostname = commands.getstatusoutput("hostname")[1]
+        if hostname == "":
+            hostname = "clockworkpi"
+                    
+        labels = \
+        [["forssh","For ssh and scp:",self._ListFontObj,self._TextColor],
+         ["ssh_addr","ssh cpi@%s" % self._IP, self._ListFontObj,self._URLColor],
+         ["forwin", "For Windows network:",    self._ListFontObj, self._TextColor],
+         ["samba_games", "\\\\%s\games" % self._IP, self._ListFontObj,self._URLColor],
+         ["samba_music", "\\\\%s\music" % self._IP, self._ListFontObj,self._URLColor],
+         ["forID",      "ID:",                     self._ListFontObj, self._TextColor],
+         ["forKey",     "Key:",                    self._ListFontObj, self._TextColor],
+         ["key_and_pass", "cpi",                   self._ListFontObj, self._URLColor],
+         ["for_airplay", "Airplay:",               self._ListFontObj, self._TextColor],
+         ["airplay_name",hostname,            self._ListFontObj, self._URLColor],
+         ["for-usb-eth","USB-Ethernet:",            self._ListFontObj, self._TextColor],
+         ["usb-eth-addr","192.168.10.1",            self._ListFontObj, self._URLColor]]
+
+        for i in labels:
+            l = Label()
+            l.SetCanvasHWND(self._CanvasHWND)
+            l.Init(i[1],i[2])
+            l.SetColor(i[3])
+            self._Labels[ i[0] ] = l
+
+        self.SetCoords() ##
+        
+    def Init(self):
+
+        
+        if self._Screen != None:
+            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
+                self._HWND = self._Screen._CanvasHWND
+                self._CanvasHWND = pygame.Surface( (self._Screen._Width,self._Screen._Height) )
+        
+        self._PosX = self._Index*self._Screen._Width 
+        self._Width = self._Screen._Width ## equal to screen width
+        self._Height = self._Screen._Height
+
+        self._PngSize["bg"] = (253,114)
+        self._PngSize["online"] = (75,122)
+        
+        bgpng = IconItem()
+        bgpng._ImgSurf = MyIconPool.GiveIconSurface("needwifi_bg")
+        bgpng._MyType = ICON_TYPES["STAT"]
+        bgpng._Parent = self
+        bgpng.Adjust(0,0,self._PngSize["bg"][0],self._PngSize["bg"][1],0)
+
+        self._Icons["bg"] = bgpng
+        
+        onlinepng = IconItem()
+        onlinepng._ImgSurf = MyIconPool.GiveIconSurface("online")
+        onlinepng._MyType = ICON_TYPES["STAT"]
+        onlinepng._Parent = self
+        onlinepng.Adjust(0,0,self._PngSize["online"][0], self._PngSize["online"][1],0)
+
+        self._Icons["online"] = onlinepng
+
+        self.SetLabels()
+
+    def KeyDown(self,event):
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+    def Draw(self):
+        if self._DrawOnce == False:
+            self.ClearCanvas()
+
+            if is_wifi_connected_now():
+                
+                self._Icons["online"].NewCoord(self._Coords["online"].x, self._Coords["online"].y)
+                self._Icons["online"].Draw()
+
+                self.SetLabels()
+                
+                for i in self._Labels:
+                    if i in self._Coords:
+                        self._Labels[i].NewCoord( self._Coords[i].x, self._Coords[i].y)
+                        self._Labels[i].Draw()
+
+                self._Labels["key_and_pass"].NewCoord( 103,self._Coords["key_and_pass"].y)
+                self._Labels["key_and_pass"].Draw()
+
+            else:
+                self._Labels["for-usb-eth"].NewCoord(self._Coords["for-usb-eth"].x+55, self._Coords["for-usb-eth"].y)
+                self._Labels["for-usb-eth"].Draw()
+                
+                self._Labels["usb-eth-addr"].NewCoord(self._Coords["usb-eth-addr"].x+55, self._Coords["usb-eth-addr"].y)
+                self._Labels["usb-eth-addr"].Draw()                
+                
+                self._Icons["bg"].NewCoord(self._Coords["bg"].x, self._Coords["bg"].y)
+                self._Icons["bg"].Draw()
+
+                
+            self._DrawOnce = True
+            
+        if self._HWND != None:
+            self._HWND.fill(MySkinManager.GiveColor('White'))
+            self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width, self._Height ) )
+            
+            
+        
+class APIOBJ(object):
+
+    _Page = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = TinyCloudPage()
+        self._Page._Screen = main_screen
+        self._Page._Name ="Tiny cloud"
+        self._Page.Init()
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+    
+        

Menu/GameShell/99_PowerOFF/__init__.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+
+#UI lib
+from UI.constants    import RUNSYS
+from UI.keys_def     import CurKeys, IsKeyStartOrA, IsKeyMenuOrB
+from UI.confirm_page import ConfirmPage
+from UI.lang_manager import MyLangManager
+from UI.skin_manager import MySkinManager
+
+import config
+
+class PowerOffConfirmPage(ConfirmPage):
+    
+    _ConfirmText = MyLangManager.Tr("Awaiting Input")
+    _FootMsg = ["Nav","","Reboot","Cancel","Shutdown"]
+
+    def CheckBattery(self):
+        try:
+            f = open(config.Battery)
+        except IOError:
+            print( "PowerOFF open %s failed" % config.Battery)
+            return 0
+        else:
+            with f:
+                bat_uevent = {}
+                content = f.readlines()
+                content = [x.strip() for x in content]
+                for i in content:
+                    pis = i.split("=")
+                    if len(pis) > 1:
+                        bat_uevent[pis[0]] = pis[1]
+
+                if "POWER_SUPPLY_CAPACITY" in bat_uevent:
+                    cur_cap = int(bat_uevent["POWER_SUPPLY_CAPACITY"])
+                else:
+                    cur_cap = 0
+                
+                return cur_cap
+                    
+        return 0
+        
+    def KeyDown(self,event):
+        
+        if IsKeyMenuOrB(event.key):
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if IsKeyStartOrA(event.key):
+            if self.CheckBattery() < 20:
+                cmdpath = "feh --bg-center %s;" % MySkinManager.GiveWallpaper("gameover.png")
+            else:
+                cmdpath = "feh --bg-center %s;" % MySkinManager.GiveWallpaper("seeyou.png")
+            
+            cmdpath += "sleep 3;"
+            
+            #cmdpath += "echo 'halt -p' > /tmp/halt_cmd"
+            
+            cmdpath += "sudo halt -p"
+            pygame.event.post( pygame.event.Event(RUNSYS, message=cmdpath))
+            
+        if event.key == CurKeys["X"]:
+            cmdpath = "feh --bg-center %s;" % MySkinManager.GiveWallpaper("seeyou.png")
+            cmdpath += "sleep 3;"
+            cmdpath += "sudo reboot"
+            pygame.event.post( pygame.event.Event(RUNSYS, message=cmdpath))
+
+
+class APIOBJ(object):
+
+    _StoragePage = None
+    def __init__(self):
+        pass
+    def Init(self,main_screen):
+        self._Page = PowerOffConfirmPage()
+
+        self._Page._Screen = main_screen
+        self._Page._Name ="Power OFF"
+        self._Page.Init()
+        
+        
+    def API(self,main_screen):
+        if main_screen !=None:
+            main_screen.PushPage(self._Page)
+            main_screen.Draw()
+            main_screen.SwapAndShow()
+
+OBJ = APIOBJ()
+def Init(main_screen):    
+    OBJ.Init(main_screen)
+def API(main_screen):
+    OBJ.API(main_screen)
+