← 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/SongManager.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:
src/org/herac/tuxguitar/song/managers/SongManager.java
1
 
/*
2
 
 * Created on 23-nov-2005
3
 
 *
4
 
 * TODO To change the template for this generated file go to
5
 
 * Window - Preferences - Java - Code Style - Code Templates
6
 
 */
7
 
package org.herac.tuxguitar.song.managers;
8
 
 
9
 
import java.io.FileNotFoundException;
10
 
import java.io.IOException;
11
 
import java.util.ArrayList;
12
 
import java.util.Iterator;
13
 
import java.util.List;
14
 
 
15
 
import org.herac.tuxguitar.io.FileFormatFormatException;
16
 
import org.herac.tuxguitar.io.SongLoader;
17
 
import org.herac.tuxguitar.io.SongWriter;
18
 
import org.herac.tuxguitar.io.gp.GPFormatException;
19
 
import org.herac.tuxguitar.song.helpers.TrackMeasure;
20
 
import org.herac.tuxguitar.song.helpers.TracksMeasures;
21
 
import org.herac.tuxguitar.song.models.Duration;
22
 
import org.herac.tuxguitar.song.models.InstrumentString;
23
 
import org.herac.tuxguitar.song.models.Marker;
24
 
import org.herac.tuxguitar.song.models.Measure;
25
 
import org.herac.tuxguitar.song.models.MeasureHeader;
26
 
import org.herac.tuxguitar.song.models.RGBColor;
27
 
import org.herac.tuxguitar.song.models.Song;
28
 
import org.herac.tuxguitar.song.models.SongChannel;
29
 
import org.herac.tuxguitar.song.models.SongTrack;
30
 
import org.herac.tuxguitar.song.models.Tempo;
31
 
import org.herac.tuxguitar.song.models.TimeSignature;
32
 
 
33
 
 
34
 
/**
35
 
 * @author julian
36
 
 *
37
 
 * TODO To change the template for this generated type comment go to
38
 
 * Window - Preferences - Java - Code Style - Code Templates
39
 
 */
40
 
public class SongManager {
41
 
    public static final short MAX_CHANNELS = 16;
42
 
    
43
 
    private Song song;
44
 
    private SongTrackManager trackManager;
45
 
    private MeasureManager measureManager;
46
 
    
47
 
    public SongManager(){               
48
 
        this.newSong();
49
 
    }
50
 
    
51
 
    public void setSongName(String name){
52
 
        getSong().setName(name);
53
 
    }
54
 
    
55
 
    public Song getSong(){
56
 
        return this.song;
57
 
    }
58
 
    
59
 
    public void newSong(){
60
 
        setSong(makeNewSong());        
61
 
    }
62
 
    
63
 
    public void save(String fileName){                        
64
 
        try {
65
 
            new SongWriter(fileName).write(getSong());    
66
 
        } catch (FileNotFoundException e) {
67
 
            e.printStackTrace();
68
 
        } catch (GPFormatException e) {
69
 
            e.printStackTrace();
70
 
        } catch (IOException e) {
71
 
            e.printStackTrace();
72
 
        }         
73
 
    }
74
 
    
75
 
    public boolean open(String fileName) throws FileFormatFormatException{
76
 
        SongLoader loader = new SongLoader(fileName);
77
 
        Song song = loader.load();
78
 
        if(song != null){
79
 
            setSong(song);
80
 
            return true;
81
 
        }            
82
 
        return false;
83
 
    }        
84
 
 
85
 
    public void setSong(Song song){
86
 
        this.song = song;
87
 
    }
88
 
    
89
 
    public void setProperties(String name,String interpret,String album,String author){
90
 
        getSong().setName(name);
91
 
        getSong().setInterpret(interpret);
92
 
        getSong().setAlbum(album);
93
 
        getSong().setAuthor(author);
94
 
    }
95
 
    
96
 
    public void addTrack(SongTrack trackToAdd){
97
 
        this.orderTracks();
98
 
        int addIndex = -1;
99
 
        for(int i = 0;i < getSong().getTracks().size();i++){
100
 
                SongTrack track = (SongTrack)getSong().getTracks().get(i);
101
 
                if(addIndex == -1 && track.getNumber() == trackToAdd.getNumber()){
102
 
                        addIndex = i;
103
 
                }
104
 
                if(addIndex >= 0){
105
 
                        track.setNumber(track.getNumber() + 1);
106
 
                }
107
 
        }
108
 
        if(addIndex < 0){
109
 
                addIndex = getSong().getTracks().size();
110
 
        }
111
 
        getSong().getTracks().add(addIndex,trackToAdd);
112
 
    }
113
 
    
114
 
    public void removeTrack(int number){
115
 
        this.orderTracks();
116
 
        SongTrack trackToRemove = null;
117
 
        
118
 
        Iterator it = getSong().getTracks().iterator();
119
 
        while(it.hasNext()){
120
 
            SongTrack currTrack = (SongTrack)it.next();            
121
 
            if(trackToRemove == null && currTrack.getNumber() == number){
122
 
                trackToRemove = currTrack;
123
 
            }else if(currTrack.getNumber() == (number + 1)){                    
124
 
                currTrack.setNumber(number);
125
 
                number ++;
126
 
            }
127
 
            
128
 
        }
129
 
        getSong().getTracks().remove(trackToRemove);
130
 
    }
131
 
    
132
 
    private void orderTracks(){
133
 
        for(int i = 0;i < getSong().getTracks().size();i++){
134
 
                SongTrack minTrack = null;
135
 
            for(int trackIdx = i;trackIdx < getSong().getTracks().size();trackIdx++){
136
 
                SongTrack track = (SongTrack)getSong().getTracks().get(trackIdx);
137
 
                if(minTrack == null || track.getNumber() < minTrack.getNumber()){
138
 
                        minTrack = track;
139
 
                }
140
 
            }
141
 
            getSong().getTracks().remove(minTrack);
142
 
            getSong().getTracks().add(i,minTrack);
143
 
        }
144
 
    }
145
 
    
146
 
