Revert "Respond to user requests for changes" (#37)

* Revert "Respond to user requests (#35)"

This reverts commit dc1b7e007c24dfb7226ee02c41ab0af723229f5f.

* Revert "image text"

This reverts commit 968db78adb9c5404d5150f4dd467a9e58545be0d.

* Revert "add restore in POWEROPT event"

This reverts commit 88523224de7721f9563a5b1f8d83bf05c76e3c76.

* Revert "off to OFF"

This reverts commit 586aa75ae4a4c276af71c17246d202ae7dfc0eef.

* Revert "text fix"

This reverts commit 8e3a90589aeb2b115d6321edcfa08abad5f78d07.

* Revert "ignore powerlevel"

This reverts commit 164b55fb4bccf625aa378057908b7fcbac8d229f.

* Revert "switch smalltext"

This reverts commit 01a5f2ef9af19a7ed302c21ceb82531e087b014b.

* Revert "text fix"

This reverts commit e03a9da323ebd767550ed2c967f6ada1252f9e18.

* Revert "text fix"

This reverts commit b5603bcf7c91b3a4af8a32dbb6fbcf92122e09a9.

* Revert "sudo rfkill"

This reverts commit 2bbeba56654727fe634faeef99f36ba68cb3d7a5.

* Revert "InspectionTeam"

This reverts commit 3db3b0e8b3b8f46287eb7b9956d262b74b61b1f8.

* Revert "move back CurKeySet"

This reverts commit 10f7e35e2e7a75cd8b4ba0a3f463f3be805eb14c.

* Revert "rm png"

This reverts commit bfdb83683a1f13e469b24479a08b4ff47b7cd924.

* Revert "airplane mode with animation"

This reverts commit 6e19ad88a7d5797ab83567e0b79d80f849d4e194.

* Revert "add detail on power mode"

This reverts commit d66a0df823a05ef45485f9e0d6db0434af4e178e.

* Revert "add PowerLevel options"

This reverts commit 36c54a4f9d0b8c569253cde4b1003cf9532e3802.

* Revert "TitleBar show airplane mode icon"

This reverts commit 74e7f8ab69f1813da84f9c26ee917f0c29bf7ab0.

* Revert "Toggle AirPlane Mode"

This reverts commit 2d11df8c37f7ab6e30c87dd5730614126b2ef7ba.

* Revert "start sheep"

This reverts commit 8f965b3ba543c5a952ef65fd868721e5b1dbbe7c.

* Revert "fix bug dosbox on rom_list_page and remove scalesmooth on sec level icons"

This reverts commit b4e40d052a479732dab13cec0b9776c3a21c93dc.

* Revert "fix fav display bug on dosbox"

This reverts commit 40be34e30d1289473b06f7f54bb70611e9da51f9.

* Revert "add dosbox on fav"

This reverts commit 2cba2e580867dfab3065dff269a5fcca0c2f668e.

* Revert "add dosbox"

This reverts commit bd71c64a5c75c8fceabe6554242569807deffea6.

* Revert "Move back to 10_Settings"

This reverts commit 4acacaf7363def6e462d1d2ecec10d68a9208353.

* Revert "change load modules checking in Settings list_page"

This reverts commit 385b672eeb0afb6d80921af8ad96da1ed76d8e80.

* Revert "develop branch commit"

This reverts commit f604310bb2d0855ea409012f6e86c71d549d56f1.

.gitignore

@@ -1,6 +1,4 @@
 *.pyc
 retroarch-core-options.cfg
 *.lpl
-*.swp
-sys.py/.powerlevel
 

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

@@ -1,317 +0,0 @@
-# -*- 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.fonts  import fonts
-from UI.util_funcs import midRect
-from UI.keys_def   import CurKeys
-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
-
-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 AirplanePage(Page):
-    _FootMsg =  ["Nav.","","","Back","Toggle"]
-    _MyList = []
-    _ListFontObj = fonts["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 = 134
-        DialogBoxs._IconHeight = 93
-        DialogBoxs.Adjust(0,0,134,372,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)
-        
-    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 out[1] == "yes":
-            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 out[1] == "yes":
-            self._Screen._MsgBox.SetText("Turning On")
-            self._Screen._MsgBox.Draw()
-            commands.getstatusoutput("sudo rfkill unblock all")
-            self._Screen._TitleBar._InAirPlaneMode = False
-        
-        else:
-            self._Screen._MsgBox.SetText("Turning Off")
-            self._Screen._MsgBox.Draw()
-            commands.getstatusoutput("sudo rfkill block all")
-            self._Screen._TitleBar._InAirPlaneMode = True
-
-        
-    def OnLoadCb(self):
-        self._Scrolled = 0
-        self._PosY = 0
-        self._DrawOnce = False
-        out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
-        if out[1] == "yes":
-            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 event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
-            self.ReturnToUpLevelPage()
-            self._Screen.Draw()
-            self._Screen.SwapAndShow()
-
-        if event.key == CurKeys["B"]:
-            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()
-        """
-                                
-    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/PowerOptions/__init__.py

@@ -1,567 +0,0 @@
-# -*- coding: utf-8 -*- 
-
-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.fonts  import fonts
-from UI.util_funcs import midRect
-from UI.keys_def   import CurKeys
-from UI.scroller   import ListScroller
-from UI.icon_pool  import MyIconPool
-from UI.icon_item  import IconItem
-from UI.multilabel import MultiLabel
-
-import config
-
-class ListPageSelector(PageSelector):
-    _BackgroundColor = pygame.Color(131,199,219)
-
-    def __init__(self):
-        self._PosX = 0
-        self._PosY = 0
-        self._Height = 0
-        self._Width  = Width
-
-    def AnimateDraw(self,x2,y2):
-        pass
-
-    def Draw(self):
-        idx = self._Parent._PsIndex
-        
-        if idx < len(self._Parent._MyList):
-            x = 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)
-
-        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,(169,169,169),(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 = fonts["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 minutes " % m
-            else:
-                min_str =  "%d minute " % m
-            
-            if s == 1:
-                sec_str = "%d second" % s
-            elif s > 1:
-                sec_str = "%d seconds" % s
-        elif secs > 0:
-            if secs > 1:
-                sec_str = "%d seconds" % secs
-            else:
-                sec_str = "%d second" % secs
-        
-        elif secs == 0:
-            sec_str = "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"] = "Never"
-        else:
-            time1["value"] = "%d secs" % self._Time1
-        time1["label"] = "Screen dimming"
-        
-        time2 = {}
-        time2["key"] = "time2"
-        if self._Time2 == 0:
-            time2["value"] = "Never"
-        else:
-            time2["value"] = "%d secs" % self._Time2
-            
-        time2["label"] = "Screen OFF"
-
-        time3 = {}
-        time3["key"] = "time3"
-        
-        if self._Time3 == 0:
-            time3["value"] = "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"] = fonts["varela12"]
-            
-            if self._AList[v]["label"] != "":
-                li.Init(  self._AList[v]["label"] )
-            else:
-                li.Init( self._AList[v]["key"] )
-
-            li._Flag = self._AList[v]["key"]
-
-            li.SetSmallText( self._AList[v]["value"] )
-            
-            self._MyList.append(li)
-            
-    def Init(self):
-        if self._Screen != None:
-            if self._Screen._CanvasHWND != None and self._CanvasHWND == None:
-                self._CanvasHWND = self._Screen._CanvasHWND
-
-        self._PosX = self._Index*self._Screen._Width 
-        self._Width = self._Screen._Width ## equal to screen width
-        self._Height = self._Screen._Height
-
-        ps = 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 event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
-            self.ReturnToUpLevelPage()
-            self._Screen.Draw()
-            self._Screen.SwapAndShow()
-        
-        if event.key == CurKeys["Up"]:
-            self.ScrollUp()
-            self._Screen.Draw()
-            self._Screen.SwapAndShow()
-        if event.key == CurKeys["Down"]:
-            self.ScrollDown()
-            self._Screen.Draw()
-            self._Screen.SwapAndShow()
-                                        
-    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 = fonts["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"
-        
-        
-        self._AList["supersaving"] = supersaving
-        self._AList["powersaving"] = powersaving
-        self._AList["balance_saving"] = balance_saving
-        
-        for i,u in enumerate( ["supersaving","powersaving","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._Icons["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 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(".powerlevel","w") as f:
-            f.write(cur_li._Value)
-
-        config.PowerLevel = cur_li._Value
-
-        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 event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
-            self.ReturnToUpLevelPage()
-            self._Screen.Draw()
-            self._Screen.SwapAndShow()
-
-        if event.key == CurKeys["B"]:
-            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((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 = 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/list_page.py

@@ -10,7 +10,7 @@ from UI.constants import Width,Height
 from UI.page   import Page,PageSelector
 from UI.label  import Label
 from UI.fonts  import fonts
-from UI.util_funcs import midRect,FileExists
+from UI.util_funcs import midRect
 from UI.keys_def   import CurKeys
 from UI.scroller   import ListScroller
 
@@ -76,21 +76,19 @@ class ListPage(Page):
         self._PsIndex = 0
 
         #                ""   pkgname, label
-        alist         = [["","Airplane","Airplane Mode"],
+        alist         = [["","Wifi","Wi-Fi"],
-                         ["","PowerOptions","Power Options"],
-                         ["","Wifi","Wi-Fi"],
                          ["","Sound","Sound Volume"],
                          ["","Brightness","BackLight Brightness"],
                          ["","Storage",""],
                          ["","Update", ""],
                          ["","About",  "About"],
-                         ["","PowerOFF","Power off"],]
+                         ["","PowerOFF","Power off"]]
 
         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
@@ -104,15 +102,13 @@ class ListPage(Page):
             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 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":
-            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._MyList.append(li)
 
         self._Scroller = ListScroller()
         self._Scroller._Parent = self

Menu/GameShell/Music Player/mpd_spectrum_page.py

@@ -3,7 +3,7 @@
 import time
 import pygame
 
-from numpy import fromstring,ceil,abs,log10,isnan,isinf,int16,sqrt,mean
+from numpy import fromstring,ceil,abs,log10,isnan,isinf,int16
 from numpy import fft as Fft
 
 import gobject
@@ -11,14 +11,12 @@ import gobject
 from beeprint import pp
 
 ## local UI import
-from UI.constants import Width,Height,ICON_TYPES
+from UI.constants import Width,Height
 from UI.page   import Page,PageSelector
 from UI.label  import Label
 from UI.fonts  import fonts
 from UI.util_funcs import midRect
 from UI.keys_def   import CurKeys
-from UI.icon_item import IconItem
-from UI.icon_pool  import MyIconPool
 
 from Queue import Queue, Empty
 from threading  import Thread
@@ -40,9 +38,6 @@ class PIFI(object):
     count = 0
     average = 0
     
-    rmscount=0
-    rmsaverage=0
-    
     def __init__(self):
         self.sampleSize = self._SAMPLE_SIZE
         self.samplingRate = self._SAMPLING_RATE
@@ -59,13 +54,6 @@ class PIFI(object):
     def resetSmoothing(self):
         self.count = 0
         self.average = 0
-        self.rmscount = 0
-        self.rmsaverage = 0
-
-    def rms_smoothOut(self, x):
-        self.rmscount += 1
-        self.rmsaverage = (self.rmsaverage*self.rmscount + x) / (self.rmscount+1)
-        return self.rmsaverage
         
     def smoothOut(self, x):
         self.count += 1
@@ -88,7 +76,6 @@ class PIFI(object):
         scaledList = [int(x*scaleFactor) for x in _list ]
         return scaledList
         
-    
     def computeSpectrum(self, fifoFile):
         
         # Read PCM samples from fifo
@@ -105,17 +92,6 @@ class PIFI(object):
         # Normalize [-1; +1]
         pcm = pcm / (2.**15)
         
-        # Compute RMS directly from signal
-        rms = sqrt(mean(pcm**2))
-        # Compute a simple 'moving maximum'
-        maximum = 2*self.rms_smoothOut(rms)
-        if maximum == 0:
-            scaleFactor = 0.0
-        else:
-            scaleFactor = self._SCALE_WIDTH/float(maximum)
-        
-        final_rms = int(rms*scaleFactor)
-        
         # Compute FFT
         N = pcm.size
         fft = Fft.fft(pcm)
@@ -151,8 +127,8 @@ class PIFI(object):
             
         # Scale the spectrum 
         scaledSpectrum = self.scaleList(spectrum)
-        scaledSpectrum.append( final_rms)
+        
-        return scaledSpectrum
+        return (self.bins, scaledSpectrum)
     
 
 class MPDSpectrumPage(Page):
@@ -164,29 +140,12 @@ class MPDSpectrumPage(Page):
     _ListFont = fonts["veramono12"]
 
     _PIFI   =  None
-    _FIFO   = None
+    _FiFo   = None
     _Color  = pygame.Color(126,206,244)
     _GobjectIntervalId = -1
     _Queue = None
     _KeepReading = True
     
-    _BGpng = None
-    _BGwidth = 320
-    _BGheight = 200
-
-    _SheepHead = None
-    _SheepHeadW = 69
-    _SheepHeadH = 66
-
-    _SheepBody = None
-    _SheepBodyW = 105
-    _SheepBodyH = 81
-
-    _freq_count = 0
-    _head_dir = 0
-
-    _Neighbor = None
-    
     def __init__(self):
         Page.__init__(self)
         self._Icons = {}
@@ -201,27 +160,8 @@ class MPDSpectrumPage(Page):
 
         self._CanvasHWND = self._Screen._CanvasHWND
 
-        """
-        self._BGpng = IconItem()
-        self._BGpng._ImgSurf = MyIconPool._Icons["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._Icons["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._Icons["sheep_body"]
-        self._SheepBody._MyType = ICON_TYPES["STAT"]
-        self._SheepBody._Parent = self
-        self._SheepBody.Adjust(0,0,self._SheepBodyW,self._SheepBodyH,0)
-        """
-        
         self.Start()
+
         self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
         
     def Start(self):
@@ -246,7 +186,7 @@ class MPDSpectrumPage(Page):
             print("self._FIFO none")
             return
         
-        scaledSpectrum = self._PIFI.computeSpectrum(self._FIFO)
+        (bins,scaledSpectrum) = self._PIFI.computeSpectrum(self._FIFO)
         self._Queue.put( scaledSpectrum )
 
         self._KeepReading = False
@@ -272,8 +212,6 @@ class MPDSpectrumPage(Page):
         return True
     
     def OnLoadCb(self):
-        if self._FIFO == None:
-            self.Start()
 
         if self._Queue != None:
             with self._Queue.mutex:
@@ -290,14 +228,6 @@ class MPDSpectrumPage(Page):
     
     def KeyDown(self,event):
         if event.key == CurKeys["Menu"] or event.key == CurKeys["A"]:
-            if self._FIFO != None and self._FIFO.closed == False:
-                try:
-                    self._FIFO.close()
-                    self._FIFO = None
-                except Exception, e:
-                    print(e)
-                
-            
             self.ReturnToUpLevelPage()
             self._Screen.Draw()
             self._Screen.SwapAndShow()
@@ -309,24 +239,22 @@ class MPDSpectrumPage(Page):
         if event.key == CurKeys["Enter"]:
             pass
 
+        
     def Draw(self):
         self.ClearCanvas()
 
         bw = 10
         spects = None
         try:
-            spects = self._Queue.get_nowait() ## last element is rms
+            spects = self._Queue.get_nowait()
 #            print("get_nowait: " , spects)
         except Empty:
             return
         else: # got line
             if len(spects) == 0:
                 return
-            w = self._Width / len( spects[0:-1] )
+            w = self._Width / len(spects)
             left_margin = (w-bw)/2
-            for i,v in enumerate(spects[0:-1]):
+            for i,v in enumerate(spects):
                 pygame.draw.rect(self._CanvasHWND,self._Color,(i*w+left_margin,self._Height-v,bw,v),0)
         
-
-
-    

Menu/GameShell/Music Player/play_list_page.py

@@ -64,7 +64,6 @@ class PlayListPage(Page):
     _ListFont = fonts["notosanscjk15"]
 
     _Scroller = None
-    _CurSongTime="0:0"
     
     _BGpng  = None
     _BGwidth = 75
@@ -112,9 +111,8 @@ class PlayListPage(Page):
         self.SyncPlaying()
 
     def GObjectInterval(self): ## 250 ms 
-        self.SyncPlaying()
-        
         if self._Screen.CurPage() == self:
+            self.SyncPlaying()
             self._Screen.Draw()
             self._Screen.SwapAndShow()
 
@@ -140,7 +138,6 @@ class PlayListPage(Page):
                         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])
@@ -274,7 +271,6 @@ class PlayListPage(Page):
             self.Click()
 
         if event.key == CurKeys["Start"]: # start spectrum
-            myvars.SpectrumPage._Neighbor = self
             self._Screen.PushPage(myvars.SpectrumPage)
             self._Screen.Draw()
             self._Screen.SwapAndShow()

sys.py/UI/Emulator/fav_list_page.py

@@ -122,18 +122,18 @@ class FavListPage(Page):
 
         for i ,v in enumerate(files_path):
             dirmap = {}
-            if os.path.isdir(v) and self._Emulator["FILETYPE"] == "dir": ## like DOSBOX
+            #if os.path.isdir(v):
-                gameshell_bat = self._Emulator["EXT"][0]
+            #    continue
-                if FileExists(v+"/"+gameshell_bat):
+            #    dir_base_name = os.path.basename(v)
-                    stats = os.stat(v)
+            #    if dir_base_name == ".Trash" or dir_base_name == ".Fav":
-                    if stats.st_gid != self._Parent._FavGID: ## only favs
+            #        pass
-                        continue
+            #    else:
+            #        dirmap["directory"] = v
+            #        ret.append(dirmap)
                     
-                    dirmap["gamedir"] = v.decode("utf8")
+            if os.path.isfile(v):
-                    ret.append(dirmap)            
-            if os.path.isfile(v) and self._Emulator["FILETYPE"] == "file":
                 stats = os.stat(v)
-                if stats.st_gid != self._Parent._FavGID: ## only favs
+                if stats.st_gid != self._Parent._FavGID:
                     continue
                 bname = os.path.basename(v)  ### filter extension
                 if len(bname)> 1:
@@ -190,9 +190,6 @@ class FavListPage(Page):
                 li.Init(v["directory"])
             elif "file" in v:
                 li.Init(v["file"])
-                
-            elif "gamedir" in v:
-                li.Init(v["gamedir"])
             else:
                 li.Init("NoName")
             
@@ -310,16 +307,11 @@ class FavListPage(Page):
             self._Screen._MsgBox.SetText("Launching...")
             self._Screen._MsgBox.Draw()
             self._Screen.SwapAndShow()
-            if self._Emulator["FILETYPE"] == "dir":
+            print("Run ",cur_li._Path)
-                path = cur_li._Path +"/"+self._Emulator["EXT"][0]
-            else:
-                path = cur_li._Path
-                
-            print("Run ",path)
             
             # check ROM_SO exists
             if FileExists(self._Emulator["ROM_SO"]):
-                escaped_path = CmdClean( path)
+                escaped_path = CmdClean( cur_li._Path)
                 
                 custom_config = ""
                 if self._Emulator["RETRO_CONFIG"] != "" and len(self._Emulator["RETRO_CONFIG"]) > 5:

sys.py/UI/Emulator/rom_list_page.py

@@ -133,19 +133,16 @@ class RomListPage(Page):
 
         for i ,v in enumerate(files_path):
             dirmap = {}
-            if os.path.isdir(v) and self._Emulator["FILETYPE"] == "dir": ## like DOSBOX
+            #if os.path.isdir(v):
-                gameshell_bat = self._Emulator["EXT"][0]
+            #    dir_base_name = os.path.basename(v)
-                
+            #    if dir_base_name == ".Trash" or dir_base_name == ".Fav":
+            #        pass
+            #    else:
+            #        dirmap["directory"] = v
+            #        ret.append(dirmap)
+            if os.path.isfile(v):
                 stats = os.stat(v)
-                if stats.st_gid == self._Parent._FavGID: ##skip fav roms
+                if stats.st_gid == self._Parent._FavGID:
-                    continue
-                
-                if FileExists(v+"/"+gameshell_bat):
-                    dirmap["gamedir"] = v.decode("utf8")
-                    ret.append(dirmap)
-            if os.path.isfile(v) and self._Emulator["FILETYPE"] == "file":
-                stats = os.stat(v)
-                if stats.st_gid == self._Parent._FavGID: ##skip fav roms
                     continue
                 
                 bname = os.path.basename(v)  ### filter extension
@@ -202,8 +199,6 @@ class RomListPage(Page):
                 li.Init(v["directory"])
             elif "file" in v:
                 li.Init(v["file"])
-            elif "gamedir" in v:
-                li.Init(v["gamedir"])
             else:
                 li.Init("NoName")
 
@@ -341,20 +336,11 @@ class RomListPage(Page):
             self._Screen._MsgBox.SetText("Launching...")
             self._Screen._MsgBox.Draw()
             self._Screen.SwapAndShow()
-
+            print("Run  ",cur_li._Path)
-            if self._Emulator["FILETYPE"] == "dir":
-                path = cur_li._Path +"/"+self._Emulator["EXT"][0]
-            else:
-                path = cur_li._Path
-            
-            print("Run  ",path)
 
             # check ROM_SO exists
             if FileExists(self._Emulator["ROM_SO"]):
-                if self._Emulator["FILETYPE"] == "dir":
+                escaped_path = CmdClean( cur_li._Path)
-                    escaped_path = CmdClean(path)
-                else:
-                    escaped_path = CmdClean(path)
                 
                 custom_config = ""
                 if self._Emulator["RETRO_CONFIG"] != "" and len(self._Emulator["RETRO_CONFIG"]) > 5:

sys.py/UI/constants.py

@@ -34,10 +34,12 @@ DT = pygame.time.Clock().tick(30)   # fps in ms,eg:50
 GMEVT = pygame.USEREVENT+1
 update_titlebar_event = pygame.event.Event(GMEVT, message="titlebar")
 
-RUNEVT   = pygame.USEREVENT+2
+RUNEVT = pygame.USEREVENT+2
-RUNSYS   = pygame.USEREVENT+3
+RUNSYS = pygame.USEREVENT+3
+
+
 LOWLIGHT = pygame.USEREVENT+4 ## when dim screen backlight
-FOOTMSG  = pygame.USEREVENT+5 ## 
+
-POWEROPT = pygame.USEREVENT+6
+FOOTMSG = pygame.USEREVENT+5 ## when dim screen backlight
 
 

sys.py/UI/label.py

@@ -50,8 +50,8 @@ class Label:
     def SetCanvasHWND(self,_canvashwnd):
         self._CanvasHWND = _canvashwnd
 
-    def Draw(self,bold=False):
+    def Draw(self):
-        self._FontObj.set_bold(bold) ## avoing same font tangling set_bold to others
+        self._FontObj.set_bold(False) ## avoing same font tangling set_bold to others
         my_text = self._FontObj.render( self._Text,True,self._Color)
         
         self._CanvasHWND.blit(my_text,(self._PosX,self._PosY,self._Width,self._Height))

sys.py/UI/main_screen.py

@@ -46,7 +46,7 @@ class MessageBox(Label):
     def SetText(self,text):
         self._Text = text
         
-    def PreDraw(self):
+    def Draw(self):
         self._Width = 0
         self._Height = 0
         self._CanvasHWND.fill( (255,255,255))
@@ -87,30 +87,19 @@ class MessageBox(Label):
         
         self._Height = lines
         
-    def DrawWith(self, x_,y_, withborder):
-        
-        self.PreDraw()
-
-        x_ = x_ - self._Width/2
-        y_ = y_ - self._Height/2
-        
         padding = 5
+        x = (self._Parent._Width - self._Width)/2
+        y = (self._Parent._Height - self._Height)/2
+       # print("x %d y %d w %d h %d" %(x,y,self._Width,self._Height ))
         
-        pygame.draw.rect(self._HWND,(255,255,255),(x_-padding,y_-padding, self._Width+padding*2,self._Height+padding*2))        
+        pygame.draw.rect(self._HWND,(255,255,255),(x-padding,y-padding, self._Width+padding*2,self._Height+padding*2))        
     
         if self._HWND != None:
-            rect = pygame.Rect(x_,y_,self._Width,self._Height)
+            rect = midRect(self._Parent._Width/2,self._Parent._Height/2,self._Width,self._Height,Width,Height)
             self._HWND.blit(self._CanvasHWND,rect,(0,0,self._Width,self._Height))
             #self._HWND.blit(self._CanvasHWND,rect)
             
-        if withborder == True:
+        pygame.draw.rect(self._HWND,(0,0,0),(x-padding,y-padding, self._Width+padding*2,self._Height+padding*2),1)
-            pygame.draw.rect(self._HWND,(0,0,0),(x_-padding,y_-padding, self._Width+padding*2,self._Height+padding*2),1)
-        
-    def Draw(self):        
-        x = (self._Parent._Width)/2
-        y = (self._Parent._Height)/2
-        
-        self.DrawWith(x,y,True)
             
 
 python_package_flag = "__init__.py"
@@ -136,7 +125,6 @@ class MainScreen(object):
     _IconFont    = fonts["varela15"]
     _SkinManager = None
     
-    
     def __init__(self):
         self._Pages = []
         self._MyPageStack = PageStack()
@@ -418,7 +406,6 @@ class MainScreen(object):
                         obj["ROM"] = ""
                         obj["ROM_SO"] =""
                         obj["EXT"]    = []
-                        obj["FILETYPE"] = "file"
                         obj["LAUNCHER"] = ""
                         obj["TITLE"]    = "Game"
                         obj["SO_URL"]   = ""

sys.py/UI/multi_icon_item.py

@@ -23,27 +23,6 @@ class MultiIconItem(IconItem):
             self._ImgSurf = pygame.image.load( self._ImageName ).convert_alpha() 
             
 
-    def DrawTopLeft(self):
-        if self._Align==ALIGN["VCenter"]: #default
-            if self._Label != None:
-                self._Label._PosX = self._PosX - self._Label._Width/2 + self._Parent._PosX
-                self._Label._PosY = self._PosY + self._Height/2 +6  + self._Parent._PosY
-                
-        elif self._Align ==ALIGN["HLeft"]:
-            if self._Label != None:
-                self._Label._PosX = self._PosX + self._Width/2 + 3 + self._Parent._PosX
-                self._Label._PosY = self._PosY - self._Label._Height/2 + self._Parent._PosY
-
-        if self._Label!=None:
-            self._Label.Draw()
-
-
-        if self._ImgSurf != None:
-            self._Parent._CanvasHWND.blit(self._ImgSurf,pygame.Rect(self._PosX+self._Parent._PosX,
-                                                                    self._PosY+self._Parent._PosY,
-                                                                    self._Width,self._Height),
-                                          (0,self._IconIndex*self._IconHeight,self._IconWidth,self._IconHeight))
-        
     def Draw(self):
         if self._Align==ALIGN["VCenter"]: #default
             if self._Label != None:
@@ -58,10 +37,8 @@ class MultiIconItem(IconItem):
         if self._Label!=None:
             self._Label.Draw()
         
-
         if self._ImgSurf != None:
             self._Parent._CanvasHWND.blit(self._ImgSurf,midRect(self._PosX+self._Parent._PosX,
                                                                 self._PosY+self._Parent._PosY,
                                                                 self._Width,self._Height,Width,Height),
                                           (0,self._IconIndex*self._IconHeight,self._IconWidth,self._IconHeight))
-            

sys.py/UI/page.py

@@ -117,9 +117,7 @@ class Page(object):
         rows = int( (self._IconNumbers * icon_width)/Width + 1)
         if rows < 1:
             rows = 1
-
+            cnt = 0
-        cnt = 0
-
         for i in range(0,rows):
             for j in range(0,cols):
                 start_x = icon_width/2  + j*icon_width
@@ -186,8 +184,8 @@ class Page(object):
             it = self._Icons[0]
             it._Parent = self
             it._Index = 0
-            it.Adjust(start_x,start_y,icon_width,icon_height,0)
+            it.Adjust(start_x,start_y,icon_width-6,icon_height-6,0)
-            #it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
+            it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
 
         elif self._IconNumbers == 2:
             start_x = (self._Width - self._PageIconMargin - self._IconNumbers*icon_width) / 2 + icon_width/2
@@ -197,16 +195,17 @@ class Page(object):
                 it = self._Icons[i]
                 it._Parent = self
                 it._Index = i
-                it.Adjust(start_x+i*self._PageIconMargin + i*icon_width,start_y, icon_width, icon_height,0)
+                it.Adjust(start_x+i*self._PageIconMargin + i*icon_width,start_y, icon_width-6, icon_height-6,0)
-                #it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
+                it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
                 
         elif self._IconNumbers > 2:
             for i in range(0,self._IconNumbers):
                 it = self._Icons[i]
                 it._Parent = self
                 it._Index = i
-                it.Adjust(start_x+i*self._PageIconMargin + i*icon_width,start_y,icon_width,icon_height,0)
+                it.Adjust(start_x+i*self._PageIconMargin + i*icon_width,start_y,icon_width-6,icon_height-6,0)
-                #it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
+                
+                it._ImgSurf = pygame.transform.smoothscale(it._ImgSurf,(it._Width,it._Height))
 
         ps = PageSelector()
         ps._IconSurf = MyIconPool._Icons["blueselector"]
@@ -232,7 +231,7 @@ class Page(object):
         rows = int((self._IconNumbers * icon_width)/self._Width + 1)
         if rows < 1:
             rows = 1
-        cnt = 0
+            cnt = 0
         for i in range(0,rows):
             for j in range(0,cols):
                 start_x = icon_width/2  + j*icon_width
@@ -268,9 +267,9 @@ class Page(object):
                 it._Parent = self
                 it._Index = i
                 it.Adjust(start_x+i*icon_width,start_y,icon_width,icon_height,0)
+                ps = PageSelector()
+                ps._IconSurf = blueselector_surf
 
-            ps = PageSelector()
-            ps._IconSurf = MyIconPool._Icons["blueselector"]
             ps._Parent = self
             ps.Init(start_x,start_y,92,92,128)
             self._Ps = ps
@@ -363,7 +362,7 @@ class Page(object):
             diffa = []
             for i in range(0,dff):
                 diffa.append(0)
-            all_pieces.extend( diffa)
+                all_pieces.extend( diffa)
                 
         return all_pieces
 
@@ -407,9 +406,8 @@ class Page(object):
             
             if self._Icons[self._PrevIconIndex]._PosY < self._Height/2:
                 self._Icons[self._PrevIconIndex]._PosY+=data2[i]
-
+                self.DrawIcons()
-            self.DrawIcons()
+                self._Screen.SwapAndShow()        
-            self._Screen.SwapAndShow()        
                 
     def IconsEasingLeft(self,icon_ew):
 

sys.py/UI/title_bar.py

@@ -3,7 +3,6 @@
 import pygame
 import os
 import sys
-import commands
 
 from datetime import datetime
 
@@ -47,7 +46,6 @@ class TitleBar:
 
     _SkinManager = None
 
-    _InAirPlaneMode = False
     
     def __init__(self):
         self._Icons = {}
@@ -239,12 +237,6 @@ class TitleBar:
         if is_wifi_connected_now():
             print("wifi is connected")
             print( wifi_strength())
-        else:
-            out = commands.getstatusoutput('sudo rfkill list | grep yes | cut -d " " -f3')
-            if out[1] == "yes":
-                self._InAirPlaneMode = True
-            else:
-                self._InAirPlaneMode = False
 
     def ClearCanvas(self):
         self._CanvasHWND.fill( self._SkinManager.GiveColor("TitleBg") )
@@ -299,13 +291,9 @@ class TitleBar:
             else:
                 self._Icons["wifistatus"]._IconIndex = 0
                 self._Icons["wifistatus"].Draw()
-                print("wifi strength error")
+                print("strength error")
         else:
-            if self._InAirPlaneMode == False:
+            self._Icons["wifistatus"]._IconIndex = 0
-                self._Icons["wifistatus"]._IconIndex = 0
-            else:
-                self._Icons["wifistatus"]._IconIndex = 5 ## airplane mode icon
-            
             self._Icons["wifistatus"].NewCoord(start_x+self._icon_width+5,self._icon_height/2+(self._BarHeight-self._icon_height)/2)
             self._Icons["wifistatus"].Draw()
         

sys.py/config.py

@@ -15,15 +15,3 @@ UPDATE_URL="https://raw.githubusercontent.com/clockworkpi/CPI/master/launcher_ve
 VERSION="stable 1.0"
 
 SKIN="default"
-
-## three timer values in seconds: dim screen, close screen,PowerOff
-## zero means no action
-PowerLevels = {}
-PowerLevels["supersaving"] = [10,30,100]
-PowerLevels["powersaving"] = [40,120,300]
-PowerLevels["balance_saving"] = [40,0,0]
-
-PowerLevel = "balance_saving"
-
-##sys.py/.powerlevel
-

sys.py/run.py

@@ -30,7 +30,7 @@ else:
 
 
 #local UI import
-from UI.constants    import Width,Height,bg_color,icon_width,icon_height,DT,GMEVT,RUNEVT,RUNSYS,ICON_TYPES,POWEROPT
+from UI.constants    import Width,Height,bg_color,icon_width,icon_height,DT,GMEVT,RUNEVT,RUNSYS,ICON_TYPES
 from UI.util_funcs   import ReplaceSuffix,FileExists, ReadTheFileContent,midRect,color_surface,SwapAndShow,GetExePath,X_center_mouse
 from UI.page         import PageStack,PageSelector,Page
 from UI.label        import Label
@@ -59,8 +59,6 @@ myscriptname = os.path.basename(os.path.realpath(__file__))
 
 everytime_keydown = time.time()
 
-passout_time_stage = 0
-
 last_brt = -1
 
 def gobject_loop():
@@ -75,7 +73,7 @@ def gobject_loop():
 
 
 def RestoreLastBackLightBrightness(main_screen):
-    global last_brt,passout_time_stage
+    global last_brt
     
     if last_brt == -1:
         return
@@ -97,21 +95,17 @@ def RestoreLastBackLightBrightness(main_screen):
                 f.close()
                 last_brt = -1
                 main_screen._TitleBar._InLowBackLight = -1
-                passout_time_stage = 0
             else:
                 
                 f.close()
                 return
 
 def InspectionTeam(main_screen):
-    global everytime_keydown,last_brt,passout_time_stage
+    global everytime_keydown,last_brt
     
     cur_time = time.time()
-    time_1 = config.PowerLevels[config.PowerLevel][0]
-    time_2 = config.PowerLevels[config.PowerLevel][1]
-    time_3 = config.PowerLevels[config.PowerLevel][2]
 
-    if cur_time - everytime_keydown > time_1 and passout_time_stage == 0:
+    if cur_time - everytime_keydown > 40:
         print("timeout, dim screen %d" % int(cur_time - everytime_keydown))
 
         try:
@@ -123,9 +117,8 @@ def InspectionTeam(main_screen):
                 content = f.readlines()
                 content = [x.strip() for x in content]
                 brt=int(content[0])
-                if brt > 0:
+                if brt > 1:
                     last_brt = brt ## remember brt for restore
-
                     brt = 1
                     f.seek(0)
                     f.write(str(brt))
@@ -134,38 +127,6 @@ def InspectionTeam(main_screen):
 
                     main_screen._TitleBar._InLowBackLight = 0
                     
-        if time_2 != 0:
-            passout_time_stage = 1 # next 
-        everytime_keydown = cur_time
-    
-    elif cur_time - everytime_keydown > time_2 and passout_time_stage == 1:
-        print("timeout, close screen %d" % int(cur_time - everytime_keydown))
-
-        try:
-            f = open(config.BackLight,"r+")
-        except IOError:
-            pass
-        else:
-            with f:
-                brt = 0
-                f.seek(0)
-                f.write(str(brt))
-                f.truncate()
-                f.close()
-                main_screen._TitleBar._InLowBackLight = 0
-
-        if time_3 != 0:
-            passout_time_stage = 2 # next 
-        everytime_keydown = cur_time
-        
-    elif cur_time - everytime_keydown > time_3 and passout_time_stage == 2:
-        print("Power Off now")
-
-        if config.CurKeySet != "PC":
-            cmdpath = "sudo halt -p"
-            pygame.event.post( pygame.event.Event(RUNSYS, message=cmdpath))
-        
-        passout_time_stage = 0
         everytime_keydown = cur_time
         
     return True
@@ -223,12 +184,6 @@ def event_process(event,main_screen):
                 os.chdir( GetExePath())
                 os.exelp("python","python"," "+myscriptname)
             return
-
-        if event.type == POWEROPT:
-            everytime_keydown = time.time()
-            RestoreLastBackLightBrightness(main_screen)
-            
-            return
         if event.type == pygame.KEYUP:
             
             pygame.event.clear(pygame.KEYDOWN)
@@ -423,15 +378,5 @@ if __name__ == '__main__':
         exit()
 
     
-    if FileExists(".powerlevel") == False:
-        os.system("touch .powerlevel")
-    
-    with open(".powerlevel","r") as f:
-        powerlevel = f.read()
-    
-    powerlevel = powerlevel.strip()
-    if powerlevel != "":
-        config.PowerLevel = powerlevel
-    
     big_loop()