Browse Source

Merge remote-tracking branch 'upstream/master'

Godzil 5 years ago
parent
commit
50a783db98
94 changed files with 816 additions and 230 deletions
  1. 2 0
      .gitignore
  2. BIN
      Menu/GameShell/10_Settings/About/__init__.pyc
  3. BIN
      Menu/GameShell/10_Settings/Airplane/__init__.pyc
  4. BIN
      Menu/GameShell/10_Settings/Brightness/__init__.pyc
  5. BIN
      Menu/GameShell/10_Settings/Brightness/brightness_page.pyc
  6. BIN
      Menu/GameShell/10_Settings/Brightness/myvars.pyc
  7. BIN
      Menu/GameShell/10_Settings/Brightness/pages.pyc
  8. 174 0
      Menu/GameShell/10_Settings/ButtonsLayout/__init__.py
  9. 7 1
      Menu/GameShell/10_Settings/PowerOptions/__init__.py
  10. BIN
      Menu/GameShell/10_Settings/PowerOptions/__init__.pyc
  11. BIN
      Menu/GameShell/10_Settings/Sound/__init__.pyc
  12. BIN
      Menu/GameShell/10_Settings/Sound/myvars.pyc
  13. BIN
      Menu/GameShell/10_Settings/Sound/pages.pyc
  14. 12 4
      Menu/GameShell/10_Settings/Sound/sound_page.py
  15. BIN
      Menu/GameShell/10_Settings/Sound/sound_page.pyc
  16. BIN
      Menu/GameShell/10_Settings/Storage/__init__.pyc
  17. BIN
      Menu/GameShell/10_Settings/Update/__init__.pyc
  18. BIN
      Menu/GameShell/10_Settings/Wifi/__init__.pyc
  19. BIN
      Menu/GameShell/10_Settings/Wifi/keyboard.pyc
  20. BIN
      Menu/GameShell/10_Settings/Wifi/myvars.pyc
  21. BIN
      Menu/GameShell/10_Settings/Wifi/net_item.pyc
  22. BIN
      Menu/GameShell/10_Settings/Wifi/pages.pyc
  23. BIN
      Menu/GameShell/10_Settings/Wifi/text_item.pyc
  24. BIN
      Menu/GameShell/10_Settings/Wifi/textarea.pyc
  25. 5 0
      Menu/GameShell/10_Settings/Wifi/wifi_list.py
  26. BIN
      Menu/GameShell/10_Settings/Wifi/wifi_list.pyc
  27. BIN
      Menu/GameShell/10_Settings/__init__.pyc
  28. BIN
      Menu/GameShell/10_Settings/list_item.pyc
  29. 2 1
      Menu/GameShell/10_Settings/list_page.py
  30. BIN
      Menu/GameShell/10_Settings/list_page.pyc
  31. BIN
      Menu/GameShell/10_Settings/myvars.pyc
  32. BIN
      Menu/GameShell/10_Settings/pages.pyc
  33. BIN
      Menu/GameShell/Music Player/__init__.pyc
  34. 2 1
      Menu/GameShell/Music Player/list_item.py
  35. BIN
      Menu/GameShell/Music Player/list_item.pyc
  36. 259 175
      Menu/GameShell/Music Player/mpd_spectrum_page.py
  37. BIN
      Menu/GameShell/Music Player/mpd_spectrum_page.pyc
  38. BIN
      Menu/GameShell/Music Player/music_lib_list_page.pyc
  39. BIN
      Menu/GameShell/Music Player/myvars.pyc
  40. 1 1
      Menu/GameShell/Music Player/pages.py
  41. BIN
      Menu/GameShell/Music Player/pages.pyc
  42. 7 0
      Menu/GameShell/Music Player/play_list_page.py
  43. BIN
      Menu/GameShell/Music Player/play_list_page.pyc
  44. BIN
      Menu/GameShell/PowerOFF/__init__.pyc
  45. BIN
      Menu/GameShell/TinyCloud/__init__.pyc
  46. BIN
      skin/default/sys.py/gameshell/icons/buttonslayout.png
  47. BIN
      skin/default/sys.py/gameshell/icons/tape.png
  48. 0 1
      sys.py/.powerlevel
  49. BIN
      sys.py/UI/Emulator/__init__.pyc
  50. BIN
      sys.py/UI/Emulator/fav_list_page.pyc
  51. BIN
      sys.py/UI/Emulator/list_item.pyc
  52. BIN
      sys.py/UI/Emulator/rom_list_page.pyc
  53. BIN
      sys.py/UI/Emulator/rom_so_confirm_page.pyc
  54. BIN
      sys.py/UI/__init__.pyc
  55. BIN
      sys.py/UI/above_all_patch.pyc
  56. BIN
      sys.py/UI/confirm_page.pyc
  57. BIN
      sys.py/UI/constants.pyc
  58. 112 0
      sys.py/UI/counter_screen.py
  59. BIN
      sys.py/UI/delete_confirm_page.pyc
  60. BIN
      sys.py/UI/download.pyc
  61. BIN
      sys.py/UI/download_process_page.pyc
  62. 1 0
      sys.py/UI/fonts.py
  63. BIN
      sys.py/UI/fonts.pyc
  64. 17 1
      sys.py/UI/foot_bar.py
  65. BIN
      sys.py/UI/foot_bar.pyc
  66. 38 0
      sys.py/UI/full_screen.py
  67. BIN
      sys.py/UI/icon_item.pyc
  68. BIN
      sys.py/UI/icon_pool.pyc
  69. BIN
      sys.py/UI/keys_def.pyc
  70. 7 0
      sys.py/UI/label.py
  71. BIN
      sys.py/UI/label.pyc
  72. 41 9
      sys.py/UI/main_screen.py
  73. BIN
      sys.py/UI/main_screen.pyc
  74. BIN
      sys.py/UI/multi_icon_item.pyc
  75. BIN
      sys.py/UI/multilabel.pyc
  76. BIN
      sys.py/UI/page.pyc
  77. BIN
      sys.py/UI/scroller.pyc
  78. BIN
      sys.py/UI/simple_name_space.pyc
  79. BIN
      sys.py/UI/skin_manager.pyc
  80. BIN
      sys.py/UI/slider.pyc
  81. 9 6
      sys.py/UI/title_bar.py
  82. BIN
      sys.py/UI/title_bar.pyc
  83. BIN
      sys.py/UI/untitled_icon.pyc
  84. BIN
      sys.py/UI/util_funcs.pyc
  85. 3 2
      sys.py/config.py
  86. BIN
      sys.py/config.pyc
  87. BIN
      sys.py/libs/DBUS/__init__.pyc
  88. BIN
      sys.py/libs/MPD/__init__.pyc
  89. BIN
      sys.py/libs/MPD/poller.pyc
  90. BIN
      sys.py/libs/__init__.pyc
  91. BIN
      sys.py/libs/easing.pyc
  92. BIN
      sys.py/libs/roundrects/__init__.pyc
  93. BIN
      sys.py/libs/roundrects/roundrects.pyc
  94. 117 28
      sys.py/run.py