    public SongTrack getTrack(Measure measure){
147
 
        SongTrack track = null;
148
 
        Iterator it = getSong().getTracks().iterator();
149
 
        while(it.hasNext()){
150
 
            SongTrack currTrack = (SongTrack)it.next();
151
 
            if(currTrack.getMeasures().contains(measure)){
152
 
                track = currTrack;
153
 
                break;
154
 
            }
155
 
        }
156
 
        return track;
157
 
    }
158
 
    
159
 
    public static Song makeNewSong(){
160
 
        List tracks = new ArrayList();
161
 
        List strings = createDefaultInstrumentStrings();   
162
 
        List measureHeaders = new ArrayList();
163
 
        List measures = new ArrayList();
164
 
        MeasureHeader header = new MeasureHeader(1,1000,new TimeSignature(4,new Duration(Duration.QUARTER)),new Tempo(100),null,MeasureHeader.TRIPLET_FEEL_NONE,false,0);        
165
 
        measureHeaders.add(header);
166
 
        measures.add(new Measure(header,new ArrayList(),new ArrayList(),1,0));        
167
 
        tracks.add(new SongTrack(1,"Track 1",new SongChannel((short)0,(short)1,(short)0), measures, strings,0,RGBColor.RED));        
168
 
        return new Song(tracks,measureHeaders);  
169
 
    }    
170
 
 
171
 
    public int getNextTrackNumber(){
172
 
        return countTracks() + 1;
173
 
    }
174
 
    
175
 
    public boolean isEmpty(){
176
 
        return this.song.getTracks().isEmpty();
177
 
    }
178
 
    
179
 
    public SongChannel getFreeChannel(short instrument,boolean isPercusion){
180
 
        return getFreeChannel(getSong().getTracks(),instrument,isPercusion);
181
 
    }
182
 
 
183
 
    public static SongChannel getFreeChannel(List tracks,short instrument,boolean isPercusion){
184
 
        if(isPercusion){
185
 
                return SongChannel.getDefaultPercusionChannel();
186
 
        }
187
 
        short channel = -1;
188
 
        short effectChannel = -1;
189
 
        
190
 
        boolean[] usedChannels = getUsedChannels(tracks);
191
 
        boolean[] usedEffectChannels = getUsedEffectChannels(tracks);        
192
 
        for(short i = 0;i < MAX_CHANNELS;i++){
193
 
                if(!usedChannels[i] && !usedEffectChannels[i]){
194
 
                    channel = (channel < 0)?i:channel;
195
 
                    effectChannel = (effectChannel < 0 && i != channel)?i:effectChannel;
196
 
                }
197
 
        }
198
 
        if(channel < 0 || effectChannel < 0){
199
 
                if(channel >= 0 ){
200
 
                        effectChannel = channel;
201
 
                }else{
202
 
                        SongChannel songChannel = (SongChannel)((SongTrack)tracks.get(tracks.size() - 1)).getChannel();
203
 
                        return (SongChannel)songChannel.clone();
204
 
                }
205
 
        }
206
 
        return new SongChannel(channel,effectChannel,instrument);
207
 
    }
208
 
    
209
 
    public boolean[] getUsedEffectChannels(){
210
 
        return getUsedEffectChannels(getSong().getTracks());
211
 
    }
212
 
    
213
 
    public static boolean[] getUsedEffectChannels(List tracks){
214
 
        boolean[] usedEffectChannels = new boolean[MAX_CHANNELS];
215
 
        
216
 
        for(int i = 0;i < tracks.size();i++){
217
 
            SongTrack track = (SongTrack)tracks.get(i);            
218
 
            usedEffectChannels[track.getChannel().getEffectChannel()] = true;
219
 
        }        
220
 
        return usedEffectChannels;
221
 
    }
222
 
    
223
 
    public boolean[] getUsedChannels(){
224
 
        return getUsedChannels(getSong().getTracks());
225
 
    }
226
 
    
227
 
    public static boolean[] getUsedChannels(List tracks){
228
 
        boolean[] usedChannels = new boolean[MAX_CHANNELS];
229
 
        
230
 
        for(int i = 0;i < tracks.size();i++){
231
 
            SongTrack track = (SongTrack)tracks.get(i);            
232
 
            usedChannels[track.getChannel().getChannel()] = true;
233
 
        }        
234
 
        return usedChannels;
235
 
    }    
236
 
    
237
 
    public SongChannel getUsedChannel(int channel){
238
 
        for(int i = 0;i < getSong().getTracks().size();i++){
239
 
            SongTrack track = (SongTrack)getSong().getTracks().get(i);            
240
 
            if(channel == track.getChannel().getChannel()){
241
 
                return (SongChannel)track.getChannel().clone();
242
 
            }
243
 
        }   
244
 
        return null;
245
 
    }
246
 
    
247
 
    public int countTracksForChannel(int channel){
248
 
        int count = 0;
249
 
        for(int i = 0;i < getSong().getTracks().size();i++){
250
 
            SongTrack track = (SongTrack)getSong().getTracks().get(i);            
251
 
            if(channel == track.getChannel().getChannel()){
252
 
                count ++;
253
 
            }
254
 
        }   
255
 
        return count;
256
 
    }
257
 
    
258
 
    public void updateChannel(SongChannel channel){
259
 
        for(int i = 0;i < getSong().getTracks().size();i++){
260
 
            SongTrack track = (SongTrack)getSong().getTracks().get(i);            
261
 
            if(channel.getChannel() == track.getChannel().getChannel()){
262
 
                track.setChannel((SongChannel)channel.clone());
263
 
            }
264
 
        }
265
 
    }
266
 
    
267
 
    public static List createDefaultInstrumentStrings(){
268
 
        List strings = new ArrayList();        
269
 
        strings.add(new InstrumentString(1, 64));
270
 
        strings.add(new InstrumentString(2, 59));
271
 
        strings.add(new InstrumentString(3, 55));
272
 
        strings.add(new InstrumentString(4, 50));
273
 
        strings.add(new InstrumentString(5, 45));
274
 
        strings.add(new InstrumentString(6, 40));
275
 
        return strings;
276
 
    }
277
 
    
278
 
