← Back to branch summary

~andrebask/cometsound/cometsound

« back to all changes in this revision

Viewing changes to src/Model.py

  • Committer: andrebask
  • Date: 2012-06-27 19:20:51 UTC
  • Revision ID: git-v1:a9346d331f04adcb4cbc1b3913e8ca1ffc30e273
Fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/Model.py
1
1
##
2
 
#    Project: CometSound - A music player written in Python 
 
2
#    Project: CometSound - A music player written in Python
3
3
#    Author: Andrea Bernardini <andrebask@gmail.com>
4
4
#    Copyright: 2010-2012 Andrea Bernardini
5
5
#    License: GPL-2+
38
38
    """Data structure that represents the file system tree"""
39
39
    audioFileList = list()
40
40
    count = 0
41
 
        
 
41
 
42
42
    def __init__(self, directoryList, progressBar = None, group = False):
43
43
        self.progressBar = progressBar
44
44
        self.numOfFiles = 0
 
45
        self.threadsUsed = 0
45
46
        self.changed = False
46
47
        self.MTlist = []
47
48
        settings = readSettings()
51
52
        try:
52
53
            self.lastUpdate = os.path.getmtime(self.cachefname)
53
54
        except:
54
 
            self.lastUpdate = 0    
 
55
            self.lastUpdate = 0
55
56
        self.setDir(directoryList, group)
56
 
     
 
57
 
57
58
    def getAudioFileList(self):
58
 
        return self.audioFileList   
59
 
                
 
59
        return self.audioFileList
 
60
 
60
61
    def getDir(self):
61
62
        return self.directory
62
 
    
 
63
 
63
64
    def setDir(self, directoryList, group = False):
64
65
        """Sets the directory to scan, calculates the number of files,
65
66
           and builds the file system tree (using __searchFiles method)"""
66
 
        self.directory = directoryList[0]  
67
 
        if self.directory == '' and not group:  
68
 
            try: 
 
67
        self.directory = directoryList[0]
 
68
        if self.directory == '' and not group:
 
69
            try:
69
70
                FILE = open(self.cachefname, 'rb')
70
71
                self.audioFileList = cerealizer.load(FILE)
71
72
                FILE.close()
75
76
                    raise Exception
76
77
            except:
77
78
                self.directory = ''
78
 
                #print sys.exc_info()  
79
 
            self.playlist = None  
 
79
                #print sys.exc_info()
 
80
            self.playlist = None
80
81
            return
81
82
        else:
82
83
            try:
93
94
                    cfname, title, album, arist = tv[0], tv[2], tv[4], tv[3]
94
95
                    self.playlist.append((cfname, title, album, arist))
95
96
            if isAudio(directoryList[0]):
96
 
                index = self.directory.rfind("/")    
 
97
                index = self.directory.rfind("/")
97
98
                if self.numOfFiles < 200:
98
99
                    self.directory = self.directory[:index]
99
100
                else:
103
104
            self.__waitSearch(self.threadsUsed)
104
105
            self.audioFileList = self.MTlist
105
106
        else:
106
 
            
 
107
 
107
108
            for dir in directoryList:
108
109
                self.numOfFiles += sum((len(f) for _, _, f in os.walk(dir)))
109
 
            self.fraction = float(1) / self.numOfFiles               
110
 
            
 
110
            self.fraction = float(1) / self.numOfFiles
 
111
 
111
112
            groupdir = directoryList[0][:directoryList[0].rfind("/")]
112
113
            self.audioFileList = [groupdir, 'Group']
113
114
            for folder in directoryList:
114
115
                self.MTlist = []
115
116
                dirname = folder[folder.rfind("/") + 1:]
116
117
                self.numOfFiles = sum((len(f) for _, _, f in os.walk(folder)))
117
 
                self.__searchFilesMThreaded(folder)   
118
 
                self.__waitSearch(1)            
119
 
                self.audioFileList.append([dirname] + self.MTlist)            
120
 
                
 
118
                self.__searchFilesMThreaded(folder)
 
119
                self.__waitSearch(1)
 
120
                self.audioFileList.append([dirname] + self.MTlist)
 
121
 
121
122
    def __searchFilesMThreaded(self, directory, threadsNum = 1):