+ 2 - 0
.gitignore

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

BIN
Menu/GameShell/10_Settings/About/__init__.pyc


BIN
Menu/GameShell/10_Settings/Airplane/__init__.pyc


BIN
Menu/GameShell/10_Settings/Brightness/__init__.pyc


BIN
Menu/GameShell/10_Settings/Brightness/brightness_page.pyc


BIN
Menu/GameShell/10_Settings/Brightness/myvars.pyc


BIN
Menu/GameShell/10_Settings/Brightness/pages.pyc


+ 174 - 0
Menu/GameShell/10_Settings/ButtonsLayout/__init__.py

@@ -0,0 +1,174 @@
+# -*- 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)
+    

+ 7 - 1
Menu/GameShell/10_Settings/PowerOptions/__init__.py

@@ -330,13 +330,19 @@ class PowerOptionsPage(Page):
         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","balance_saving"] ):
+        for i,u in enumerate( ["supersaving","powersaving","server","balance_saving"] ):
             if u not in self._AList:
                 continue
             

BIN
Menu/GameShell/10_Settings/PowerOptions/__init__.pyc


BIN
Menu/GameShell/10_Settings/Sound/__init__.pyc


BIN
Menu/GameShell/10_Settings/Sound/myvars.pyc


BIN
Menu/GameShell/10_Settings/Sound/pages.pyc


+ 12 - 4
Menu/GameShell/10_Settings/Sound/sound_page.py