    public static List createPercusionStrings(int stringCount){
279
 
        List strings = new ArrayList();      
280
 
        for(int i = 1;i <= stringCount; i++){
281
 
            strings.add(new InstrumentString(i, 0));
282
 
        }
283
 
        return strings;
284
 
    }        
285
 
 
286
 
    public void calculateMeasureStartWithRepetitions(){
287
 
        boolean repeatOpen = true;        
288
 
        long repeatStart = 1000;
289
 
        
290
 
        long repeatEnd = 0;
291
 
        long startMove = 0;
292
 
        int repeatStartIndex = 0;
293
 
        int repeatNumber = 0;
294
 
 
295
 
        for (int headerIdx = 0; headerIdx < getSong().getMeasureHeaders().size(); headerIdx++) {
296
 
            MeasureHeader header = (MeasureHeader) getSong().getMeasureHeaders().get(headerIdx);
297
 
            
298
 
            //asigno el start con repeticiones
299
 
            if(!repeatOpen || header.getStart() + header.getLength() > repeatEnd){
300
 
                header.setStartWidthRepetitions(header.getStart() + startMove);
301
 
                //calculo las notas dentro del compas
302
 
                Iterator it = getSong().getTracks().iterator();
303
 
                while(it.hasNext()){
304
 
                        SongTrack track = (SongTrack)it.next();
305
 
                        getMeasureManager().calculateNoteStartWithRepetitions(getTrackManager().getMeasure(track,header.getNumber()),startMove);                                                
306
 
                }
307
 
            }            
308
 
 
309
 
            //guardo el indice de el compas donde empieza una repeticion
310
 
            if (header.isRepeatStart()) {
311
 
                repeatStartIndex = headerIdx;                
312
 
                repeatStart = header.getStart();
313
 
                repeatOpen = true;
314
 
            }
315
 
 
316
 
            //si hay una repeticion la hago
317
 
            if (repeatOpen && header.getNumberOfRepetitions() > 0) {
318
 
                if (repeatNumber < header.getNumberOfRepetitions()) {
319
 
                    repeatEnd = header.getStart() + header.getLength();
320
 
                    startMove += repeatEnd - repeatStart;
321
 
                    headerIdx = repeatStartIndex - 1;
322
 
                    repeatNumber++;
323
 
                } else {
324
 
                    repeatStart = 0;
325
 
                    repeatNumber = 0;
326
 
                    repeatEnd = 0;
327
 
                    repeatOpen = false;
328
 
                }
329
 
            }
330
 
 
331
 
        }        
332
 
    }
333
 
    
334
 
 
335
 
    public int countTracks(){
336
 
        return (getSong().getTracks().size());
337
 
    }
338
 
 
339
 
    public int countMeasures(){
340
 
        return (getMeasureHeaders().size());
341
 
    }
342
 
    
343
 
    public SongTrackManager getTrackManager(){
344
 
        if(this.trackManager == null){
345
 
                this.trackManager = new SongTrackManager(this);
346
 
        }
347
 
        return this.trackManager;
348
 
    }
349
 
    
350
 
    public MeasureManager getMeasureManager(){
351
 
        if(this.measureManager == null){
352
 
                this.measureManager = new MeasureManager(this);
353
 
        }
354
 
        return this.measureManager;
355
 
    }    
356
 
    
357
 
    public SongTrack getTrack(long number){
358
 
        SongTrack track = null;        
359
 
        for (int i = 0; i < getSong().getTracks().size(); i++) {
360
 
            SongTrack currTrack = (SongTrack) getSong().getTracks().get(i);            
361
 
            if(currTrack.getNumber() == number){
362
 
                track = currTrack;
363
 
                break;
364
 
            }
365
 
        }     
366
 
        return track;
367
 
    }  
368
 
    
369
 
    
370
 
    public SongTrack getFirstTrack(){
371
 
        SongTrack track = null;
372
 
        if(!getSong().getTracks().isEmpty()){
373
 
            track = (SongTrack)getSong().getTracks().get(0);
374
 
        }
375
 
        return track;
376
 
    }       
377
 
 
378
 
    public SongTrack getLastTrack(){
379
 
        SongTrack track = null;
380
 
        if(!getSong().getTracks().isEmpty()){
381
 
            track = (SongTrack)getSong().getTracks().get(getSong().getTracks().size() - 1);
382
 
        }
383
 
        return track;
384
 
    }   
385
 
 
386
 
    public SongTrack cloneTrack(SongTrack track){
387
 
        SongTrack clone = (SongTrack)track.clone(getMeasureHeaders());
388
 
        clone.setNumber(getNextTrackNumber());
389
 
        addTrack(clone);        
390
 
        return clone;
391
 
    }
392
 
    
393
 
    public boolean moveTrackUp(SongTrack track){  
394
 
        if(track.getNumber() > 1){
395
 
                SongTrack prevTrack = getTrack(track.getNumber() - 1);
396
 
                prevTrack.setNumber(prevTrack.getNumber() + 1);        
397
 
                track.setNumber(track.getNumber() - 1);                 
398
 
                orderTracks();
399
 
                return true;
400
 
        }
401
 
        return false;
402
 
    }       
403
 
 
404
 
    public boolean moveTrackDown(SongTrack track){  
405
 
        if(track.getNumber() < this.countTracks()){
406
 
                SongTrack nextTrack = getTrack(track.getNumber() + 1);
407
 
                nextTrack.setNumber(nextTrack.getNumber() - 1);        
408
 
                track.setNumber(track.getNumber() + 1);                 
409
 
                orderTracks();
410
 
                return true;
411
 
        }
412
 
        return false;
413
 
    }    
414
 
 
415
 
