Add files via upload

Menu/GameShell/Music Player/__init__.py

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

Menu/GameShell/Music Player/icons/preload.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*- 
+
+import pygame
+from pygame.locals import *
+from sys import exit
+import os
+import sys
+
+from beeprint import pp
+
+ICONS_PRELOAD={}
+
+
+def load_icons():
+    basepath = os.path.dirname(os.path.realpath(__file__))
+
+    files = os.listdir(basepath)
+    for i in files:
+        if os.path.isfile(basepath+"/"+i) and i.endswith(".png"):
+            keyname = i.split(".")[0]
+            ICONS_PRELOAD[keyname] = pygame.image.load(basepath+"/"+i).convert_alpha()

Menu/GameShell/Music Player/list_item.py

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

Menu/GameShell/Music Player/mpd_spectrum_page.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*- 
+
+import time
+import pygame
+
+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
+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 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
+    _SAMPLING_RATE = 44100
+    _FIRST_SELECTED_BIN = 5
+    _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
+        
+        # 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
+        
+    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 = {}
+    _Selector=None
+    _FootMsg = ["Nav","","","Back","Pause"]
+    _MyList = []
+    _ListFont = fonts["veramono12"]
+
+    _PIFI   =  None
+    _FiFo   = None
+    _Color  = pygame.Color(126,206,244)
+    _GobjectIntervalId = -1
+    _Queue = None
+    _KeepReading = True
+    
+    def __init__(self):
+        Page.__init__(self)
+        self._Icons = {}
+        self._CanvasHWND = None
+        self._MyList = []
+        self._PIFI = PIFI()
+            
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        self.Start()
+
+        self._GobjectIntervalId = gobject.timeout_add(50,self.Playing)
+        
+    def Start(self):
+        
+        try:
+            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()
+            
+        except IOError:
+            print("open %s failed"%self._PIFI._MPD_FIFO)
+            self._FIFO = None
+            return
+
+
+    def GetSpectrum(self):
+        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):
+        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:
+            
+            return False
+        
+        return True
+    
+    def OnLoadCb(self):
+
+        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"]:
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        if event.key == CurKeys["Start"]:
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Enter"]:
+            pass
+
+        
+    def Draw(self):
+        self.ClearCanvas()
+
+        bw = 10
+        spects = None
+        try:
+            spects = self._Queue.get_nowait()
+#            print("get_nowait: " , spects)
+        except Empty:
+            return
+        else: # got line
+            if len(spects) == 0:
+                return
+            w = self._Width / len(spects)
+            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/music_lib_list_page.py

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

Menu/GameShell/Music Player/myvars.py

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

Menu/GameShell/Music Player/pages.py

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