@@ -122,12 +122,20 @@ class SoundPage(Page):
 
         self._MySlider.Init()
         
-        m = alsaaudio.Mixer()
-        self._MySlider.SetValue(m.getvolume()[0])
+        try:
+		m = alsaaudio.Mixer()
+	        self._MySlider.SetValue(m.getvolume()[0])
+	except Exception,e:
+		print(str(e))
+		self._MySlider.SetValue(0)
+
 
     def OnLoadCb(self):
-        m = alsaaudio.Mixer()
-        self._MySlider.SetValue(m.getvolume()[0])
+	try:
+	        m = alsaaudio.Mixer()
+        	self._MySlider.SetValue(m.getvolume()[0])
+	except Exception,e:
+		print(str(e))
                 
     def WhenSliderDrag(self,value): ##value 0-100
         if value < 0 or value > 100:

BIN
Menu/GameShell/10_Settings/Sound/sound_page.pyc


BIN
Menu/GameShell/10_Settings/Storage/__init__.pyc


BIN
Menu/GameShell/10_Settings/Update/__init__.pyc


BIN
Menu/GameShell/10_Settings/Wifi/__init__.pyc


BIN
Menu/GameShell/10_Settings/Wifi/keyboard.pyc


BIN
Menu/GameShell/10_Settings/Wifi/myvars.pyc


BIN
Menu/GameShell/10_Settings/Wifi/net_item.pyc


BIN
Menu/GameShell/10_Settings/Wifi/pages.pyc


BIN
Menu/GameShell/10_Settings/Wifi/text_item.pyc


BIN
Menu/GameShell/10_Settings/Wifi/textarea.pyc


+ 5 - 0
Menu/GameShell/10_Settings/Wifi/wifi_list.py

@@ -373,6 +373,7 @@ class WifiList(Page):
         self._CanvasHWND = None
     
     def ShowBox(self,msg):
+        
         self._MsgBox._Text = msg
         self._ShowingMessageBox = True
         self._Screen.Draw()
@@ -471,6 +472,7 @@ class WifiList(Page):
         self._PrevWicdState = state
         
     def SetConnectingStatus(self,fast):
+        
         wireless_connecting = self._Wireless.CheckIfWirelessConnecting()
 
         """
@@ -526,6 +528,9 @@ class WifiList(Page):
                 return True
 
     def DbusDaemonStatusChangedSig(self,state=None,info=None):
+        if self._Screen._CurrentPage != self:
+            return
+
         print("in DbusDaemonStatusChangedSig")
         """
         dbus.UInt32(2L)

BIN
Menu/GameShell/10_Settings/Wifi/wifi_list.pyc


BIN
Menu/GameShell/10_Settings/__init__.pyc


BIN
Menu/GameShell/10_Settings/list_item.pyc


+ 2 - 1
Menu/GameShell/10_Settings/list_page.py

@@ -84,7 +84,8 @@ class ListPage(Page):
                          ["","Storage",""],
                          ["","Update", ""],
                          ["","About",  "About"],
-                         ["","PowerOFF","Power off"],]
+                         ["","PowerOFF","Power off"],
+                         ["","ButtonsLayout","Buttons Layout"],]
 
         start_x  = 0
         start_y  = 0

BIN
Menu/GameShell/10_Settings/list_page.pyc


BIN
Menu/GameShell/10_Settings/myvars.pyc


BIN
Menu/GameShell/10_Settings/pages.pyc


BIN
Menu/GameShell/Music Player/__init__.pyc


+ 2 - 1
Menu/GameShell/Music Player/list_item.py

@@ -65,7 +65,7 @@ class ListItem(object):
     _PlayingProcess = 0 # 0 - 100
     _Parent  = None
     
-    
+    _Text = ""
     def __init__(self):
         self._Labels = {}
         self._Icons  = {}
@@ -75,6 +75,7 @@ class ListItem(object):
     def Init(self,text):
 
         #self._Fonts["normal"] = fonts["veramono12"]
+        self._Text = text
         
         l = ListItemLabel()
         l._PosX = 22

BIN
Menu/GameShell/Music Player/list_item.pyc


+ 259 - 175
Menu/GameShell/Music Player/mpd_spectrum_page.py

@@ -1,10 +1,11 @@
 # -*- coding: utf-8 -*- 
 
+import os
 import time
 import pygame
 