    private SongTrack makeNewTrack(){        
416
 
        //measures
417
 
        List measures = new ArrayList();        
418
 
        Iterator it = getSong().getMeasureHeaders().iterator();
419
 
        while(it.hasNext()){
420
 
            MeasureHeader header = (MeasureHeader)it.next();            
421
 
            measures.add(new Measure(header,new ArrayList(),new ArrayList(),1,0));
422
 
        }
423
 
        //Strings
424
 
        int number = getNextTrackNumber();
425
 
        String name = "Track " + number;
426
 
        SongChannel channel = getFreeChannel((short)0,false);
427
 
        List strings = createDefaultInstrumentStrings();
428
 
 
429
 
        return new SongTrack(number,name,channel,measures,strings,0,RGBColor.RED);
430
 
    }
431
 
    
432
 
    public SongTrack createTrack(){
433
 
        SongTrack track = null;
434
 
        if(getSong().getTracks().isEmpty()){
435
 
            setSong(makeNewSong());
436
 
        }else{
437
 
            track = makeNewTrack();
438
 
        }
439
 
        addTrack(track);
440
 
        return track;
441
 
    }
442
 
 
443
 
    public void removeTrack(SongTrack track){
444
 
        removeTrack(track.getNumber());
445
 
    }    
446
 
 
447
 
    public void changeTimeSignature(long start,TimeSignature timeSignature,boolean toEnd){
448
 
        changeTimeSignature(getMeasureHeaderAt(start),timeSignature,toEnd);
449
 
    }
450
 
    
451
 
 
452
 
    public void changeTimeSignature(MeasureHeader header,TimeSignature timeSignature,boolean toEnd){        
453
 
        //asigno el nuevo ritmo
454
 
        header.setTimeSignature((TimeSignature)timeSignature.clone());         
455
 
 
456
 
        long nextStart = header.getStart() + header.getLength();
457
 
        List measures = getMeasureHeadersBeforeEnd(header.getStart() + 1);
458
 
        Iterator it = measures.iterator();
459
 
        while(it.hasNext()){
460
 
            MeasureHeader nextHeader = (MeasureHeader)it.next();
461
 
            
462
 
            long theMove = nextStart - nextHeader.getStart();
463
 
 
464
 
            moveMeasureComponents(nextHeader,theMove,0);
465
 
            moveMeasureHeader(nextHeader,theMove,0);
466
 
 
467
 
            if(toEnd){           
468
 
                nextHeader.setTimeSignature((TimeSignature)timeSignature.clone());  
469
 
            }
470
 
            
471
 
            nextStart = nextHeader.getStart() + nextHeader.getLength();
472
 
        }
473
 
                  
474
 
    }    
475
 
 
476
 
    public void changeTripletFeel(long start,int tripletFeel,boolean toEnd){
477
 
        changeTripletFeel(getMeasureHeaderAt(start),tripletFeel,toEnd);
478
 
    }
479
 
    
480
 
 
481
 
    public void changeTripletFeel(MeasureHeader header,int tripletFeel,boolean toEnd){        
482
 
        //asigno el nuevo tripletFeel
483
 
        header.setTripletFeel(tripletFeel);    
484
 
 
485
 
        if(toEnd){
486
 
            List measures = getMeasureHeadersBeforeEnd(header.getStart() + 1);
487
 
            Iterator it = measures.iterator();
488
 
            while(it.hasNext()){
489
 
                MeasureHeader nextHeader = (MeasureHeader)it.next();
490
 
                nextHeader.setTripletFeel(tripletFeel); 
491
 
            }            
492
 
        }                  
493
 
    }    
494
 
    
495
 
    
496
 
    public void changeTempo(long start,Tempo tempo,boolean toEnd){
497
 
        changeTempo(getMeasureHeaderAt(start),tempo,toEnd);
498
 
    }    
499
 
    
500
 
    public void changeTempo(MeasureHeader header,Tempo tempo,boolean toEnd){        
501
 
        //asigno el nuevo tempo
502
 
        header.setTempo((Tempo)tempo.clone());        
503
 
 
504
 
        if(toEnd){
505
 
            List measures = getMeasureHeadersBeforeEnd(header.getStart() + 1);
506
 
            Iterator it = measures.iterator();
507
 
            while(it.hasNext()){
508
 
                MeasureHeader nextHeader = (MeasureHeader)it.next();
509
 
                nextHeader.setTempo((Tempo)tempo.clone()); 
510
 
            }            
511
 
        }
512
 
        
513
 
    }        
514
 
 
515
 
    public void changeOpenRepeat(long start){
516
 
        MeasureHeader header = getMeasureHeaderAt(start);
517
 
        header.setRepeatStart(!header.isRepeatStart());
518
 
        calculateMeasureStartWithRepetitions();
519
 
    }    
520
 
 
521
 
    public void changeCloseRepeat(long start,int numberOfRepetitions){
522
 
        MeasureHeader header = getMeasureHeaderAt(start);
523
 
        header.setNumberOfRepetitions(numberOfRepetitions);
524
 
        calculateMeasureStartWithRepetitions();
525
 
    }    
526
 
    
527
 
    public void addNewMeasureBeforeEnd(){        
528
 
        MeasureHeader lastHeader = getLastMeasureHeader();      
529
 
        TimeSignature timeSignature = (TimeSignature)lastHeader.getTimeSignature().clone();   
530
 
        Tempo tempo = (Tempo)lastHeader.getTempo().clone(); 
531
 
        int number = (lastHeader.getNumber() + 1);
532
 
        long start = (lastHeader.getStart() + lastHeader.getLength());        
533
 
        boolean repeatStart = false;
534
 
        int numberOfRepetitions = 0;                    
535
 
        int tripletFeel = lastHeader.getTripletFeel();
536
 
        
537
 
        MeasureHeader header = new MeasureHeader(number,start,timeSignature,tempo,null,tripletFeel,repeatStart,numberOfRepetitions);            
538
 
        getSong().getMeasureHeaders().add(header);
539
 
        
540
 
        Iterator it = getSong().getTracks().iterator();
541
 
        while(it.hasNext()){
542
 
                SongTrack track = (SongTrack)it.next();
543
 
            
544
 
            getTrackManager().addNewMeasureBeforeEnd(track,header);            
545
 
        }   
546
 
        calculateMeasureStartWithRepetitions();
547
 
    }
548
 
       
549
 
