← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2008-06-19 00:30:30 UTC
  • mfrom: (1.1.1 upstream) (2.1.3 hardy)
  • Revision ID: james.westby@ubuntu.com-20080619003030-agens2gvd5m4dacu
http://bugs.debian.org/481728
https://launchpad.net/bugs/176979
https://launchpad.net/bugs/212207
New upstream release (Closes: #481728) also (LP: #176979, #212207)

Show diffs side-by-side

added added

removed removed

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