-from numpy import fromstring,ceil,abs,log10,isnan,isinf,int16,sqrt,mean
-from numpy import fft as Fft
+import numpy
+import math
 
 import gobject
 
@@ -20,141 +21,51 @@ 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 = 256
+    _SAMPLE_SIZE = 1024
     _SAMPLING_RATE = 44100
     _FIRST_SELECTED_BIN = 5
-    _NUMBER_OF_SELECTED_BINS = 10
-    _SCALE_WIDTH = Height/2 - 20
+    _NUMBER_OF_SELECTED_BINS = 1024
 
-    count = 0
-    average = 0
-
-    rmscount=0
-    rmsaverage=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
-        
-        # Initialization : frequency bins
-        freq = Fft.fftfreq(self.sampleSize) * self.samplingRate
-        freqR = freq[:self.sampleSize/2]
-        self.bins = freqR[self.firstSelectedBin:self.firstSelectedBin+self.numberOfSelectedBins]
         
-        self.resetSmoothing()
-    
-    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
-        self.average = (self.average*self.count + x) / (self.count+1)
-        return self.average
+    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 ""
     
-    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
+        data = numpy.fromstring(rawSamples, dtype=numpy.int16)
 
-    
-    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 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)
-        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
+        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)
         
-        # Select a significant range in the spectrum
-        spectrum = logPower[self.firstSelectedBin:self.firstSelectedBin+self.numberOfSelectedBins]
-            
-        # Scale the spectrum 
-        scaledSpectrum = self.scaleList(spectrum)
-        scaledSpectrum.append( final_rms)
-        return scaledSpectrum
+        return spec_y
+    
     
-
 class MPDSpectrumPage(Page):
 
     _Icons = {}
@@ -162,14 +73,15 @@ class MPDSpectrumPage(Page):
     _FootMsg = ["Nav","","","Back",""]
     _MyList = []
     _ListFont = fonts["veramono12"]
-
+    _SongFont = fonts["notosanscjk12"]
     _PIFI   =  None
     _FIFO   = None
     _Color  = pygame.Color(126,206,244)
     _GobjectIntervalId = -1
     _Queue = None
     _KeepReading = True
-
+    _ReadingThread = None
+    
     _BGpng = None
     _BGwidth = 320
     _BGheight = 200
@@ -182,10 +94,23 @@ class MPDSpectrumPage(Page):
     _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)