    public void addNewMeasure(int number){
550
 
        //Obtengo un clon para el nuevo Header.
551
 
        MeasureHeader header = null;
552
 
        if(number == 1){
553
 
                header = (MeasureHeader)getMeasureHeader(number).clone();               
554
 
        }else{
555
 
                header = (MeasureHeader)getMeasureHeader((number - 1)).clone();
556
 
                header.setStart(header.getStart() + header.getLength());
557
 
                header.setNumber(header.getNumber() + 1);
558
 
        }
559
 
        header.setMarker(null);
560
 
        header.setRepeatStart(false);
561
 
        header.setNumberOfRepetitions(0);
562
 
        
563
 
        //Si hay Headers siguientes los muevo
564
 
        MeasureHeader nextHeader = getMeasureHeader(number);            
565
 
        if(nextHeader != null){
566
 
                moveMeasureHeaders(getMeasureHeadersBeforeEnd(nextHeader.getStart()),header.getLength(),1,true);
567
 
        }
568
 
        
569
 
        //Agrego el header a la lista
570
 
        addMeasureHeader( (header.getNumber() - 1) ,header);
571
 
        
572
 
        //Agrego los compases en todas las pistas
573
 
        Iterator it = getSong().getTracks().iterator();
574
 
        while(it.hasNext()){
575
 
                SongTrack track = (SongTrack)it.next();
576
 
                getTrackManager().addNewMeasure(track,header);
577
 
        }  
578
 
        
579
 
        calculateMeasureStartWithRepetitions();
580
 
    }    
581
 
 
582
 
        
583
 
    public List getMeasures(long start){
584
 
        List measures = new ArrayList();
585
 
        Iterator it = getSong().getTracks().iterator();
586
 
        while(it.hasNext()){
587
 
                SongTrack track = (SongTrack)it.next();
588
 
            Measure measure = getTrackManager().getMeasureAt(track,start);
589
 
            if(measure != null){
590
 
                measures.add(measure);
591
 
            }
592
 
        }  
593
 
        return measures;
594
 
    }    
595
 
    
596
 
    public SongTrack replaceTrack(SongTrack t){
597
 
        SongTrack track = getTrack(t.getNumber());
598
 
        if(track != null){
599
 
                track.makeEqual(t,getMeasureHeaders());
600
 
        }       
601
 
        return track;
602
 
    }
603
 
    
604
 
    public TracksMeasures copyMeasures(long p1, long p2){
605
 
        TracksMeasures tracksMeasures = new TracksMeasures(); 
606
 
        tracksMeasures.setMeasureHeaders(getMeasureHeadersBetween(p1,p2));
607
 
        
608
 
        List list = new ArrayList();
609
 
        Iterator it = getSong().getTracks().iterator();
610
 
        while(it.hasNext()){
611
 
                SongTrack track = (SongTrack)it.next();
612
 
                List measures = getTrackManager().copyMeasures(track,p1,p2);
613
 
                tracksMeasures.addTrackMeasure(track.getNumber(),measures);
614
 
        }        
615
 
        return (TracksMeasures)tracksMeasures.clone();
616
 
    }
617
 
    
618
 
    public TracksMeasures copyMeasures(long p1, long p2,SongTrack track){
619
 
        TracksMeasures tracksMeasures = new TracksMeasures(); 
620
 
        tracksMeasures.setMeasureHeaders(getMeasureHeadersBetween(p1,p2));      
621
 
        
622
 
        List list = new ArrayList();
623
 
        List measures = getTrackManager().copyMeasures(track,p1,p2);
624
 
        tracksMeasures.addTrackMeasure(track.getNumber(),measures);
625
 
            
626
 
        return (TracksMeasures)tracksMeasures.clone();
627
 
    }    
628
 
    
629
 
    
630
 
    public void insertMeasures(TracksMeasures tracksMeasures,int fromNumber,long move){         
631
 
        List measureHeaders = new ArrayList();
632
 
        moveMeasureHeaders(tracksMeasures.getMeasureHeaders(),move,0,false);
633
 
        
634
 
        int headerNumber = fromNumber;
635
 
        Iterator it = tracksMeasures.getMeasureHeaders().iterator();
636
 
        while(it.hasNext()){
637
 
                MeasureHeader header = (MeasureHeader)it.next();
638
 
                header.setNumber(headerNumber);
639
 
                measureHeaders.add(header);
640
 
                headerNumber ++;
641
 
        }       
642
 
        
643
 
        //-----------------------------
644
 
        long start = ((MeasureHeader)measureHeaders.get(0)).getStart(); 
645
 
        long end = ((MeasureHeader)measureHeaders.get(measureHeaders.size() - 1)).getStart() + ((MeasureHeader)measureHeaders.get(measureHeaders.size() - 1)).getLength();      
646
 
        List headersBeforeEnd = getMeasureHeadersBeforeEnd(start);
647
 
        moveMeasureHeaders(headersBeforeEnd,end - start,measureHeaders.size(),true);       
648
 
        /*
649
 
        it = getMeasureHeadersBeforeEnd(start).iterator();
650
 
        while(it.hasNext()){
651
 
                MeasureHeader header = (MeasureHeader)it.next();
652
 
            moveMeasureComponents(header,end - start,measureHeaders.size());            
653
 
        }
654
 
        it= getMeasureHeadersBeforeEnd(start).iterator();
655
 
        while(it.hasNext()){
656
 
                MeasureHeader header = (MeasureHeader)it.next();
657
 
            moveMeasureHeader(header,end - start,measureHeaders.size(),false);            
658
 
        }          
659
 
        */
660
 
        //---------------------------------------
661
 
        
662
 
        it = tracksMeasures.getMeasureHeaders().iterator();
663
 
        while(it.hasNext()){
664
 
                MeasureHeader header = (MeasureHeader)it.next();
665
 
                addMeasureHeader(header.getNumber() - 1,header);
666
 
        }               
667
 
        
668
 
        it = getSong().getTracks().iterator();
669
 
        while (it.hasNext()) {
670
 
            SongTrack currTrack = (SongTrack) it.next();
671
 
            List measures = null;
672
 
                        
673
 
            Iterator trackMeasureIt = tracksMeasures.getTrackMeasures().iterator();
674
 
            while(trackMeasureIt.hasNext()){
675
 
                TrackMeasure trackMeasure = (TrackMeasure)trackMeasureIt.next();
676
 
                if(trackMeasure.getTrack() == currTrack.getNumber()){
677
 
                        measures = trackMeasure.getMeasures();
678
 
                        break;
679
 
                }
680
 
            }            
681
 
            if(measures == null){
682
 
                measures = getEmptyMeasures(((TrackMeasure)tracksMeasures.getTrackMeasures().get(0)).getMeasures());
683
 
            }             
684
 
            
685
 
                for(int i = 0;i < measures.size();i++){
686
 
                        Measure measure = (Measure)measures.get(i);
687
 
                        measure.setHeader((MeasureHeader)measureHeaders.get(i));
688
 
                        getMeasureManager().moveAllComponents(measure,move);                            
689
 
                }            
690
 
 
691
 
            getTrackManager().insertMeasures(currTrack,measures, fromNumber);
692
 
        }                        
693
 
        calculateMeasureStartWithRepetitions();
694
 
    }
695
 
    
696
 
