← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/tuxguitar/oneiric

« back to all changes in this revision

Viewing changes to src/org/herac/tuxguitar/song/managers/SongTrackManager.java

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2008-06-19 00:30:30 UTC
  • mto: (5.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20080619003030-h719szrhsngou7c6
Tags: upstream-1.0
Import upstream version 1.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/song/managers/SongTrackManager.java
1
 
package org.herac.tuxguitar.song.managers;
2
 
 
3
 
import java.util.ArrayList;
4
 
import java.util.Iterator;
5
 
import java.util.List;
6
 
 
7
 
import org.herac.tuxguitar.song.models.Measure;
8
 
import org.herac.tuxguitar.song.models.MeasureHeader;
9
 
import org.herac.tuxguitar.song.models.RGBColor;
10
 
import org.herac.tuxguitar.song.models.SongChannel;
11
 
import org.herac.tuxguitar.song.models.SongTrack;
12
 
 
13
 
public class SongTrackManager {
14
 
        private SongManager songManager;
15
 
        
16
 
        public SongTrackManager(SongManager songManager){
17
 
                this.songManager = songManager;
18
 
        }
19
 
        
20
 
        
21
 
        
22
 
    public int countMeasures(SongTrack track){
23
 
        return (track.getMeasures().size());
24
 
    }
25
 
        
26
 
           
27
 
    public Measure getFirstMeasure(SongTrack track){
28
 
        Measure firstMeasure = null;    
29
 
        for(int i = 0;i < track.getMeasures().size();i++){
30
 
            Measure currMeasure = (Measure)track.getMeasures().get(i);
31
 
            if(firstMeasure == null || (currMeasure.getStart() < firstMeasure.getStart())){
32
 
                firstMeasure = currMeasure;
33
 
            }
34
 
        }        
35
 
        return firstMeasure;
36
 
    }     
37
 
 
38
 
    public Measure getLastMeasure(SongTrack track){
39
 
        int lastIndex = track.getMeasures().size() - 1; 
40
 
        return (Measure)track.getMeasures().get(lastIndex);
41
 
    }      
42
 
    
43
 
    public Measure getPrevMeasure(SongTrack track,Measure measure){
44
 
        int prevIndex = measure.getNumber() - 1; 
45
 
        if(prevIndex > 0){
46
 
            return (Measure)track.getMeasures().get(prevIndex - 1);
47
 
        }
48
 
        return null;
49
 
    }      
50
 
    
51
 
    public Measure getNextMeasure(SongTrack track,Measure measure){
52
 
        int nextIndex = measure.getNumber(); 
53
 
        if(nextIndex < track.getMeasures().size()){
54
 
            return (Measure)track.getMeasures().get(nextIndex);
55
 
        }
56
 
        return null;
57
 
    }       
58
 
  
59
 
    public Measure getMeasureAt(SongTrack track,long start){
60
 
        Iterator it = track.getMeasures().iterator();
61
 
        while(it.hasNext()){
62
 
            Measure measure = (Measure)it.next();  
63
 
            long measureStart = measure.getStart();
64
 
            long measureLength = measure.getLength();
65
 
            if(start >= measureStart && start < measureStart + measureLength){
66
 
                return measure;
67
 
            }
68
 
        }     
69
 
        return null;
70
 
    }           
71
 
    
72
 
    public Measure getMeasure(SongTrack track,int number){
73
 
        for (int i = 0; i < track.getMeasures().size(); i++) {
74
 
            Measure measure = (Measure) track.getMeasures().get(i);            
75
 
            if(measure.getNumber() == number){
76
 
                return measure;
77
 
            }
78
 
        }     
79
 
        return null;
80
 
    }   
81
 
    
82
 
    /**
83
 
     * Retorna Todos los desde Start hasta el final del compas
84
 
     */
85
 
    public List getMeasuresBeforeEnd(SongTrack track,long fromStart) {
86
 
        List measures = new ArrayList();        
87
 
        Iterator it = track.getMeasures().iterator();
88
 
        while(it.hasNext()){           
89
 
            Measure currMeasure = (Measure)it.next();
90
 
            if (currMeasure.getStart() >= fromStart) {
91
 
                measures.add(currMeasure);
92
 
            }
93
 
        }
94
 
        return measures;
95
 
    }         
96
 
    
97
 
    /**
98
 
     * Retorna Todos los desde Start hasta el final del compas
99
 
     */
100
 
    public List getMeasuresBetween(SongTrack track,long p1,long p2) {
101
 
        List measures = new ArrayList();        
102
 
        Iterator it = track.getMeasures().iterator();
103
 
        while(it.hasNext()){           
104
 
            Measure currMeasure = (Measure)it.next();
105
 
            long start = currMeasure.getStart();
106
 
            if (start >= p1 && start <= p2) {
107
 
                measures.add(currMeasure);
108
 
            }
109
 
        }
110
 
        return measures;
111
 
    }          
112
 
    
113
 
    public void addNewMeasureBeforeEnd(SongTrack track,MeasureHeader header){        
114
 
        addNewMeasureAfter(track,header,getLastMeasure(track));
115
 
    }    
116
 
    
117
 
 
118
 
    
119
 
 
120
 
    /**
121
 
     * Agrega un Compas
122
 
     */
123
 
    public void addNewMeasureAfter(SongTrack track,MeasureHeader header,Measure measure){      
124
 
        int clef = measure.getClef();
125
 
        int keySignature = measure.getKeySignature();
126
 
        
127
 
        addMeasure(track,new Measure(header, new ArrayList(), new ArrayList(),clef,keySignature));
128
 
    }
129
 
 
130
 
    public void addNewMeasure(SongTrack track,MeasureHeader header){
131
 
        Measure previous = getMeasure(track, (header.getNumber() == 1)?(header.getNumber()+1):header.getNumber()-1); 
132
 
        
133
 
        int clef = previous.getClef();
134
 
        int keySignature = previous.getKeySignature();        
135
 
        addMeasure(track,header.getNumber() - 1,new Measure(header, new ArrayList(), new ArrayList(),clef,keySignature));
136
 
    }
137
 
    
138
 
    public List copyMeasures(SongTrack track,long p1,long p2){
139
 
        List measures = new ArrayList();
140
 
        
141
 
        Iterator it = getMeasuresBetween(track,p1,p2).iterator();
142
 
        while(it.hasNext()){
143
 
            Measure measure = (Measure)it.next();
144
 
            measures.add(measure);
145
 
        }
146
 
        return measures;
147
 
    }
148
 
    
149
 
    /**
150
 
     * Agrega un Compas
151
 
     */
152
 
    public void insertMeasures(SongTrack track,List measures,int fromNumber){
153
 
        long start = -1;
154
 
        long end = 0;        
155
 
        if(!measures.isEmpty()){
156
 
            start = ((Measure)measures.get(0)).getStart(); 
157
 
            end = ((Measure)measures.get(measures.size() - 1)).getStart() + ((Measure)measures.get(measures.size() - 1)).getLength();
158
 
 
159
 
            Iterator it = measures.iterator();
160
 
            while(it.hasNext()){
161
 
                Measure measure = (Measure)it.next();
162
 
                addMeasure(track,(measure.getNumber() - 1),measure);
163
 
                fromNumber ++;
164
 
            }        
165
 
        }
166
 
    }    
167
 
        
168
 
    
169
 
    /**
170
 
     * Agrega un Compas
171
 
     */
172
 
    public void addMeasure(SongTrack track,Measure measure){
173
 
        track.getMeasures().add(measure);
174
 
    }    
175
 
    
176
 
    /**
177
 
     * Agrega un Compas
178
 
     */
179
 
    public void addMeasure(SongTrack track,int index,Measure measure){
180
 
        track.getMeasures().add(index,measure);
181
 
    }        
182
 
 
183
 
    public void removeLastMeasure(SongTrack track){    
184
 
        removeMeasure(track,getLastMeasure(track));
185
 
    }
186
 
    
187
 
    public void removeMeasure(SongTrack track,long start){    
188
 
        removeMeasure(track,getMeasureAt(track,start));
189
 
    }
190
 
    
191
 
    public void removeMeasure(SongTrack track,Measure measure){        
192
 
        long start = measure.getStart();
193
 
        long length = measure.getLength();
194
 
    
195
 
        track.getMeasures().remove(measure.getNumber() - 1);  
196
 
    }    
197
 
    
198
 
    public Measure replaceMeasure(SongTrack track,Measure newMeasure){          
199
 
        Measure measure = getMeasureAt(track,newMeasure.getStart());
200
 
        measure.makeEqual(newMeasure);          
201
 
 
202
 
        return measure;
203
 
    }
204
 
    
205
 
    /**
206
 
     * Mueve el compas
207
 
     */    
208
 
    public void moveMeasure(SongTrack track,Measure measure,long theMove,int numberMove){                
209
 
        songManager.getMeasureManager().moveAllNotes(measure,theMove);
210
 
        songManager.getMeasureManager().moveAllSilences(measure,theMove);
211
 
    }
212
 
    
213
 
    public void changeKeySignature(SongTrack track,long start,int keySignature,boolean toEnd){
214
 
        changeKeySignature(track,getMeasureAt(track,start),keySignature,toEnd);
215
 
    }
216
 
    
217
 
    /**
218
 
     * Cambia el Key Signature
219
 
     */
220
 
    public void changeKeySignature(SongTrack track,Measure measure,int keySignature,boolean toEnd){        
221
 
        //asigno el nuevo Key
222
 
        measure.setKeySignature(keySignature);
223
 
        
224
 
        if(toEnd){
225
 
            List measures = getMeasuresBeforeEnd(track,measure.getStart() + 1);
226
 
            Iterator it = measures.iterator();
227
 
            while(it.hasNext()){
228
 
                Measure nextMeasure = (Measure)it.next();
229
 
                nextMeasure.setKeySignature(keySignature);
230
 
            }            
231
 
        }                
232
 
    }    
233
 
    
234
 
    
235
 
    public void changeClef(SongTrack track,long start,int clef,boolean toEnd){
236
 
        changeClef(track,getMeasureAt(track,start),clef,toEnd);
237
 
    }
238
 
    
239
 
    /**
240
 
     * Cambia el Clef
241
 
     */
242
 
    public void changeClef(SongTrack track,Measure measure,int clef,boolean toEnd){        
243
 
        //asigno el nuevo clef
244
 
        measure.setClef(clef);         
245
 
 
246
 
        if(toEnd){
247
 
            List measures = getMeasuresBeforeEnd(track,measure.getStart() + 1);
248
 
            Iterator it = measures.iterator();
249
 
            while(it.hasNext()){
250
 
                Measure nextMeasure = (Measure)it.next();
251
 
                nextMeasure.setClef(clef);  
252
 
            }            
253
 
        }        
254
 
     
255
 
    }        
256
 
 
257
 
    public void changeInfo(SongTrack track,String name,RGBColor color,int offset){         
258
 
        track.setName(name);
259
 
        track.setColor(color);
260
 
        track.setOffset(offset);
261
 
    }
262
 
    
263
 
    
264
 
    public void changeInstrumentStrings(SongTrack track,List strings){
265
 
        if(strings.size() < track.getStrings().size()){
266
 
            removeNotesAfterString(track,strings.size());            
267
 
        }                
268
 
        track.setStrings(strings);
269
 
    }
270
 
    
271
 
    public void removeNotesAfterString(SongTrack track,int string){
272
 
        Iterator it = track.getMeasures().iterator();
273
 
        while(it.hasNext()){
274
 
            Measure measure = (Measure)it.next();
275
 
            
276
 
            songManager.getMeasureManager().removeNotesAfterString(measure,string);
277
 
        }          
278
 
    }
279
 
    
280
 
    public void changeInstrument(SongTrack track,int instrument,boolean percusion){
281
 
        track.getChannel().setInstrument((short)instrument);
282
 
        if(percusion){
283
 
                track.getChannel().setChannel(SongChannel.DEFAULT_PERCUSION_CHANNEL);
284
 
                track.getChannel().setEffectChannel(SongChannel.DEFAULT_PERCUSION_CHANNEL);             
285
 
                track.setStrings(SongManager.createPercusionStrings(track.getStrings().size()));
286
 
        }else{
287
 
                if(track.getChannel().isPercusionChannel()){
288
 
                        SongChannel tempChannel = this.songManager.getFreeChannel((short)instrument,false);
289
 
                        track.getChannel().setChannel(tempChannel.getChannel());
290
 
                        track.getChannel().setEffectChannel(tempChannel.getEffectChannel()); 
291
 
                }
292
 
        }
293
 
        this.songManager.updateChannel(track.getChannel());
294
 
    }
295
 
 
296
 
    
297
 
    public void autoCompleteSilences(SongTrack track){
298
 
        Iterator it = track.getMeasures().iterator();
299
 
        while(it.hasNext()){
300
 
            Measure measure = (Measure)it.next();            
301
 
            this.songManager.getMeasureManager().autoCompleteSilences(measure);
302
 
        }
303
 
    }
304
 
    
305
 
    /**
306
 
     * Retorna true si es el primer compas
307
 
     */         
308
 
    public boolean isFirstMeasure(Measure measure){
309
 
        return (measure.getNumber() == 1);
310
 
    }
311
 
 
312
 
    /**
313
 
     * Retorna true si es el ultimo compas
314
 
     */         
315
 
    public boolean isLastMeasure(SongTrack track,Measure measure){
316
 
        return (countMeasures(track) == measure.getNumber());
317
 
    }
318
 
}