@@ -200,7 +125,8 @@ 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"]
@@ -221,19 +147,46 @@ class MPDSpectrumPage(Page):
         self._SheepBody.Adjust(0,0,self._SheepBodyW,self._SheepBodyH,0)
         """
         
-        self.Start()
-        self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
+        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
         
         try:
-            self._FIFO = open(self._PIFI._MPD_FIFO)
-            q = Queue()
-            self._Queue = q
+            self._FIFO = os.open(self._PIFI._MPD_FIFO, os.O_RDONLY | os.O_NONBLOCK)
             
             t = Thread(target=self.GetSpectrum)
             t.daemon = True # thread dies with the program
             t.start()
+            self._ReadingThread = t
             
         except IOError:
             print("open %s failed"%self._PIFI._MPD_FIFO)
@@ -242,61 +195,79 @@ class MPDSpectrumPage(Page):
 
 
     def GetSpectrum(self):
-        if self._FIFO == None:
-            print("self._FIFO none")
-            return
+        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()        
         
-        scaledSpectrum = self._PIFI.computeSpectrum(self._FIFO)
-        self._Queue.put( scaledSpectrum )
 
-        self._KeepReading = False
+    def Playing(self):
         
-        return ## Thread ends
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
 
-    def Playing(self):
-        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()
-            
-        else:
+
+    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)
             
-            return False
-        
-        return True
+            for i in range(0,pivot):
+                self._bby[i] = origs[i]
+                self._bby[ len(origs) -i -1 ] = origs[ len(origs) -i -1 ]
+
+            smooth_constant = 1.0/(2.0*pivot+1.0)
+            for i in range(pivot, len(origs)-pivot):
+                _sum = 0.0
+                for j in range(0,(2*pivot)+1):
+                    _sum += (smooth_constant * origs[i+j-pivot]) +j -pivot
+
+                self._bby[i] = _sum
+
+            if p < (passes - 1):
+                origs = self._bby[:]
     
     def OnLoadCb(self):
+        if self._Neighbor != None:
+            pass
+        
+        if self._KeepReading == False:
+            self._KeepReading = True
+        
         if self._FIFO == None:
             self.Start()
             
-        if self._Queue != None:
-            with self._Queue.mutex:
-                self._Queue.queue.clear()
-        
-        try:
-            if self._GobjectIntervalId != -1:
-                gobject.source_remove(self._GobjectIntervalId)
-        except:
-            pass
-        
-        self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
-
     
     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)
+            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()
@@ -308,25 +279,138 @@ class MPDSpectrumPage(Page):
             
         if event.key == CurKeys["Enter"]:
             pass
+
         
     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.get_nowait() ## last element is rms
-#            print("get_nowait: " , spects)
+            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
+
+
         except Empty:
             return
         else: # got line
-            if len(spects) == 0:
+            if len(self._vis_values) == 0:
                 return
-            w = self._Width / len( spects[0:-1] )
-            left_margin = (w-bw)/2
-            for i,v in enumerate(spects[0:-1]):
-                pygame.draw.rect(self._CanvasHWND,self._Color,(i*w+left_margin,self._Height-v,bw,v),0)
-        
+
+            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       
 
 
     

BIN
Menu/GameShell/Music Player/mpd_spectrum_page.pyc


BIN
Menu/GameShell/Music Player/music_lib_list_page.pyc


BIN
Menu/GameShell/Music Player/myvars.pyc


+ 1 - 1
Menu/GameShell/Music Player/pages.py

@@ -34,5 +34,5 @@ def InitListPage(main_screen):
 def InitSpectrumPage(main_screen):
     myvars.SpectrumPage = MPDSpectrumPage()
     myvars.SpectrumPage._Screen = main_screen
-    myvars.SpectrumPage._Name   = "Spectrum"
+    myvars.SpectrumPage._Name   = "GameShell RTA"
     myvars.SpectrumPage.Init()

BIN
Menu/GameShell/Music Player/pages.pyc


+ 7 - 0
Menu/GameShell/Music Player/play_list_page.py

@@ -71,6 +71,8 @@ class PlayListPage(Page):
     _BGheight = 70
 
     _Scrolled = 0
+
+    _CurSongName = ""
     
     def __init__(self):
         self._Icons = {}
@@ -126,6 +128,7 @@ 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
@@ -134,6 +137,8 @@ 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
@@ -244,6 +249,8 @@ 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()

BIN
Menu/GameShell/Music Player/play_list_page.pyc


BIN
Menu/GameShell/PowerOFF/__init__.pyc


BIN
Menu/GameShell/TinyCloud/__init__.pyc


BIN
skin/default/sys.py/gameshell/icons/buttonslayout.png


BIN
skin/default/sys.py/gameshell/icons/tape.png


+ 0 - 1
sys.py/.powerlevel

@@ -1 +0,0 @@
-balance_saving

BIN
sys.py/UI/Emulator/__init__.pyc


BIN
sys.py/UI/Emulator/fav_list_page.pyc


BIN
sys.py/UI/Emulator/list_item.pyc


BIN
sys.py/UI/Emulator/rom_list_page.pyc


BIN
sys.py/UI/Emulator/rom_so_confirm_page.pyc


BIN
sys.py/UI/__init__.pyc


BIN
sys.py/UI/above_all_patch.pyc


BIN
sys.py/UI/confirm_page.pyc


BIN
sys.py/UI/constants.pyc


+ 112 - 0
sys.py/UI/counter_screen.py

@@ -0,0 +1,112 @@
+# -*- 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()
+        
+        
+        

BIN
sys.py/UI/delete_confirm_page.pyc


BIN
sys.py/UI/download.pyc


BIN
sys.py/UI/download_process_page.pyc


+ 1 - 0
sys.py/UI/fonts.py

@@ -38,6 +38,7 @@ 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)

BIN
sys.py/UI/fonts.pyc


+ 17 - 1
sys.py/UI/foot_bar.py

@@ -131,8 +131,24 @@ 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):
-        for idx,x in enumerate(("nav","x","y","a","b")):
+        
+        barr = ["nav","x","y","a","b"]
+        if self.GetButtonsLayoutMode() == "snes":
+            barr = ["nav","y","x","b","a"]
+            
+        for idx,x in enumerate(barr):
             try:
                 self._Icons[x]._Label.SetText(texts[idx])
             except IndexError:

BIN
sys.py/UI/foot_bar.pyc


+ 38 - 0
sys.py/UI/full_screen.py

@@ -0,0 +1,38 @@
+# -*- 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
+    

BIN
sys.py/UI/icon_item.pyc


BIN
sys.py/UI/icon_pool.pyc


BIN
sys.py/UI/keys_def.pyc


+ 7 - 0
sys.py/UI/label.py

@@ -4,6 +4,8 @@ import pygame
 
 #import base64
 #from beeprint import pp
+from constants import Width,Height
+from util_funcs  import midRect
 
 class Label:
     _PosX=0
@@ -50,6 +52,11 @@ 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
         my_text = self._FontObj.render( self._Text,True,self._Color)

BIN
sys.py/UI/label.pyc


+ 41 - 9
sys.py/UI/main_screen.py

@@ -26,6 +26,7 @@ from untitled_icon import UntitledIcon
 from Emulator    import MyEmulator
 
 from skin_manager import SkinManager
+from counter_screen import CounterScreen
 
 class MessageBox(Label):
     _Parent = None
@@ -124,7 +125,7 @@ class MainScreen(object):
     _PosX  = 0
     _PosY  = TitleBar._BarHeight+1
     _Width = Width 
-    _Height = Height -FootBar._BarHeight -TitleBar._BarHeight-1
+    _Height = Height -FootBar._BarHeight -TitleBar._BarHeight
     _MyPageStack = None
     _CurrentPage = None # pointer to the current displaying Page Class
     _CanvasHWND  = None
@@ -135,7 +136,9 @@ class MainScreen(object):
     _MsgBoxFont  = fonts["veramono20"]
     _IconFont    = fonts["varela15"]
     _SkinManager = None
-    
+
+    _Closed      = False
+    _CounterScreen = None
     
     def __init__(self):
         self._Pages = []
@@ -149,6 +152,12 @@ 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)
@@ -341,6 +350,8 @@ 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()
@@ -355,6 +366,15 @@ 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):
@@ -388,7 +408,9 @@ class MainScreen(object):
                     iconitem = IconItem()
                     iconitem._CmdPath = ""
                     iconitem.AddLabel(i2,self._IconFont)
-                    if FileExists( SkinMap(_dir+"/"+i2+".png") ):
+                    if FileExists( _dir+"/"+i+"/"+i2+".png"): ### 20_Prog/Prog.png , cut 20_ 
+                        iconitem._ImageName = _dir+"/"+i+"/"+i2+".png"
+                    elif FileExists( SkinMap(_dir+"/"+i2+".png") ):
                         iconitem._ImageName = SkinMap(_dir+"/"+i2+".png")
                     else:
                         untitled = UntitledIcon()
@@ -447,7 +469,12 @@ 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()
@@ -461,7 +488,7 @@ class MainScreen(object):
                     
                     #cmd      =  ReadTheFileContent(_dir+"/"+i)
                     iconitem = IconItem()
-                    iconitem._CmdPath = _dir+"/"+i
+                    iconitem._CmdPath = os.path.realpath(_dir+"/"+i)
                     MakeExecutable(iconitem._CmdPath)
                     iconitem._MyType  = ICON_TYPES["EXE"]
                     if FileExists( SkinMap( _dir+"/"+ReplaceSuffix(i2,"png"))):
@@ -490,7 +517,6 @@ 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):
@@ -510,14 +536,17 @@ class MainScreen(object):
             self.EasingAllPageRight()
             #self.SwapAndShow()
         """