    private List getEmptyMeasures(List measures) {
697
 
        List emptyMeasures = new ArrayList();
698
 
 
699
 
        Iterator it = measures.iterator();
700
 
        while (it.hasNext()) {
701
 
            Measure measure = (Measure) it.next();
702
 
            int clef = measure.getClef();
703
 
            int keySignature = measure.getKeySignature();            
704
 
            
705
 
            emptyMeasures.add(new Measure(null, new ArrayList(), new ArrayList(),clef,keySignature));
706
 
        }
707
 
        return emptyMeasures;
708
 
    }    
709
 
    
710
 
    
711
 
    public void replaceMeasures(TracksMeasures tracksMeasures,long move) {
712
 
        List measureHeaders = new ArrayList();
713
 
        moveMeasureHeaders(tracksMeasures.getMeasureHeaders(),move,0,false);            
714
 
        Iterator it = tracksMeasures.getMeasureHeaders().iterator();
715
 
        while(it.hasNext()){
716
 
                MeasureHeader header = (MeasureHeader)it.next();                
717
 
                measureHeaders.add(replaceMeasureHeader(header));
718
 
        }
719
 
        
720
 
        it = tracksMeasures.getTrackMeasures().iterator();
721
 
        while(it.hasNext()){
722
 
                TrackMeasure trackMeasure = (TrackMeasure)it.next();
723
 
                
724
 
                SongTrack currTrack = getTrack(trackMeasure.getTrack());
725
 
                List measures = trackMeasure.getMeasures();             
726
 
                for(int i = 0;i < measures.size();i++){
727
 
                        Measure measure = (Measure)measures.get(i);
728
 
                        measure.setHeader((MeasureHeader)measureHeaders.get(i));
729
 
                        getMeasureManager().moveAllComponents(measure,move);
730
 
                        getTrackManager().replaceMeasure(currTrack,measure);                    
731
 
                }
732
 
        }        
733
 
        calculateMeasureStartWithRepetitions();        
734
 
    }        
735
 
 
736
 
    
737
 
           
738
 
    public MeasureHeader getFirstMeasureHeader(){
739
 
        MeasureHeader firstHeader = null;    
740
 
        for(int i = 0;i < getSong().getMeasureHeaders().size();i++){
741
 
                MeasureHeader currHeader = (MeasureHeader)getSong().getMeasureHeaders().get(i);
742
 
            if(firstHeader == null || (currHeader.getStart() < firstHeader.getStart())){
743
 
                firstHeader = currHeader;
744
 
            }
745
 
        }        
746
 
        return firstHeader;
747
 
    }     
748
 
 
749
 
    public MeasureHeader getLastMeasureHeader(){
750
 
        int lastIndex = getSong().getMeasureHeaders().size() - 1; 
751
 
        return (MeasureHeader)getSong().getMeasureHeaders().get(lastIndex);
752
 
    }      
753
 
    
754
 
    public MeasureHeader getPrevMeasureHeader(MeasureHeader header){
755
 
        int prevIndex = header.getNumber() - 1; 
756
 
        if(prevIndex > 0){
757
 
            return (MeasureHeader)getSong().getMeasureHeaders().get(prevIndex - 1);
758
 
        }
759
 
        return null;
760
 
    }      
761
 
    
762
 
    public MeasureHeader getNextMeasureHeader(MeasureHeader header){
763
 
        int nextIndex = header.getNumber(); 
764
 
        if(nextIndex < getSong().getMeasureHeaders().size()){
765
 
            return (MeasureHeader)getSong().getMeasureHeaders().get(nextIndex);
766
 
        }
767
 
        return null;
768
 
    }       
769
 
  
770
 
    public MeasureHeader getMeasureHeaderAt(long start){
771
 
        Iterator it = getSong().getMeasureHeaders().iterator();
772
 
        while(it.hasNext()){
773
 
                MeasureHeader header = (MeasureHeader)it.next();  
774
 
            long measureStart = header.getStart();
775
 
            long measureLength = header.getLength();
776
 
            if(start >= measureStart && start < measureStart + measureLength){
777
 
                return header;
778
 
            }
779
 
        }     
780
 
        return null;
781
 
    }           
782
 
    
783
 
    public MeasureHeader getMeasureHeader(int number){
784
 
        for (int i = 0; i < getSong().getMeasureHeaders().size(); i++) {
785
 
                MeasureHeader header = (MeasureHeader)getSong().getMeasureHeaders().get(i);            
786
 
            if(header.getNumber() == number){
787
 
                return header;
788
 
            }
789
 
        }     
790
 
        return null;
791
 
    }   
792
 
    
793
 
