clockworkpi/launcher
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: clockworkpi/launcher:1.2
Branches Tags
clockworkpi/launcher:master clockworkpi/launcher:gcores clockworkpi/launcher:develop
clockworkpi/launcher:1.22 clockworkpi/launcher:1.21 clockworkpi/launcher:1.2
..
compare: clockworkpi/launcher:develop
Branches Tags
clockworkpi/launcher:master clockworkpi/launcher:gcores clockworkpi/launcher:develop
clockworkpi/launcher:1.22 clockworkpi/launcher:1.21 clockworkpi/launcher:1.2

7 Commits
1.2 .. develop

Author SHA1 Message Date
cuu 19276110a5 fix bug dosbox on rom_list_page and remove scalesmooth on sec level icons 2018-06-20 22:06:31 +08:00
cuu b98223b731 fix fav display bug on dosbox 2018-06-20 22:06:31 +08:00
cuu 7ec97f3e12 add dosbox on fav 2018-06-20 22:06:31 +08:00
cuu 7569c9968d add dosbox 2018-06-20 22:06:31 +08:00
cuu 99197302df Move back to 10_Settings 2018-06-20 22:06:31 +08:00
cuu b52c811687 change load modules checking in Settings list_page 2018-06-20 22:06:31 +08:00
cuu 43c040cfbb develop branch commit 2018-06-20 22:06:31 +08:00
36 changed files with 3177 additions and 1706 deletions
Expand all files Collapse all files
.gitignore
+2 -4
View File
@@ -1,7 +1,5 @@
*.pyc
retroarch-core-options.cfg
*.lpl
*.swp
.bsv
*.pyc
sys.py/.powerlevel
sys.py/.buttonslayout
Menu/GameShell/10_Settings/ButtonsLayout/__init__.py
-174
View File
@@ -1,174 +0,0 @@
# -*- coding: utf-8 -*-
import pygame
import commands
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.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 ButtonsLayoutPage(Page):
_FootMsg = ["Nav.","","","Back","Toggle"]
_MyList = []
_ListFontObj = fonts["varela13"]
_AList = {}
_Scrolled = 0
_BGwidth = 320
_BGheight = 240-24-20
_DrawOnce = False
_Scroller = 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._Icons["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)
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 GetButtonsLayoutMode(self):
lm = "xbox"
try:
with open(".buttonslayout", "r") as f:
lm = f.read()
except:
None
if lm not in ["xbox","snes"]:
lm = "xbox"
return lm
def ToggleMode(self):
if self.GetButtonsLayoutMode() == "xbox":
with open(".buttonslayout", "w") as f:
f.write("snes")
self._dialog_index = 1
self._Screen.Draw()
self._Screen.SwapAndShow()
else:
with open(".buttonslayout", "w") as f:
f.write("xbox")
self._dialog_index = 0
self._Screen.Draw()
self._Screen.SwapAndShow()
def OnLoadCb(self):
self._Scrolled = 0
self._PosY = 0
self._DrawOnce = False
if self.GetButtonsLayoutMode() == "xbox":
self._dialog_index = 0
else:
self._dialog_index = 1
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.ToggleMode()
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/Airplane/__init__.py → Menu/GameShell/10_Settings/HelloWorld/__init__.py
+61 -122
View File
@@ -2,7 +2,7 @@
import pygame
#import math
import commands
import subprocess
#from beeprint import pp
from libs.roundrects import aa_round_rect
@@ -18,8 +18,6 @@ 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):
@@ -76,8 +74,8 @@ class InfoPageListItem(object):
class AirplanePage(Page):
_FootMsg = ["Nav.","","","Back","Toggle"]
class HelloWorldPage(Page):
_FootMsg = ["Nav.","","","Back",""]
_MyList = []
_ListFontObj = fonts["varela13"]
@@ -90,21 +88,53 @@ class AirplanePage(Page):
_DrawOnce = False
_Scroller = None
_EasingDur = 30
_airwire_y = 0
_dialog_index = 0
def __init__(self):
Page.__init__(self)
self._Icons = {}
def HelloWorld(self):
hello = {}
hello["key"] = "helloworld"
hello["label"] = "HelloWorld "
hello["value"] = "GameShell"
self._AList["hello"] = hello
def GenList(self):
self._MyList = []
start_x = 0
start_y = 10
last_height = 0
for i,u in enumerate( ["hello"] ):
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"] = fonts["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:
@@ -116,34 +146,8 @@ class AirplanePage(Page):
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 = IconItem()
bgpng._ImgSurf = MyIconPool._Icons["about_bg"]
bgpng._MyType = ICON_TYPES["STAT"]
bgpng._Parent = self
@@ -151,6 +155,7 @@ class AirplanePage(Page):
self._Icons["bg"] = bgpng
"""
self.HelloWorld()
self.GenList()
@@ -173,66 +178,12 @@ class AirplanePage(Page):
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()
@@ -243,19 +194,7 @@ class AirplanePage(Page):
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()
@@ -264,29 +203,29 @@ class AirplanePage(Page):
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()
if self._DrawOnce == False:
self.ClearCanvas()
#self._Ps.Draw()
if "bg" in self._Icons:
self._Icons["bg"].NewCoord(self._Width/2,self._Height/2 + (self._BGheight - Height)/2 + self._Screen._TitleBar._Height)
self._Icons["bg"].Draw()
self._Icons["GS"].NewCoord(98,118)
self._Icons["GS"].Draw()
for i in self._MyList:
i.Draw()
self._DrawOnce = True
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()
self._Scroller.UpdateSize(self._BGheight,abs(self._Scrolled)*3)
self._Scroller.Draw()
@@ -297,9 +236,9 @@ class APIOBJ(object):
def __init__(self):
pass
def Init(self,main_screen):
self._Page = AirplanePage()
self._Page = HelloWorldPage()
self._Page._Screen = main_screen
self._Page._Name ="Airplane Mode"
self._Page._Name ="HelloWorld"
self._Page.Init()
def API(self,main_screen):
Menu/GameShell/10_Settings/PowerOptions/__init__.py
-573
View File
@@ -1,573 +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"
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._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/Sound/sound_page.py
+4 -12
View File
@@ -122,20 +122,12 @@ class SoundPage(Page):
self._MySlider.Init()
try:
m = alsaaudio.Mixer()
self._MySlider.SetValue(m.getvolume()[0])
except Exception,e:
print(str(e))
self._MySlider.SetValue(0)
m = alsaaudio.Mixer()
self._MySlider.SetValue(m.getvolume()[0])
def OnLoadCb(self):
try:
m = alsaaudio.Mixer()
self._MySlider.SetValue(m.getvolume()[0])
except Exception,e:
print(str(e))
m = alsaaudio.Mixer()
self._MySlider.SetValue(m.getvolume()[0])
def WhenSliderDrag(self,value): ##value 0-100
if value < 0 or value > 100:
Menu/GameShell/10_Settings/Wifi/wifi_list.py
-5
View File
@@ -373,7 +373,6 @@ class WifiList(Page):
self._CanvasHWND = None
def ShowBox(self,msg):
self._MsgBox._Text = msg
self._ShowingMessageBox = True
self._Screen.Draw()
@@ -472,7 +471,6 @@ class WifiList(Page):
self._PrevWicdState = state
def SetConnectingStatus(self,fast):
wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
"""
@@ -528,9 +526,6 @@ class WifiList(Page):
return True
def DbusDaemonStatusChangedSig(self,state=None,info=None):
if self._Screen._CurrentPage != self:
return
print("in DbusDaemonStatusChangedSig")
"""
dbus.UInt32(2L)
Menu/GameShell/10_Settings/list_page.py
+2 -4
View File
@@ -76,16 +76,14 @@ class ListPage(Page):
self._PsIndex = 0
# "" pkgname, label
alist = [["","Airplane","Airplane Mode"],
["","PowerOptions","Power Options"],
["","Wifi","Wi-Fi"],
alist = [["","Wifi","Wi-Fi"],
["","Sound","Sound Volume"],
["","Brightness","BackLight Brightness"],
["","Storage",""],
["","Update", ""],
["","About", "About"],
["","PowerOFF","Power off"],
["","ButtonsLayout","Buttons Layout"],]
["","HelloWorld","HelloWorld"],]
start_x = 0
start_y = 0
Menu/GameShell/20_Retro Games/.bsv
BIN
View File
Binary file not shown.
Menu/GameShell/20_Retro Games/DOSBOX/action.config
+8
View File
@@ -0,0 +1,8 @@
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
Menu/GameShell/20_Retro Games/DOSBOX/retroarch.cfg
+2880
View File
File diff suppressed because it is too large Load Diff
Menu/GameShell/20_Retro Games/MAME/action.config
+1
View File
@@ -4,3 +4,4 @@ EXT=zip
LAUNCHER=retroarch -L
TITLE=MAME Roms
SO_URL=http://buildbot.libretro.com/nightly/linux/armhf/latest/mame2003_plus_libretro.so.zip
RETRO_CONFIG=/home/cpi/apps/launcher/Menu/GameShell/20_Retro\ Games/MAME/retroarch.cfg
Menu/GameShell/20_Retro Games/NESTOPIA/action.config
+1 -1
View File
@@ -1,6 +1,6 @@
ROM=/home/cpi/games/NESTOPIA
ROM_SO=/home/cpi/apps/emulators/nestopia_libretro.so
EXT=zip,nes
EXT=zip
LAUNCHER=retroarch -L
TITLE=NESTOPIA Roms
SO_URL=http://buildbot.libretro.com/nightly/linux/armhf/latest/nestopia_libretro.so.zip
Menu/GameShell/Music Player/list_item.py
+1 -2
View File
@@ -65,7 +65,7 @@ class ListItem(object):
_PlayingProcess = 0 # 0 - 100
_Parent = None
_Text = ""
def __init__(self):
self._Labels = {}
self._Icons = {}
@@ -75,7 +75,6 @@ class ListItem(object):
def Init(self,text):
#self._Fonts["normal"] = fonts["veramono12"]
self._Text = text
l = ListItemLabel()
l._PosX = 22
Menu/GameShell/Music Player/mpd_spectrum_page.py
+149 -305
View File
@@ -1,71 +1,136 @@
# -*- coding: utf-8 -*-
import os
import time
import pygame
import numpy
import math
from numpy import fromstring,ceil,abs,log10,isnan,isinf,int16
from numpy import fft as Fft
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
from list_item import ListItem
import myvars
class PIFI(object):
_MPD_FIFO = "/tmp/mpd.fifo"
_SAMPLE_SIZE = 1024
_SAMPLE_SIZE = 256
_SAMPLING_RATE = 44100
_FIRST_SELECTED_BIN = 5
_NUMBER_OF_SELECTED_BINS = 1024
_NUMBER_OF_SELECTED_BINS = 10
_SCALE_WIDTH = Height/2 - 20
count = 0
average = 0
def __init__(self):
self.sampleSize = self._SAMPLE_SIZE
self.samplingRate = self._SAMPLING_RATE
self.firstSelectedBin = self._FIRST_SELECTED_BIN
self.numberOfSelectedBins = self._NUMBER_OF_SELECTED_BINS
def GetSpectrum(self,fifoFile,trim_by=10,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")
return rawSamples
except Exception,e:
return ""
data = numpy.fromstring(rawSamples, 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)
# Initialization : frequency bins
freq = Fft.fftfreq(self.sampleSize) * self.samplingRate
freqR = freq[:self.sampleSize/2]
self.bins = freqR[self.firstSelectedBin:self.firstSelectedBin+self.numberOfSelectedBins]
return spec_y
self.resetSmoothing()
def resetSmoothing(self):
self.count = 0
self.average = 0
def smoothOut(self, x):
self.count += 1
self.average = (self.average*self.count + x) / (self.count+1)
return self.average
def scaleList(self, _list):
for i,x in enumerate(_list):
if isnan(x) or isinf(x):
_list[i] = 0
# Compute a simple just-above 'moving average' of maximums
maximum = 1.1*self.smoothOut(max( _list ))
if maximum == 0:
scaleFactor = 0.0
else:
scaleFactor = self._SCALE_WIDTH/float(maximum)
# Compute the scaled list of values
scaledList = [int(x*scaleFactor) for x in _list ]
return scaledList
def computeSpectrum(self, fifoFile):
# Read PCM samples from fifo
rawSamples = fifoFile.read(self.sampleSize) # will return empty lines (non-blocking)
if len(rawSamples) == 0:
print("computeSpectrum read zero")
return [],[]
else:
pass
## print("computeSpectrum %d " % len(rawSamples))
pcm = fromstring(rawSamples, dtype=int16)
# Normalize [-1; +1]
pcm = pcm / (2.**15)
# Compute FFT
N = pcm.size
fft = Fft.fft(pcm)
uniquePts = ceil((N+1)/2.0)
fft = fft[0:int(uniquePts)]
# Compute amplitude spectrum
amplitudeSpectrum = abs(fft) / float(N)
# Compute power spectrum
p = amplitudeSpectrum**2
# Multiply by two to keep same energy
# See explanation:
# https://web.archive.org/web/20120615002031/http://www.mathworks.com/support/tech-notes/1700/1702.html
if N % 2 > 0:
# odd number of points
# odd nfft excludes Nyquist point
p[1:len(p)] = p[1:len(p)] * 2
else:
# even number of points
p[1:len(p) -1] = p[1:len(p) - 1] * 2
# Power in logarithmic scale (dB)
logPower = 10*log10(p)
# Compute RMS from power
#rms = numpy.sqrt(numpy.sum(p))
#print "RMS(power):", rms
# Select a significant range in the spectrum
spectrum = logPower[self.firstSelectedBin:self.firstSelectedBin+self.numberOfSelectedBins]
# Scale the spectrum
scaledSpectrum = self.scaleList(spectrum)
return (self.bins, scaledSpectrum)
class MPDSpectrumPage(Page):
_Icons = {}
@@ -73,44 +138,13 @@ class MPDSpectrumPage(Page):
_FootMsg = ["Nav","","","Back",""]
_MyList = []
_ListFont = fonts["veramono12"]
_SongFont = fonts["notosanscjk12"]
_PIFI = None
_FIFO = None
_FiFo = None
_Color = pygame.Color(126,206,244)
_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)
@@ -125,68 +159,21 @@ class MPDSpectrumPage(Page):
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._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._cwp_png = IconItem()
self._cwp_png._ImgSurf = MyIconPool._Icons["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,(255,255,255))
self._title = Label()
self._title.SetCanvasHWND(self._CanvasHWND)
self._title.Init("Title:",self._ListFont,(255,255,255))
self._time = Label()
self._time.SetCanvasHWND(self._CanvasHWND)
self._time.Init("Time:",self._ListFont,(255,255,255))
self._time2 = Label()
self._time2.SetCanvasHWND(self._CanvasHWND)
self._time2.Init("00:00-00:00",self._ListFont,(255,255,255))
self.Start()
def Start(self):
if self._Screen.CurPage() != self:
return
self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
def Start(self):
try:
self._FIFO = os.open(self._PIFI._MPD_FIFO, os.O_RDONLY | os.O_NONBLOCK)
self._FIFO = open(self._PIFI._MPD_FIFO)
q = Queue()
self._Queue = q
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)
@@ -195,80 +182,52 @@ class MPDSpectrumPage(Page):
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 > 40:
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()
if self._FIFO == None:
print("self._FIFO none")
return
(bins,scaledSpectrum) = self._PIFI.computeSpectrum(self._FIFO)
self._Queue.put( scaledSpectrum )
self._KeepReading = False
return ## Thread ends
def Playing(self):
self._Screen.Draw()
self._Screen.SwapAndShow()
def ClearCanvas(self):
self._CanvasHWND.fill((0,0,0))
def SgsSmooth(self):
passes = 1
points = 3
origs = self._bby[:]
for p in range(0,passes):
pivot = int(points/2.0)
if self._Screen.CurPage() == self:
if self._KeepReading == False:
self._KeepReading = True
t = Thread(target=self.GetSpectrum)
t.daemon=True
t.start()
self._Screen.Draw()
self._Screen.SwapAndShow()
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[:]
else:
return False
return True
def OnLoadCb(self):
if self._Neighbor != None:
if self._Queue != None:
with self._Queue.mutex:
self._Queue.queue.clear()
try:
if self._GobjectIntervalId != -1:
gobject.source_remove(self._GobjectIntervalId)
except:
pass
if self._KeepReading == False:
self._KeepReading = True
if self._FIFO == None:
self.Start()
self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
def KeyDown(self,event):
if event.key == CurKeys["Menu"] or event.key == CurKeys["A"]:
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()
@@ -283,134 +242,19 @@ class MPDSpectrumPage(Page):
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((0,0,0))
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) )
self._bbs = []
for i in range(0,meterNum):
index = int(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 * 100
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
spects = self._Queue.get_nowait()
# print("get_nowait: " , spects)
except Empty:
return
else: # got line
if len(self._vis_values) == 0:
if len(spects) == 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,(255,255,255),(i*(bw+gap)+margin_left,self._Height-gap-self._capYPositionArray[i]-margin_bottom,bw,gap),0)
pygame.draw.rect(self._CanvasHWND,(255,255,255),(i*(bw+gap)+margin_left,self._Height-value-gap-margin_bottom,bw,value+gap),0)
self._vis_values[i] -= 2
w = self._Width / len(spects)
left_margin = (w-bw)/2
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/pages.py
+1 -1
View File
@@ -34,5 +34,5 @@ def InitListPage(main_screen):
def InitSpectrumPage(main_screen):
myvars.SpectrumPage = MPDSpectrumPage()
myvars.SpectrumPage._Screen = main_screen
myvars.SpectrumPage._Name = "GameShell RTA"
myvars.SpectrumPage._Name = "Spectrum"
myvars.SpectrumPage.Init()
Menu/GameShell/Music Player/play_list_page.py
+6 -17
View File
@@ -59,20 +59,17 @@ class PlayListPage(Page):
_Icons = {}
_Selector=None
_FootMsg = ["Nav","RTA","Remove","Back","Play/Pause"]
_FootMsg = ["Nav","","Remove","Back","Play/Pause"]
_MyList = []
_ListFont = fonts["notosanscjk15"]
_Scroller = None
_CurSongTime="0:0"
_BGpng = None
_BGwidth = 75
_BGheight = 70
_Scrolled = 0
_CurSongName = ""
def __init__(self):
self._Icons = {}
@@ -113,13 +110,12 @@ class PlayListPage(Page):
self.SyncPlaying()
def GObjectInterval(self): ## 250 ms
self.SyncPlaying()
def GObjectInterval(self): ## 250 ms
if self._Screen.CurPage() == self:
self.SyncPlaying()
self._Screen.Draw()
self._Screen.SwapAndShow()
return True
def SyncPlaying(self):
@@ -128,7 +124,6 @@ class PlayListPage(Page):
current_song = myvars.Poller.poll()
for i ,v in enumerate(self._MyList):
self._MyList[i]._Playing = False
self._MyList[i]._PlayingProcess = 0
@@ -137,22 +132,19 @@ class PlayListPage(Page):
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):
@@ -249,8 +241,6 @@ class PlayListPage(Page):
if event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
if myvars.Poller != None:
myvars.Poller.stop()
self._CurSongTime=""
self._CurSongName=""
self.ReturnToUpLevelPage()
self._Screen.Draw()
@@ -280,8 +270,7 @@ class PlayListPage(Page):
if event.key == CurKeys["Enter"]:
self.Click()
if event.key == CurKeys["X"]: # start spectrum
myvars.SpectrumPage._Neighbor = self
if event.key == CurKeys["Start"]: # start spectrum
self._Screen.PushPage(myvars.SpectrumPage)
self._Screen.Draw()
self._Screen.SwapAndShow()
skin/default/sys.py/gameshell/icons/DialogBoxs.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 5.1 KiB

skin/default/sys.py/gameshell/icons/GS.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 599 B

skin/default/sys.py/gameshell/icons/airwire.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 111 B

skin/default/sys.py/gameshell/icons/buttonslayout.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 21 KiB

skin/default/sys.py/gameshell/icons/sheep_bg.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 19 KiB

skin/default/sys.py/gameshell/icons/sheep_body.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.2 KiB

skin/default/sys.py/gameshell/icons/sheep_head.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.0 KiB

skin/default/sys.py/gameshell/icons/tape.png
BIN
View File
Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.2 KiB

skin/default/sys.py/gameshell/titlebar_icons/wifi.png
BIN
View File
Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 1.4 KiB

After

Width:  |  Height:  |  Size: 1.9 KiB

sys.py/UI/constants.py
+6 -4
View File
@@ -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
RUNSYS = pygame.USEREVENT+3
RUNEVT = pygame.USEREVENT+2
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/counter_screen.py
-112
View File
@@ -1,112 +0,0 @@
# -*- coding: utf-8 -*-
import pygame
import gobject
import commands
## local package import
from constants import Width,Height,RUNSYS
from label import Label
from fonts import fonts
from full_screen import FullScreen
import config
class CounterScreen(FullScreen):
_CounterFont = fonts["varela120"]
_TextFont1 = fonts["varela15"]
_TextFont2 = fonts["varela12"]
_TopLabel = None
_BottomLabel = None
_NumberLabel = None
_BGColor = pygame.Color(0,0,0)
_FGColor = pygame.Color(255,255,255)
_Counting = False
_Number = 10
_GobjectIntervalId = -1
_inter_counter = 0
def GObjectInterval(self):
self._inter_counter+=1
if self._Number == 0:
self._Counting = False
print("do the real shutdown")
if config.CurKeySet != "PC":
cmdpath = "feh --bg-center gameshell/wallpaper/seeyou.png;"
cmdpath += "sleep 3;"
cmdpath += "sudo halt -p"
pygame.event.post( pygame.event.Event(RUNSYS, message=cmdpath))\
return False
if self._inter_counter >=2:
self._Number -= 1
if self._Number < 0:
self._Number = 0
print("sub Number %d " % self._Number)
self._inter_counter = 0
self.Draw()
self.SwapAndShow()
return self._Counting
def StartCounter(self):
if self._Counting == True:
return
self._Number = 10
self._Counting = True
self._GobjectIntervalId = gobject.timeout_add(500,self.GObjectInterval)
def StopCounter(self):
if self._Counting == False:
return
self._Counting = False
self._Number = 10
if self._GobjectIntervalId != -1:
gobject.source_remove(self._GobjectIntervalId)
self._GobjectIntervalId = -1
return
def Init(self):
self._CanvasHWND = pygame.Surface((self._Width,self._Height))
self._TopLabel = Label()
self._TopLabel.SetCanvasHWND(self._CanvasHWND)
self._TopLabel.Init("System shutdown in", self._TextFont1, self._FGColor)
self._BottomLabel = Label()
self._BottomLabel.SetCanvasHWND(self._CanvasHWND)
self._BottomLabel.Init("Press any key to stop countdown", self._TextFont2, self._FGColor)
self._NumberLabel = Label()
self._NumberLabel.SetCanvasHWND(self._CanvasHWND)
self._NumberLabel.Init(str(self._Number), self._CounterFont, self._FGColor)
def Draw(self):
self._CanvasHWND.fill( self._BGColor )
self._TopLabel.NewCoord(Width/2, 15)
self._TopLabel.DrawCenter()
self._BottomLabel.NewCoord(Width/2, Height-15)
self._BottomLabel.DrawCenter()
self._NumberLabel.NewCoord(Width/2,Height/2)
self._NumberLabel.SetText(str(self._Number))
self._NumberLabel.DrawCenter()
sys.py/UI/fonts.py
-1
View File
@@ -38,7 +38,6 @@ fonts["varela27"] = pygame.font.Font(fonts_path["varela"],27)
fonts["varela28"] = pygame.font.Font(fonts_path["varela"],28)
fonts["varela34"] = pygame.font.Font(fonts_path["varela"],34)
fonts["varela40"] = pygame.font.Font(fonts_path["varela"],40)
fonts["varela120"] = pygame.font.Font(fonts_path["varela"],120)
fonts["veramono25"] = pygame.font.Font(fonts_path["veramono"],25)
fonts["veramono24"] = pygame.font.Font(fonts_path["veramono"],24)
sys.py/UI/foot_bar.py
+1 -17
View File
@@ -131,24 +131,8 @@ class FootBar:
self.Draw()
def GetButtonsLayoutMode(self):
lm = "xbox"
try:
with open(".buttonslayout", "r") as f:
lm = f.read()
except:
None
if lm not in ["xbox","snes"]:
lm = "xbox"
return lm
def SetLabelTexts(self,texts):
barr = ["nav","x","y","a","b"]
if self.GetButtonsLayoutMode() == "snes":
barr = ["nav","y","x","b","a"]
for idx,x in enumerate(barr):
for idx,x in enumerate(("nav","x","y","a","b")):
try:
self._Icons[x]._Label.SetText(texts[idx])
except IndexError:
sys.py/UI/full_screen.py
-38
View File
@@ -1,38 +0,0 @@
# -*- coding: utf-8 -*-
import pygame
#from sys import exit
#import os
#import sys
#from libs import easing
#from datetime import datetime
#from beeprint import pp
## local package import
from constants import Width,Height
class FullScreen(object):
_PosX = 0
_PosY = 0
_Width = Width
_Height = Height
_CanvasHWND = None
_HWND = None
def __init__(self):
pass
def Init(self):
pass
def SwapAndShow(self):
if self._HWND != None:
self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width,self._Height))
pygame.display.update()
def Draw(self):
pass
sys.py/UI/label.py
+2 -9
View File
@@ -4,8 +4,6 @@ import pygame
#import base64
#from beeprint import pp
from constants import Width,Height
from util_funcs import midRect
class Label:
_PosX=0
@@ -52,13 +50,8 @@ class Label:
def SetCanvasHWND(self,_canvashwnd):
self._CanvasHWND = _canvashwnd
def DrawCenter(self,bold=False):
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,midRect(self._PosX,self._PosY,self._Width,self._Height,Width,Height))
def Draw(self,bold=False):
self._FontObj.set_bold(bold) ## avoing same font tangling set_bold to others
def Draw(self):
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
+19 -63
View File
@@ -26,7 +26,6 @@ from untitled_icon import UntitledIcon
from Emulator import MyEmulator
from skin_manager import SkinManager
from counter_screen import CounterScreen
class MessageBox(Label):
_Parent = None
@@ -46,8 +45,8 @@ 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))
@@ -88,31 +87,20 @@ 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
pygame.draw.rect(self._HWND,(255,255,255),(x_-padding,y_-padding, self._Width+padding*2,self._Height+padding*2))
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))
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)
def Draw(self):
x = (self._Parent._Width)/2
y = (self._Parent._Height)/2
self.DrawWith(x,y,True)
pygame.draw.rect(self._HWND,(0,0,0),(x-padding,y-padding, self._Width+padding*2,self._Height+padding*2),1)
python_package_flag = "__init__.py"
emulator_flag = "action.config"
@@ -125,7 +113,7 @@ class MainScreen(object):
_PosX = 0
_PosY = TitleBar._BarHeight+1
_Width = Width
_Height = Height -FootBar._BarHeight -TitleBar._BarHeight
_Height = Height -FootBar._BarHeight -TitleBar._BarHeight-1
_MyPageStack = None
_CurrentPage = None # pointer to the current displaying Page Class
_CanvasHWND = None
@@ -136,9 +124,6 @@ class MainScreen(object):
_MsgBoxFont = fonts["veramono20"]
_IconFont = fonts["varela15"]
_SkinManager = None
_Closed = False
_CounterScreen = None
def __init__(self):
self._Pages = []
@@ -152,12 +137,6 @@ class MainScreen(object):
self._SkinManager = SkinManager()
self._SkinManager.Init()
self._CounterScreen = CounterScreen()
self._CounterScreen._HWND = self._HWND
self._CounterScreen.Init()
def FartherPages(self):
self._PageMax = len(self._Pages)
@@ -350,8 +329,6 @@ class MainScreen(object):
self._CanvasHWND.fill((255,255,255))
def SwapAndShow(self):
if self._Closed == True:
return
if self._HWND != None:
self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width,self._Height))
pygame.display.update()
@@ -366,15 +343,6 @@ class MainScreen(object):
else:
return name
def IsExecPackage(self,dirname):
files = os.listdir(dirname)
bname = os.path.basename(dirname)
bname = self.ExtraName(bname)
for i in sorted(files):
if i == bname+".sh":
return True
return False
def IsEmulatorPackage(self,dirname):
files = os.listdir(dirname)
for i in sorted(files):
@@ -408,9 +376,7 @@ class MainScreen(object):
iconitem = IconItem()
iconitem._CmdPath = ""
iconitem.AddLabel(i2,self._IconFont)
if FileExists( _dir+"/"+i+"/"+i2+".png"): ### 20_Prog/Prog.png , cut 20_
iconitem._ImageName = _dir+"/"+i+"/"+i2+".png"
elif FileExists( SkinMap(_dir+"/"+i2+".png") ):
if FileExists( SkinMap(_dir+"/"+i2+".png") ):
iconitem._ImageName = SkinMap(_dir+"/"+i2+".png")
else:
untitled = UntitledIcon()
@@ -469,12 +435,7 @@ class MainScreen(object):
iconitem._CmdPath = em
iconitem._MyType = ICON_TYPES["Emulator"]
cur_page._Icons.append(iconitem)
elif self.IsExecPackage(_dir+"/"+i):
iconitem._MyType = ICON_TYPES["EXE"]
iconitem._CmdPath = os.path.realpath(_dir+"/"+i+"/"+i2+".sh")
MakeExecutable(iconitem._CmdPath)
cur_page._Icons.append(iconitem)
else:
iconitem._MyType = ICON_TYPES["DIR"]
iconitem._LinkPage = Page()
@@ -488,7 +449,7 @@ class MainScreen(object):
#cmd = ReadTheFileContent(_dir+"/"+i)
iconitem = IconItem()
iconitem._CmdPath = os.path.realpath(_dir+"/"+i)
iconitem._CmdPath = _dir+"/"+i
MakeExecutable(iconitem._CmdPath)
iconitem._MyType = ICON_TYPES["EXE"]
if FileExists( SkinMap( _dir+"/"+ReplaceSuffix(i2,"png"))):
@@ -517,6 +478,7 @@ class MainScreen(object):
pygame.time.delay(1000)
cmdpath = cmdpath.strip()
cmdpath = CmdClean(cmdpath)
pygame.event.post( pygame.event.Event(RUNEVT, message=cmdpath))
def OnExitCb(self,event):
@@ -536,17 +498,14 @@ class MainScreen(object):
self.EasingAllPageRight()
#self.SwapAndShow()
"""
if event.key == pygame.K_t:
self.DrawRun()
self.SwapAndShow()
"""
if event.key == CurKeys["Space"]:
self._CounterScreen.Draw()
self._CounterScreen.SwapAndShow()
self._CounterScreen.StartCounter()
"""
self.Draw()
self.SwapAndShow()
## leave rest to Pages
current_page_key_down_cb = getattr(self._CurrentPage,"KeyDown",None)
if current_page_key_down_cb != None:
@@ -559,9 +518,6 @@ class MainScreen(object):
self._MsgBox.Draw()
def Draw(self):
if self._Closed == True:
return
self._CurrentPage.Draw()
#if self._HWND != None:
# self._HWND.blit(self._CanvasHWND,(self._PosX,self._PosY,self._Width,self._Height))
sys.py/UI/multi_icon_item.py
+1 -24
View File
@@ -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:
@@ -57,11 +36,9 @@ 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/title_bar.py
+9 -24
View File
@@ -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 = {}
@@ -59,13 +57,14 @@ class TitleBar:
self.SyncSoundVolume()
self.UpdateWifiStrength()
SwapAndShow()
# print("TitleBar Gobjectroundrobin")
elif self._InLowBackLight >= 0:
else:
self._InLowBackLight+=1
if self._InLowBackLight > 10:
self.CheckBatteryStat()
self.SyncSoundVolume()
self.UpdateWifiStrength()
SwapAndShow()
self._InLowBackLight = 0
return True
@@ -95,12 +94,8 @@ class TitleBar:
return ge
def SyncSoundVolume(self):
try:
m = alsaaudio.Mixer()
vol = m.getvolume()[0]
except Exception,e:
print(str(e))
vol = 0
m = alsaaudio.Mixer()
vol = m.getvolume()[0]
snd_segs = [ [0,10],[10,30],[30,70],[70,100] ]
@@ -126,7 +121,7 @@ class TitleBar:
f = open(Battery)
except IOError:
self._Icons["battery"] = self._Icons["battery_unknown"]
# print("CheckBatteryStat open failed")
print("CheckBatteryStat open failed")
return False
else:
with f:
@@ -242,13 +237,7 @@ 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") )
@@ -302,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
else:
self._Icons["wifistatus"]._IconIndex = 5 ## airplane mode icon
self._Icons["wifistatus"]._IconIndex = 0
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
+1 -14
View File
@@ -12,19 +12,6 @@ MPD_socket = "/tmp/mpd.socket"
UPDATE_URL="https://raw.githubusercontent.com/clockworkpi/CPI/master/launcher_ver.json"
VERSION="stable 1.2"
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,120]
PowerLevels["powersaving"] = [40,120,300]
PowerLevels["server"] = [40,120,0]
PowerLevels["balance_saving"] = [40,0,0]
PowerLevel = "balance_saving"
##sys.py/.powerlevel
sys.py/run.py
+22 -180
View File
@@ -3,7 +3,6 @@
import dbus
import dbus.service
import sys
import commands
from wicd import misc
##misc.to_bool
##misc.misc.noneToString
@@ -31,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
@@ -60,13 +59,8 @@ myscriptname = os.path.basename(os.path.realpath(__file__))
everytime_keydown = time.time()
passout_time_stage = 0
last_brt = -1
gobject_flash_led1 = -1
gobject_flash_led1_counter = 0
def gobject_loop():
"""
here to receive dbus signal
@@ -77,71 +71,12 @@ def gobject_loop():
gobject_main_loop.quit()
exit(-1)
def GobjectFlashLed1(main_screen):
global gobject_flash_led1_counter
if main_screen._Closed == False:
if gobject_flash_led1_counter > 0:
try:
f = open("/proc/driver/led1","w")
except IOError:
print( "open /proc/driver/led1 IOError")
pass
else:
with f:
f.seek(0)
f.write("0")
f.truncate()
f.close()
gobject_flash_led1_counter = 0
return True
gobject_flash_led1_counter+=1
if gobject_flash_led1_counter == 3:
try:
f = open("/proc/driver/led1","w")
except IOError:
print( "open /proc/driver/led1 IOError")
pass
else:
with f:
f.seek(0)
f.write("1")
f.truncate()
f.close()
elif gobject_flash_led1_counter == 5:
try:
f = open("/proc/driver/led1","w")
except IOError:
print( "open /proc/driver/led1 IOError")
pass
else:
with f:
f.seek(0)
f.write("0")
f.truncate()
f.close()
if gobject_flash_led1_counter == 11:
gobject_flash_led1_counter = 1
return True
def RestoreLastBackLightBrightness(main_screen):
global last_brt,passout_time_stage,gobject_flash_led1
passout_time_stage = 0
main_screen._TitleBar._InLowBackLight = -1
main_screen._Closed = False
global last_brt
if last_brt == -1:
return True
return
try:
f = open(config.BackLight,"r+")
@@ -159,39 +94,18 @@ def RestoreLastBackLightBrightness(main_screen):
f.truncate()
f.close()
last_brt = -1
else:
main_screen._TitleBar._InLowBackLight = -1
else:
f.close()
try:
f = open("/proc/driver/led1","w")
except IOError:
print( "open /proc/driver/led1 IOError")
pass
else:
with f:
f.seek(0)
f.write("0")
f.truncate()
f.close()
if main_screen._CounterScreen._Counting==True:
main_screen._CounterScreen.StopCounter()
main_screen.Draw()
main_screen.SwapAndShow()
return False
return True
return
def InspectionTeam(main_screen):
global everytime_keydown,last_brt,passout_time_stage,gobject_flash_led1
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:
@@ -203,68 +117,17 @@ def InspectionTeam(main_screen):
content = f.readlines()
content = [x.strip() for x in content]
brt=int(content[0])
if brt > 0:
if last_brt < 0:
last_brt = brt ## remember brt for restore
if brt > 1:
last_brt = brt ## remember brt for restore
brt = 1
f.seek(0)
f.write(str(brt))
f.truncate()
f.close()
main_screen._TitleBar._InLowBackLight = 0
if time_2 != 0:
passout_time_stage = 1 # next
main_screen._TitleBar._InLowBackLight = 0
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
main_screen._Closed = True
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 counting down")
main_screen._CounterScreen.Draw()
main_screen._CounterScreen.SwapAndShow()
main_screen._CounterScreen.StartCounter()
try:
f = open(config.BackLight,"r+")
except IOError:
pass
else:
with f:
brt = last_brt
f.seek(0)
f.write(str(brt))
f.truncate()
f.close()
main_screen._TitleBar._InLowBackLight = 0
passout_time_stage = 4
return True
@@ -283,7 +146,8 @@ def event_process(event,main_screen):
main_screen.SwapAndShow()
pygame.event.clear(GMEVT)
return
if event.type == RUNEVT:
if event.type == RUNEVT:
if config.DontLeave==True:
os.chdir(GetExePath())
os.system( "/bin/sh -c "+event.message)
@@ -296,8 +160,7 @@ def event_process(event,main_screen):
pygame.quit()
gobject_main_loop.quit()
os.chdir( GetExePath())
exec_app_cmd = "cd "+os.path.dirname(event.message)+";"
exec_app_cmd += event.message
exec_app_cmd = event.message
exec_app_cmd += "; sync & cd "+GetExePath()+"; exec python "+myscriptname
print(exec_app_cmd)
os.execlp("/bin/sh","/bin/sh","-c", exec_app_cmd)
@@ -314,27 +177,20 @@ def event_process(event,main_screen):
pygame.quit()
gobject_main_loop.quit()
os.chdir( GetExePath())
exec_app_cmd = "cd "+os.path.dirname(event.message)+";"
exec_app_cmd += event.message
exec_app_cmd = event.message
exec_app_cmd += "; sync & cd "+GetExePath()+"; exec python "+myscriptname
print(exec_app_cmd)
os.execlp("/bin/sh","/bin/sh","-c", exec_app_cmd)
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)
return
if event.type == pygame.KEYDOWN:
everytime_keydown = time.time()
if RestoreLastBackLightBrightness(main_screen) == False:
return
RestoreLastBackLightBrightness(main_screen)
###########################################################
if event.key == pygame.K_q:
on_exit_cb = getattr(main_screen,"OnExitCb",None)
@@ -372,7 +228,6 @@ def event_process(event,main_screen):
###########################################################
if event.key == pygame.K_ESCAPE:
pygame.event.clear()
key_down_cb = getattr(main_screen,"KeyDown",None)
if key_down_cb != None:
@@ -453,7 +308,7 @@ def socket_thread(main_screen):
i._CmdPath.API(main_screen)
def big_loop():
global sound_patch,gobject_flash_led1
global sound_patch
title_bar = TitleBar()
title_bar.Init(screen)
@@ -468,7 +323,6 @@ def big_loop():
main_screen.ReadTheDirIntoPages("../Menu",0,None)
main_screen.FartherPages()
title_bar._SkinManager = main_screen._SkinManager
foot_bar._SkinManager = main_screen._SkinManager
@@ -482,13 +336,11 @@ def big_loop():
main_screen.SwapAndShow()
#gobject.timeout_add(DT,gobject_pygame_event_timer,main_screen)
gobject_flash_led1 = gobject.timeout_add(200,GobjectFlashLed1,main_screen)
gobject.timeout_add(DT,gobject_pygame_event_poll_timer,main_screen)
gobject.timeout_add(3000,title_bar.GObjectRoundRobin)
# socket_thread(main_screen)
socket_thread(main_screen)
gobject_loop()
@@ -505,7 +357,7 @@ if __name__ == '__main__':
screen = pygame.display.set_mode(SCREEN_SIZE, 0, 32)
pygame.event.set_allowed(None)
pygame.event.set_allowed([pygame.KEYDOWN,pygame.KEYUP,GMEVT,RUNEVT,RUNSYS,POWEROPT])
pygame.event.set_allowed([pygame.KEYDOWN,pygame.KEYUP,GMEVT,RUNEVT,RUNSYS])
pygame.key.set_repeat(DT+DT*6+DT/2, DT+DT*3+DT/2)
@@ -525,16 +377,6 @@ if __name__ == '__main__':
print("This pygame does not support PNG")
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()