+        
         if event.key == pygame.K_t:
             self.DrawRun()
             self.SwapAndShow()
         
+        """
         if event.key == CurKeys["Space"]:
-            self.Draw()
-            self.SwapAndShow()
-            
+            self._CounterScreen.Draw()
+            self._CounterScreen.SwapAndShow()
+            self._CounterScreen.StartCounter()
+        """ 
         ## leave rest to Pages
         current_page_key_down_cb = getattr(self._CurrentPage,"KeyDown",None)
         if current_page_key_down_cb != None:
@@ -530,6 +559,9 @@ 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))

BIN
sys.py/UI/main_screen.pyc


BIN
sys.py/UI/multi_icon_item.pyc


BIN
sys.py/UI/multilabel.pyc


BIN
sys.py/UI/page.pyc


BIN
sys.py/UI/scroller.pyc


BIN
sys.py/UI/simple_name_space.pyc


BIN
sys.py/UI/skin_manager.pyc


BIN
sys.py/UI/slider.pyc


+ 9 - 6
sys.py/UI/title_bar.py

@@ -59,14 +59,13 @@ class TitleBar:
             self.SyncSoundVolume()
             self.UpdateWifiStrength()
             SwapAndShow()
-        else:
+#            print("TitleBar Gobjectroundrobin")
+        elif self._InLowBackLight >= 0:
             self._InLowBackLight+=1