    /**
794
 
     * Retorna Todos los desde Start hasta el final del compas
795
 
     */
796
 
    public List getMeasureHeadersBeforeEnd(long fromStart) {
797
 
        List headers = new ArrayList();        
798
 
        Iterator it = getSong().getMeasureHeaders().iterator();
799
 
        while(it.hasNext()){           
800
 
                MeasureHeader header = (MeasureHeader)it.next();
801
 
            if (header.getStart() >= fromStart) {
802
 
                headers.add(header);
803
 
            }
804
 
        }
805
 
        return headers;
806
 
    }         
807
 
    
808
 
    /**
809
 
     * Retorna Todos los desde Start hasta el final del compas
810
 
     */
811
 
    public List getMeasureHeadersAfter(int number) {
812
 
        List headers = new ArrayList();        
813
 
        Iterator it = getSong().getMeasureHeaders().iterator();
814
 
        while(it.hasNext()){           
815
 
                MeasureHeader header = (MeasureHeader)it.next();
816
 
            if (header.getNumber() > number) {
817
 
                headers.add(header);
818
 
            }
819
 
        }
820
 
        return headers;
821
 
    }      
822
 
    
823
 
    /**
824
 
     * Retorna Todos los desde Start hasta el final del compas
825
 
     */
826
 
    public List getMeasureHeadersBetween(long p1,long p2) {
827
 
        List headers = new ArrayList();        
828
 
        Iterator it = getSong().getMeasureHeaders().iterator();
829
 
        while(it.hasNext()){           
830
 
                MeasureHeader header = (MeasureHeader)it.next();
831
 
            long start = header.getStart();
832
 
            if (start >= p1 && start <= p2) {
833
 
                headers.add(header);
834
 
            }
835
 
        }
836
 
        return headers;
837
 
    }
838
 
 
839
 
    public List getMeasureHeaders(){
840
 
        return getSong().getMeasureHeaders();
841
 
    }    
842
 
    
843
 
 
844
 
    public void removeMeasures(long p1,long p2){
845
 
        removeMeasureHeaders(p1,p2);
846
 
    }
847
 
    
848
 
    public void removeLastMeasure(){ 
849
 
        removeLastMeasureHeader();
850
 
    }    
851
 
    
852
 
    public void removeMeasure(long start){
853
 
        removeMeasureHeader(start);
854
 
    }
855
 
   
856
 
    
857
 
    public void removeMeasure(int number){
858
 
        removeMeasureHeader(number);
859
 
    }
860
 
    
861
 
    
862
 
    /**
863
 
     * Agrega un Compas
864
 
     */
865
 
    public void addMeasureHeader(MeasureHeader measure){
866
 
        getSong().getMeasureHeaders().add(measure);
867
 
    }    
868
 
    
869
 
    /**
870
 
     * Agrega un Compas
871
 
     */
872
 
    public void addMeasureHeader(int index,MeasureHeader measure){
873
 
        getSong().getMeasureHeaders().add(index,measure);
874
 
    }        
875
 
    
876
 
    public void removeMeasureHeaders(long p1,long p2){
877
 
        List measures = new ArrayList();
878
 
        
879
 
        Iterator it = getMeasureHeadersBetween(p1,p2).iterator();
880
 
        while(it.hasNext()){
881
 
            MeasureHeader measure = (MeasureHeader)it.next();
882
 
            removeMeasureHeader(measure);
883
 
        }        
884
 
    }    
885
 
    
886
 
    public void removeLastMeasureHeader(){    
887
 
        removeMeasureHeader(getLastMeasureHeader());
888
 
    }
889
 
    
890
 
    public void removeMeasureHeader(long start){    
891
 
        removeMeasureHeader(getMeasureHeaderAt(start));
892
 
    }
893
 
    
894
 
    public void removeMeasureHeader(int number){    
895
 
        removeMeasureHeader(getMeasureHeader(number));
896
 
    }
897
 
    
898
 
    public void removeMeasureHeader(MeasureHeader header){        
899
 
        long start = header.getStart();
900
 
        long length = header.getLength();
901
 
        
902
 
        Iterator it = getSong().getTracks().iterator();
903
 
        while(it.hasNext()){
904
 
                SongTrack track = (SongTrack)it.next();
905
 
            getTrackManager().removeMeasure(track,start);     
906
 
        }   
907
 
        
908
 
        List nextMeasures = getMeasureHeadersBeforeEnd(start + 1);
909
 
        moveMeasureHeaders(nextMeasures,-length,-1,true);  
910
 
        /*
911
 
        it = nextMeasures.iterator();
912
 
        while(it.hasNext()){
913
 
            MeasureHeader currMeasure = (MeasureHeader)it.next();
914
 
            moveMeasureHeader(currMeasure,-length,-1,true);            
915
 
        }    
916
 
        */
917
 
        getSong().getMeasureHeaders().remove(header.getNumber() - 1);  
918
 
        
919
 
        calculateMeasureStartWithRepetitions();
920
 
    }    
921
 
    
922
 
    public MeasureHeader replaceMeasureHeader(MeasureHeader newMeasure){        
923
 
        MeasureHeader measure = getMeasureHeaderAt(newMeasure.getStart());
924
 
        measure.makeEqual((MeasureHeader)newMeasure.clone());
925
 
        //measure.makeEqual(newMeasure);        
926
 
 
927
 
 
928
 
        return measure;
929
 
    }
930
 
    
931
 
    
932
 
    public void moveMeasureHeaders(List headers,long theMove,int numberMove,boolean moveComponents) {        
933
 
        if(moveComponents){
934
 
                Iterator it = headers.iterator();
935
 
                while(it.hasNext()){
936
 
                        MeasureHeader header = (MeasureHeader) it.next();
937
 
                        moveMeasureComponents(header,theMove,numberMove);     
938
 
                }
939
 
        }               
940
 
        Iterator it = headers.iterator();
941
 
        while (it.hasNext()) {
942
 
            MeasureHeader header = (MeasureHeader) it.next();
943
 
            moveMeasureHeader(header,theMove,numberMove);
944
 
        }
945
 
    }    
946
 
    
947
 
