add PowerLevel options

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

@@ -0,0 +1,351 @@
+# -*- 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
+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 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
+        
+        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._Labels["Text"]._Width + 16 
+            self._Labels["Small"]._PosY = self._PosY 
+            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 PowerOptionsPage(Page):
+    _FootMsg =  ["Nav.","","","Back","Select"]
+    _MyList = []
+    _ListFont = fonts["notosanscjk15"]
+    
+    _AList = {}
+
+    _Scrolled = 0
+    
+    _BGwidth = 320
+    _BGheight = 240-24-20
+
+    _DrawOnce = False
+    _Scroller = 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"] = "Super Power saving"
+        supersaving["value"] = "supersaving"
+
+        powersaving = {}
+        powersaving["key"] = "saving"
+        powersaving["label"] = "Power saving"
+        powersaving["value"] = "powersaving"
+
+        balance_saving = {}
+        balance_saving["key"] = "balance"
+        balance_saving["label"] = "Balance"
+        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)
+        
+    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]
+        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.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):
+        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()
+        
+                                
+    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

@@ -77,6 +77,7 @@ class ListPage(Page):
 
         #                ""   pkgname, label
         alist         = [["","Airplane","Airplane Mode"],
+                         ["","PowerOptions","Power Options"],
                          ["","Wifi","Wi-Fi"],
                          ["","Sound","Sound Volume"],
                          ["","Brightness","BackLight Brightness"],

Menu/GameShell/20_Retro Games/DOSBOX/action.config

@@ -1,8 +0,0 @@
-ROM=/home/cpi/games/DOSBOX
-ROM_SO=/home/cpi/apps/emulators/dosbox_libretro.so
-EXT=GAMESHELL.BAT
-FILETYPE=dir
-LAUNCHER=retroarch -L
-TITLE=DOS games
-SO_URL=http://buildbot.libretro.com/nightly/linux/armhf/latest/dosbox_libretro.so.zip
-RETRO_CONFIG=/home/cpi/apps/launcher/Menu/GameShell/20_Retro\ Games/DOSBOX/retroarch.cfg

sys.py/.powerlevel

@@ -0,0 +1 @@
+powersaving

sys.py/UI/constants.py

@@ -39,7 +39,7 @@ RUNSYS = pygame.USEREVENT+3
 
 
 LOWLIGHT = pygame.USEREVENT+4 ## when dim screen backlight
-
+FOOTMSG = pygame.USEREVENT+5 ## 
-FOOTMSG = pygame.USEREVENT+5 ## when dim screen backlight
+POWEROPT = pygame.USEREVENT+6
 
 

sys.py/UI/label.py

@@ -50,8 +50,8 @@ class Label:
     def SetCanvasHWND(self,_canvashwnd):
         self._CanvasHWND = _canvashwnd
 
-    def Draw(self):
+    def Draw(self,bold=False):
-        self._FontObj.set_bold(False) ## avoing same font tangling set_bold to others
+        self._FontObj.set_bold(bold) ## 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/config.py

@@ -15,3 +15,13 @@ UPDATE_URL="https://raw.githubusercontent.com/clockworkpi/CPI/master/launcher_ve
 VERSION="stable 1.0"
 
 SKIN="default"
+
+PowerLevels = {}
+PowerLevels["supersaving"] = [10,10,10]
+PowerLevels["powersaving"] = [40,120,300]
+PowerLevels["balance_saving"] = [40,0,0]
+
+PowerLevel = "balance_saving"
+
+##sys.py/.powerlevel
+

sys.py/run.py

@@ -59,6 +59,8 @@ myscriptname = os.path.basename(os.path.realpath(__file__))
 
 everytime_keydown = time.time()
 
+passout_time_stage = 0
+
 last_brt = -1
 
 def gobject_loop():
@@ -73,7 +75,7 @@ def gobject_loop():
 
 
 def RestoreLastBackLightBrightness(main_screen):
-    global last_brt
+    global last_brt,passout_time_stage
     
     if last_brt == -1:
         return
@@ -95,17 +97,21 @@ 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
+    global everytime_keydown,last_brt,passout_time_stage
     
     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 > 40:
+    if cur_time - everytime_keydown > time_1 and passout_time_stage = 0:
         print("timeout, dim screen %d" % int(cur_time - everytime_keydown))
 
         try:
@@ -119,6 +125,7 @@ def InspectionTeam(main_screen):
                 brt=int(content[0])
                 if brt > 1:
                     last_brt = brt ## remember brt for restore
+
                     brt = 1
                     f.seek(0)
                     f.write(str(brt))
@@ -127,6 +134,34 @@ 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 = 1:
+        print("Power Off now")
+        
+        passout_time_stage = 0
         everytime_keydown = cur_time
         
     return True
@@ -184,6 +219,11 @@ def event_process(event,main_screen):
                 os.chdir( GetExePath())
                 os.exelp("python","python"," "+myscriptname)
             return
+
+        if event.type == POWEROPT:
+            everytime_keydown = time.time()
+
+            return
         if event.type == pygame.KEYUP:
             
             pygame.event.clear(pygame.KEYDOWN)
@@ -378,5 +418,12 @@ if __name__ == '__main__':
         exit()
 
 
+    with open(".powerlevel","r") as f:
+        powerlevel = f.read()
+    
+    powerlevel = powerlevel.strip()
+    if powerlevel != "":
+        config.PowerLevel = powerlevel
+    
     big_loop()