-
             if self._InLowBackLight > 10:
                 self.CheckBatteryStat()
                 self.SyncSoundVolume()
                 self.UpdateWifiStrength()
-                SwapAndShow()
                 self._InLowBackLight = 0
         
         return True
@@ -96,8 +95,12 @@ class TitleBar:
         return ge
 
     def SyncSoundVolume(self):
-        m = alsaaudio.Mixer()
-        vol = m.getvolume()[0]
+	try:
+	        m = alsaaudio.Mixer()
+	        vol = m.getvolume()[0]	
+	except Exception,e:
+		print(str(e))
+	        vol = 0
 
         snd_segs = [ [0,10],[10,30],[30,70],[70,100] ]
 
@@ -123,7 +126,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:

BIN
sys.py/UI/title_bar.pyc


BIN
sys.py/UI/untitled_icon.pyc


BIN
sys.py/UI/util_funcs.pyc


+ 3 - 2
sys.py/config.py

@@ -12,15 +12,16 @@ MPD_socket = "/tmp/mpd.socket"
 
 UPDATE_URL="https://raw.githubusercontent.com/clockworkpi/CPI/master/launcher_ver.json"
 
-VERSION="stable 1.0"
+VERSION="stable 1.2"
 
 SKIN="default"
 
 ## three timer values in seconds: dim screen, close screen,PowerOff
 ## zero means no action
 PowerLevels = {}
-PowerLevels["supersaving"] = [10,30,100]
+PowerLevels["supersaving"] = [10,30,120]
 PowerLevels["powersaving"] = [40,120,300]
+PowerLevels["server"]      = [40,120,0]
 PowerLevels["balance_saving"] = [40,0,0]
 
 PowerLevel = "balance_saving"

BIN
sys.py/config.pyc


BIN
sys.py/libs/DBUS/__init__.pyc


BIN
sys.py/libs/MPD/__init__.pyc


BIN
sys.py/libs/MPD/poller.pyc


BIN
sys.py/libs/__init__.pyc


BIN
sys.py/libs/easing.pyc


BIN
sys.py/libs/roundrects/__init__.pyc


BIN
sys.py/libs/roundrects/roundrects.pyc


+ 117 - 28
sys.py/run.py

@@ -3,6 +3,7 @@
 import dbus
 import dbus.service
 import sys
+import commands
 from wicd import misc 
 ##misc.to_bool
 ##misc.misc.noneToString
@@ -63,6 +64,9 @@ passout_time_stage = 0
 
 last_brt = -1
 