    /**
948
 
     * Mueve el compas
949
 
     */
950
 
    public void moveMeasureHeader(MeasureHeader header,long theMove,int numberMove){     
951
 
        header.setNumber(header.getNumber() + numberMove);
952
 
        header.setStart(header.getStart() + theMove);
953
 
    }    
954
 
    
955
 
    /**
956
 
     * Mueve el compas
957
 
     */
958
 
    public void moveMeasureComponents(MeasureHeader header,long theMove,int numberMove){     
959
 
        Iterator it = getSong().getTracks().iterator();
960
 
        while(it.hasNext()){
961
 
                SongTrack track = (SongTrack)it.next();
962
 
            getTrackManager().moveMeasure(track,getTrackManager().getMeasure(track,header.getNumber()),theMove,numberMove);     
963
 
        }
964
 
    }    
965
 
    
966
 
    
967
 
    /** 
968
 
     * Retorna true si el start esta en el rango del compas
969
 
     */
970
 
    public boolean isAtPosition(MeasureHeader header,long start){               
971
 
                return (start >= header.getStart() && start < header.getStart() + header.getLength());          
972
 
    }
973
 
    
974
 
    
975
 
    
976
 
    
977
 
    
978
 
    
979
 
    
980
 
    
981
 
    
982
 
    
983
 
    
984
 
    
985
 
    
986
 
    
987
 
    public Marker updateMarker(int number,String title,RGBColor color){    
988
 
        return updateMarker(new Marker(number,title,color));
989
 
    }     
990
 
    
991
 
    public Marker updateMarker(Marker marker){    
992
 
        MeasureHeader header = getMeasureHeader(marker.getMeasure());
993
 
        if(header != null){
994
 
                header.setMarker(marker);
995
 
        }
996
 
        return null;
997
 
    }     
998
 
    
999
 
    public void removeMarker(Marker marker){
1000
 
        if(marker != null){
1001
 
                removeMarker(marker.getMeasure());
1002
 
        }
1003
 
    }    
1004
 
    
1005
 
    public void removeMarker(int number){
1006
 
        MeasureHeader header = getMeasureHeader(number);
1007
 
        if(header != null && header.hasMarker()){
1008
 
                header.setMarker(null);
1009
 
        }
1010
 
    }
1011
 
    
1012
 
    public void removeAllMarkers(){ 
1013
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1014
 
        while(it.hasNext()){
1015
 
                MeasureHeader header = (MeasureHeader)it.next();
1016
 
                if(header.hasMarker()){
1017
 
                        header.setMarker(null);
1018
 
                }
1019
 
        }
1020
 
    }
1021
 
 
1022
 
    public List getMarkers(){ 
1023
 
        List markers = new ArrayList();
1024
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1025
 
        while(it.hasNext()){
1026
 
                MeasureHeader header = (MeasureHeader)it.next();
1027
 
                if(header.hasMarker()){
1028
 
                        markers.add(header.getMarker());
1029
 
                }
1030
 
        }  
1031
 
        return markers;
1032
 
    }    
1033
 
 
1034
 
    public Marker getMarker(int number){       
1035
 
        MeasureHeader header = getMeasureHeader(number);
1036
 
        if(header != null && header.hasMarker()){
1037
 
                return header.getMarker();
1038
 
        }
1039
 
        return null;
1040
 
    }      
1041
 
    
1042
 
    public Marker getPreviousMarker(int from){
1043
 
        MeasureHeader previous = null;          
1044
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1045
 
        while(it.hasNext()){
1046
 
                MeasureHeader header = (MeasureHeader)it.next();
1047
 
                if(header.hasMarker() && header.getNumber() < from){
1048
 
                        if(previous == null || previous.getNumber() < header.getNumber()){
1049
 
                                previous = header;
1050
 
                        }
1051
 
                }
1052
 
        }               
1053
 
        return (previous != null)?previous.getMarker():null;
1054
 
    }         
1055
 
    
1056
 
    public Marker getNextMarker(int from){
1057
 
        MeasureHeader next = null;      
1058
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1059
 
        while(it.hasNext()){
1060
 
                MeasureHeader header = (MeasureHeader)it.next();
1061
 
                if(header.hasMarker() && header.getNumber() > from){
1062
 
                        if(next == null || next.getNumber() > header.getNumber()){
1063
 
                                next = header;
1064
 
                        }
1065
 
                }
1066
 
        }               
1067
 
        return (next != null)?next.getMarker():null;
1068
 
    }        
1069
 
 
1070
 
    public Marker getFirstMarker(){
1071
 
        MeasureHeader first = null;     
1072
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1073
 
        while(it.hasNext()){
1074
 
                MeasureHeader header = (MeasureHeader)it.next();
1075
 
                if(header.hasMarker()){
1076
 
                        if(first == null || header.getNumber() < first.getNumber()){
1077
 
                                first = header;
1078
 
                        }
1079
 
                }
1080
 
        }               
1081
 
        return (first != null)?first.getMarker():null;
1082
 
    }            
1083
 
    
1084
 
    public Marker getLastMarker(){
1085
 
        MeasureHeader next = null;      
1086
 
        Iterator it = getSong().getMeasureHeaders().iterator();
1087
 
        while(it.hasNext()){
1088
 
                MeasureHeader header = (MeasureHeader)it.next();
1089
 
                if(header.hasMarker()){
1090
 
                        if(next == null || header.getNumber() > next.getNumber()){
1091
 
                                next = header;
1092
 
                        }
1093
 
                }
1094
 
        }               
1095
 
        return (next != null)?next.getMarker():null;
1096
 
    }        
1097
 
 
1098
 
    
1099
 
    public void autoCompleteSilences(){
1100
 
        Iterator it = getSong().getTracks().iterator();
1101
 
        while(it.hasNext()){
1102
 
                SongTrack track = (SongTrack)it.next();      
1103
 
            getTrackManager().autoCompleteSilences(track);
1104
 
        }
1105
 
    }
1106
 
    
1107
 
}