122
123
        """Recursively scans the file system to find audio files and add them to the tree"""
123
124
        #print directory
128
129
            return
129
130
        Global.scanCount = 0
130
131
        self.threadsUsed = 0
131
 
        slot = len(fileList)/threadsNum        
 
132
        slot = len(fileList)/threadsNum
132
133
        for i in range(1,threadsNum):
133
134
            flist = fileList[ (i-1) * slot : i * slot ]
134
135
            if len(flist) > 0:
135
136
                gobject.idle_add(self.__searchFilesList, directory, flist)
136
 
                self.threadsUsed += 1 
 
137
                self.threadsUsed += 1
137
138
        flist = fileList[ slot * (threadsNum-1) : ]
138
139
        if len(flist) > 0:
139
140
            gobject.idle_add(self.__searchFilesList, directory, flist)
140
141
            self.threadsUsed += 1
141
 
        
 
142
 
142
143
    def __searchFilesList(self, directory, fileList):
143
144
        """Recursively scans the file system to find audio files and add them to the tree"""
144
145
        #print directory
152
153
                    continue
153
154
                #print 'processing ' + fileName
154
155
                if isAudio(fileName):
155
 
                    self.MTlist.append(AudioFile(directory, fileName).getAudioFileInfos())   
 
156
                    self.MTlist.append(AudioFile(directory, fileName).getAudioFileInfos())
156
157
                elif stat.S_ISDIR(filestat.st_mode):
157
158
                    #print filestat.st_mtime
158
159
                    l = self.__searchFiles(os.path.join(directory, fileName))
183
184
                    continue
184
185
                #print 'processing ' + fileName
185
186
                if isAudio(fileName):
186
 
                    list.append(AudioFile(directory, fileName).getAudioFileInfos())   
 
187
                    list.append(AudioFile(directory, fileName).getAudioFileInfos())
187
188
                elif stat.S_ISDIR(filestat.st_mode):
188
189
                    #print filestat.st_mtime
189
190
                    l = self.__searchFiles(os.path.join(directory, fileName))
193
194
            Global.PBcount += 1
194
195
            gtkTrick()
195
196
 
196
 
        return list  
197
 
    
 
197
        return list
 
198
 
198
199
    def __waitSearch(self, threadsNum):
199
200
        while Global.scanCount == 0:
200
201
            gtkTrick()
201
202
        while Global.scanCount < self.threadsUsed:
202
203
            time.sleep(0.1)
203
204
            gtkTrick()
204
 
              
 
205
 
205
206
    def __updateProgressBar(self, par1 = None, par2 = None):
206
207
        """Updates the progress bar that shows the current status of the scan"""
207
208
        if self.progressBar != None:
208
209
            self.progressBar.set_fraction(self.__truncate(Global.PBcount * self.fraction))
209
210
            #self.progressBar.set_text(str(self.count * self.fraction)[2:4] + "%")
210
 
            
 
211
 
211
212
    def __updateProgressBarThreaded(self):
212
213
        """Updates the progress bar that shows the current status of the scan"""
213
214
        while Global.PBcount < self.numOfFiles:
214
215
            #print self.__truncate(Global.PBcount * self.fraction)
215
216
            gobject.idle_add(self.__updateProgressBar)
216
217
            time.sleep(.01)
217
 
                
 
218
 
218
219
    def __truncate(self, i):
219
220
        if i < 1: return i
220
221
        else: return 1.0
221
 
        
 
222
 
222
223
    def updateModel(self):
223
224
        """Searches in the file system recently changed or added files to update the model"""
224
225
        self.changed = False
227
228
        gobject.idle_add(self.__updateModel, self.getAudioFileList(), self.directory)
228
229
        self.__waitSearch(1)
229
230
        self.lastUpdate = time.time()
230
 
        
 
231
 
231
232
    def __updateModel(self, fileTree, dir):
232
 
        
 
233
 
233
234
        Global.scanCount = 0
234
235
        if not os.path.exists(dir):
235
236
            return
272
273
                fileTree.append(AudioFile(dir, element).getAudioFileInfos())
273
274
                self.changed = True
274
275
        Global.scanCount += 1
275
 
     
 
276