+gobject_flash_led1 = -1
+gobject_flash_led1_counter = 0
+
 def gobject_loop():
     """
     here to receive dbus signal 
@@ -73,12 +77,57 @@ def gobject_loop():
         gobject_main_loop.quit()
         exit(-1)
 
+def GobjectFlashLed1(main_screen):
+    global gobject_flash_led1_counter
+    gobject_flash_led1_counter+=1
 
+    if gobject_flash_led1_counter == 2:
+        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 == 4:
+        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 == 10:
+        gobject_flash_led1_counter = 0
+    
+    return True
+
+    
 def RestoreLastBackLightBrightness(main_screen):
-    global last_brt,passout_time_stage
+    global last_brt,passout_time_stage,gobject_flash_led1
+
+    passout_time_stage = 0
+    main_screen._TitleBar._InLowBackLight = -1
+    main_screen._Closed = False
+    
+    if gobject_flash_led1 != -1:
+        gobject.source_remove(gobject_flash_led1)
+        gobject_flash_led1 = -1
+
     
     if last_brt == -1:
-        return
+        return True
 
     try:
         f = open(config.BackLight,"r+")
@@ -96,15 +145,32 @@ def RestoreLastBackLightBrightness(main_screen):
                 f.truncate()
                 f.close()
                 last_brt = -1
-                main_screen._TitleBar._InLowBackLight = -1
-                passout_time_stage = 0
-            else:
-                
+            else:                
                 f.close()
-                return
+
+    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
 
 def InspectionTeam(main_screen):
-    global everytime_keydown,last_brt,passout_time_stage
+    global everytime_keydown,last_brt,passout_time_stage,gobject_flash_led1
     
     cur_time = time.time()
     time_1 = config.PowerLevels[config.PowerLevel][0]
@@ -124,7 +190,8 @@ def InspectionTeam(main_screen):
                 content = [x.strip() for x in content]
                 brt=int(content[0])
                 if brt > 0:
-                    last_brt = brt ## remember brt for restore
+                    if last_brt < 0:
+                        last_brt = brt ## remember brt for restore
 
                     brt = 1
                     f.seek(0)
@@ -132,7 +199,7 @@ def InspectionTeam(main_screen):
                     f.truncate()
                     f.close()
 
-                    main_screen._TitleBar._InLowBackLight = 0
+        main_screen._TitleBar._InLowBackLight = 0
 
         if time_2 != 0:
             passout_time_stage = 1 # next 
@@ -140,7 +207,7 @@ def InspectionTeam(main_screen):
     
     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:
@@ -152,21 +219,40 @@ def InspectionTeam(main_screen):
                 f.write(str(brt))
                 f.truncate()
                 f.close()
-                main_screen._TitleBar._InLowBackLight = 0
 
+        
+        main_screen._TitleBar._InLowBackLight = 0
+        main_screen._Closed = True
         if time_3 != 0:
-            passout_time_stage = 2 # next 
+            passout_time_stage = 2 # next
+
+        gobject_flash_led1 = gobject.timeout_add(200,GobjectFlashLed1,main_screen)
+        
         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))
+        print("Power Off counting down")
         
-        passout_time_stage = 0
-        everytime_keydown = cur_time
+        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
 
@@ -185,8 +271,7 @@ 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)
@@ -199,7 +284,8 @@ def event_process(event,main_screen):
                 pygame.quit()
                 gobject_main_loop.quit()
                 os.chdir( GetExePath())
-                exec_app_cmd = event.message
+                exec_app_cmd = "cd "+os.path.dirname(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)
@@ -216,7 +302,8 @@ def event_process(event,main_screen):
                 pygame.quit()
                 gobject_main_loop.quit()
                 os.chdir( GetExePath())
-                exec_app_cmd = event.message
+                exec_app_cmd = "cd "+os.path.dirname(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)
@@ -226,7 +313,6 @@ def event_process(event,main_screen):
 
         if event.type == POWEROPT:
             everytime_keydown = time.time()
-            RestoreLastBackLightBrightness(main_screen)
             
             return
         if event.type == pygame.KEYUP:
@@ -235,7 +321,8 @@ def event_process(event,main_screen):
             return
         if event.type == pygame.KEYDOWN:
             everytime_keydown = time.time()
-            RestoreLastBackLightBrightness(main_screen)
+            if RestoreLastBackLightBrightness(main_screen) == False:
+                return
             ###########################################################
             if event.key == pygame.K_q:
                 on_exit_cb = getattr(main_screen,"OnExitCb",None)
@@ -273,6 +360,7 @@ 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:
@@ -368,6 +456,7 @@ def big_loop():
     main_screen.ReadTheDirIntoPages("../Menu",0,None)
     main_screen.FartherPages()
 
+    
     title_bar._SkinManager = main_screen._SkinManager
     foot_bar._SkinManager  = main_screen._SkinManager
     
@@ -385,7 +474,7 @@ def big_loop():
     gobject.timeout_add(3000,title_bar.GObjectRoundRobin)
 
 
-    socket_thread(main_screen)
+#    socket_thread(main_screen)
     
     gobject_loop()
     
@@ -402,7 +491,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])
+    pygame.event.set_allowed([pygame.KEYDOWN,pygame.KEYUP,GMEVT,RUNEVT,RUNSYS,POWEROPT])
     
     pygame.key.set_repeat(DT+DT*6+DT/2, DT+DT*3+DT/2)