Menu/GameShell/Music Player/play_list_page.py

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*- 
+import os
+import pygame
+import gobject
+
+from libs.roundrects import aa_round_rect
+
+## local UI import
+from UI.constants import Width,Height,ICON_TYPES
+from UI.page   import Page,PageSelector
+from UI.icon_item import IconItem
+from UI.label  import Label
+from UI.fonts  import fonts
+from UI.util_funcs import midRect
+from UI.keys_def   import CurKeys
+from UI.icon_pool  import MyIconPool
+
+from UI.scroller   import ListScroller
+
+from list_item  import ListItem
+
+import myvars
+
+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)-1):
+            idx = len(self._Parent._MyList)
+            if idx > 0:
+                idx -=1
+            elif idx == 0: #Nothing
+                return
+
+        x = self._Parent._MyList[idx]._PosX+2
+        y = self._Parent._MyList[idx]._PosY+1
+        h = self._Parent._MyList[idx]._Height -3
+        
+        self._PosX = x
+        self._PosY = y
+        self._Height = h
+
+        aa_round_rect(self._Parent._CanvasHWND,  
+                      (x,y,self._Width-4,h),self._BackgroundColor,4,0,self._BackgroundColor)
+        
+
+
+class PlayListPage(Page):
+
+    _Icons = {}
+    _Selector=None
+    _FootMsg = ["Nav","","Remove","Back","Play/Pause"]
+    _MyList = []
+    _ListFont = fonts["notosanscjk15"]
+
+    _Scroller = None
+    
+    _BGpng  = None
+    _BGwidth = 75
+    _BGheight = 70
+    
+    def __init__(self):
+        self._Icons = {}
+        Page.__init__(self)
+        self._CanvasHWND = None
+        self._MyList = []
+
+    def SyncList(self):
+        self._MyList = []
+        start_x  = 0
+        start_y  = 0
+        if myvars.Poller == None:
+            return
+        
+        play_list = myvars.Poller.playlist()
+        for i,v in enumerate(play_list):
+            li = ListItem()
+            li._Parent = self
+            li._PosX   = start_x
+            li._PosY   = start_y + i*ListItem._Height
+            li._Width  = Width
+            li._Fonts["normal"] = self._ListFont
+
+            if "title" in v:
+                li.Init( v["title"])
+                if "file" in v:
+                    li._Path = v["file"]
+                
+            elif "file" in v:
+                li.Init(os.path.basename(v["file"]))
+                li._Path = v["file"] 
+            else:
+                li.Init("NoName")
+
+            li._Labels["Text"]._PosX = 7
+            self._MyList.append(li)
+
+            
+        self.SyncPlaying()
+
+    def GObjectInterval(self): ## 250 ms 
+        if self._Screen.CurPage() == self:
+            self.SyncPlaying()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+
+        return True
+    
+    def SyncPlaying(self):
+        if myvars.Poller == None:
+            return
+        
+        current_song = myvars.Poller.poll()
+        
+        for i ,v in enumerate(self._MyList):
+            self._MyList[i]._Playing = False
+            self._MyList[i]._PlayingProcess = 0
+            
+        if current_song != None:
+            if "song" in current_song:
+                posid = int(current_song["song"])
+                if posid < len(self._MyList): # out of index
+                    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:
+                        times_ = current_song["time"].split(":")
+                        if len(times_)> 1:
+                            cur = float(times_[0])
+                            end = float(times_[1])
+                            pros = int((cur/end)*100.0)
+                            self._MyList[posid]._PlayingProcess = pros
+                        
+                
+    def InPlayList(self,path):
+        for i,v in enumerate(self._MyList):
+            if v._Path == path:
+                return True
+    
+    def Init(self):
+        self._PosX = self._Index * self._Screen._Width
+        self._Width = self._Screen._Width
+        self._Height = self._Screen._Height
+
+        self._CanvasHWND = self._Screen._CanvasHWND
+
+        ps = ListPageSelector()
+        ps._Parent = self
+        self._Ps = ps
+        self._PsIndex = 0
+
+        self.SyncList()
+        gobject.timeout_add(850,self.GObjectInterval)
+
+        self._BGpng = IconItem()
+        self._BGpng._ImgSurf = MyIconPool._Icons["heart"]
+        self._BGpng._MyType = ICON_TYPES["STAT"]
+        self._BGpng._Parent = self
+        self._BGpng.AddLabel("my favourites", fonts["varela18"])
+        self._BGpng.SetLableColor(pygame.Color(204,204,204))
+        self._BGpng.Adjust(0,0,self._BGwidth,self._BGheight,0)
+
+        self._Scroller = ListScroller()
+        self._Scroller._Parent = self
+        self._Scroller._PosX = self._Width - 10
+        self._Scroller._PosY = 2
+        self._Scroller.Init()
+        
+        
+    def ScrollUp(self):
+        if len(self._MyList) == 0:
+            return
+        self._PsIndex -= 1
+        if self._PsIndex < 0:
+            self._PsIndex = 0
+        cur_li = self._MyList[self._PsIndex]
+        if cur_li._PosY < 0:
+            for i in range(0, len(self._MyList)):
+                self._MyList[i]._PosY += self._MyList[i]._Height
+        
+
+    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):
+        if len(self._MyList) == 0:
+            return
+        
+        cur_li = self._MyList[self._PsIndex]
+        play_pos_id = myvars.Poller.play(self._PsIndex)
+
+        self.SyncPlaying()
+
+        self._Screen.Draw()
+        self._Screen.SwapAndShow()
+        
+    def OnReturnBackCb(self):
+        self.SyncList()
+    
+    def KeyDown(self,event):
+        if event.key == CurKeys["A"] or event.key == CurKeys["Menu"]:
+            if myvars.Poller != None:
+                myvars.Poller.stop()
+            
+            self.ReturnToUpLevelPage()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Up"]:
+            self.ScrollUp()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        if event.key == CurKeys["Down"]:
+            self.ScrollDown()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Right"]:#add
+            self._Screen.PushCurPage()
+            self._Screen.SetCurPage(myvars.MusicLibListPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+        
+        if event.key == CurKeys["Y"]:# del selected songs
+            myvars.Poller.delete(self._PsIndex)
+            self.SyncList()
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+        if event.key == CurKeys["Enter"]:
+            self.Click()
+
+        if event.key == CurKeys["Start"]: # start spectrum
+            self._Screen.PushPage(myvars.SpectrumPage)
+            self._Screen.Draw()
+            self._Screen.SwapAndShow()
+            
+    def Draw(self):
+        self.ClearCanvas()
+
+        if len(self._MyList) == 0:
+            self._BGpng.NewCoord(self._Width/2,self._Height/2)
+            self._BGpng.Draw()
+            return
+        else:
+            if len(self._MyList) * ListItem._Height > self._Height:
+                self._Ps._Width = self._Width - 11
+                self._Ps.Draw()
+                for i in self._MyList:
+                    i.Draw()
+                self._Scroller.UpdateSize( len(self._MyList)*ListItem._Height, self._PsIndex*ListItem._Height)
+                self._Scroller.Draw()
+            else:
+                self._Ps._Width = self._Width
+                self._Ps.Draw()
+                for i in self._MyList:
+                    i.Draw()
+