1
package org.herac.tuxguitar.song.managers;
3
import java.util.ArrayList;
4
import java.util.Iterator;
7
import org.herac.tuxguitar.gui.editors.tab.TablatureUtil;
8
import org.herac.tuxguitar.song.models.Component;
9
import org.herac.tuxguitar.song.models.Duration;
10
import org.herac.tuxguitar.song.models.InstrumentString;
11
import org.herac.tuxguitar.song.models.Measure;
12
import org.herac.tuxguitar.song.models.Note;
13
import org.herac.tuxguitar.song.models.Silence;
14
import org.herac.tuxguitar.song.models.SongTrack;
15
import org.herac.tuxguitar.song.models.Tupleto;
16
import org.herac.tuxguitar.song.models.effects.BendEffect;
17
import org.herac.tuxguitar.song.models.effects.GraceEffect;
18
import org.herac.tuxguitar.song.models.effects.HarmonicEffect;
19
import org.herac.tuxguitar.song.models.effects.TremoloBarEffect;
20
import org.herac.tuxguitar.song.models.effects.TremoloPickingEffect;
21
import org.herac.tuxguitar.song.models.effects.TrillEffect;
23
public class MeasureManager {
24
private SongManager songManager;
26
public MeasureManager(SongManager songManager){
27
this.songManager = songManager;
30
public void orderNotes(Measure measure){
31
for(int i = 0;i < measure.getNotes().size();i++){
33
for(int noteIdx = i;noteIdx < measure.getNotes().size();noteIdx++){
34
Note note = (Note)measure.getNotes().get(noteIdx);
35
if(minNote == null || note.getStart() < minNote.getStart()){
39
measure.getNotes().remove(minNote);
40
measure.getNotes().add(i,minNote);
44
public void addNote(Measure measure,Note note){
45
//Verifico si entra en el compas
46
if(canInsert(measure,note,true,false)){
47
//Borro lo que haya en la misma posicion
48
removeComponentsAt(measure,note.getStart(),note.getString(),false);
51
measure.addNote(note);
53
//trato de agregar un silencio similar al lado
54
tryChangeSilenceAfter(measure,note);
59
public void removeNote(Measure measure,Note note){
60
measure.removeNote(note);
64
* Agrega un silencio al compas
66
public void addSilence(Measure measure,Silence silence){
67
//Verifico si entra en el compas
68
if(canInsert(measure,silence,true,false)){
69
//Borro lo que haya en la misma posicion
70
removeAllComponentsAt(measure,silence.getStart());
73
measure.addSilence(silence);
77
public void removeSilence(Measure measure,Silence silence){
78
measure.removeSilence(silence);
82
* Elimina un silencio del compas.
83
* si se asigna moveNextComponents = true. los componentes que le siguen
84
* se moveran para completar el espacio vacio que dejo el silencio
86
public void removeSilence(Measure measure,Silence silence,boolean moveNextComponents){
87
//TODO sacar el calculo de length con el nextComponent cuando en autosilences se agreguen tresillos
88
List components = getComponents(measure);
89
Component component = getComponent(components,silence.getStart());
90
Component nextComponent = getNextComponent(components,component);
93
removeSilence(measure,silence);
94
if(moveNextComponents){
95
long start = silence.getStart();
96
long length = silence.getDuration().getTime();
98
if(nextComponent != null){
99
length = nextComponent.getStart() - start;
102
moveComponents(measure,start + length,-length);
106
public void removeNotesAfterString(Measure measure,int string){
107
List notesToRemove = new ArrayList();
108
Iterator it = measure.getNotes().iterator();
110
Note note = (Note)it.next();
111
if(note.getString() > string){
112
notesToRemove.add(note);
115
it = notesToRemove.iterator();
117
Note note = (Note)it.next();
118
removeNote(measure,note);
123
* Retorna Todas las Notas en la posicion Start
125
public List getNotes(Measure measure,long start) {
126
List notes = new ArrayList();
127
Iterator it = measure.getNotes().iterator();
129
Note note = (Note)it.next();
130
if (note.getStart() == start) {
138
* Retorna las Nota en la posicion y cuerda
140
public Note getNote(Measure measure,long start,int string) {
141
Iterator it = measure.getNotes().iterator();
143
Note note = (Note)it.next();
144
if (note.getStart() == start && note.getString() == string) {
152
* Mueve todas las notas
154
public void moveAllNotes(Measure measure,long theMove){
155
moveComponents(measure.getNotes(),theMove);
159
* Mueve todos los silencios
161
public void moveAllSilences(Measure measure,long theMove){
162
moveComponents(measure.getSilences(),theMove);
166
* Mueve todos los componentes
168
public void moveAllComponents(Measure measure,long theMove){
169
moveComponents(getComponents(measure),theMove);
174
* Mueve los componentes ubicados en start
176
public boolean moveComponents(Measure measure,long start,long theMove){
177
//obtengo los datos del compas
178
long measureStart = measure.getStart();
179
long measureLength = measure.getLength();
181
//muevo los componentes
182
List components = getComponentsBeforeEnd(getComponents(measure),start);
183
moveComponents(components,theMove);
185
//si el compas no quedo correctamente vuelvo a dejar todo como estaba
186
Component first = getFirstComponent(getComponents(measure));
187
while(first instanceof Silence){
188
removeSilence(measure,(Silence)first);
189
first = getNextComponent(getComponents(measure),first);
191
Component last = getLastComponent(getComponents(measure));
192
while(last instanceof Silence){
193
removeSilence(measure,(Silence)last);
194
last = getPreviousComponent(getComponents(measure),last);
196
if(first != null && last != null){
197
if(first.getStart() < measureStart || (last.getStart() + last.getDuration().getTime()) > (measureStart + measureLength)){
198
moveComponents(components,-theMove);
206
* Mueve los componentes
208
private void moveComponents(List components,long theMove){
209
Iterator it = components.iterator();
211
Component component = (Component)it.next();
212
moveComponent(component,theMove);
217
* Mueve el componente
219
private void moveComponent(Component component,long theMove){
220
//obtengo el start viejo
221
long start = component.getStart();
223
//asigno el nuevo start
224
component.setStart(start + theMove);
228
* Retorna los silencios en la posicion start
230
public List getSilences(Measure measure,long start) {
231
List silences = new ArrayList();
232
for (int i = 0; i < measure.getSilences().size(); i++) {
233
Silence silence = (Silence) measure.getSilences().get(i);
234
if (silence.getStart() == start) {
235
silences.add(silence);
242
* Retorna el Siguiente Componente que sea de un silencio
244
public Silence getNextSilence(Measure measure,Component component) {
245
Silence nextSilence = null;
246
for (int i = 0; i < measure.getSilences().size(); i++) {
247
Silence currSilence = (Silence) measure.getSilences().get(i);
249
if (currSilence.getStart() > component.getStart()) {
250
if (nextSilence == null) {
251
nextSilence = currSilence;
252
} else if (currSilence.getStart() < nextSilence.getStart()) {
253
nextSilence = currSilence;
254
} else if (currSilence.getStart() == nextSilence.getStart()
255
&& currSilence.getDuration().getTime() <= nextSilence.getDuration().getTime()) {
256
nextSilence = currSilence;
264
public List getComponents(Measure measure){
265
List components = new ArrayList();
266
components.addAll(measure.getNotes());
267
components.addAll(measure.getSilences());
272
* Retorna el Siguiente Componente
274
public Component getNextComponent(List components,Component component) {
275
Component nextComponent = null;
276
for (int noteIdx = 0; noteIdx < components.size(); noteIdx++) {
277
Component currComponent = (Component) components.get(noteIdx);
279
if (currComponent.getStart() > component.getStart()) {
280
if (nextComponent == null) {
281
nextComponent = currComponent;
282
} else if (currComponent.getStart() < nextComponent.getStart()) {
283
nextComponent = currComponent;
284
} else if (currComponent.getStart() == nextComponent.getStart()
285
&& currComponent.getDuration().getTime() <= nextComponent.getDuration().getTime()) {
286
nextComponent = currComponent;
290
return nextComponent;
294
* Retorna el Componente Anterior
296
public Component getPreviousComponent(List components,Component component) {
297
Component prevComponent = null;
298
for (int noteIdx = 0; noteIdx < components.size(); noteIdx++) {
299
Component currComponent = (Component) components.get(noteIdx);
301
if (currComponent.getStart() < component.getStart()) {
302
if (prevComponent == null) {
303
prevComponent = currComponent;
304
} else if (currComponent.getStart() > prevComponent.getStart()) {
305
prevComponent = currComponent;
306
} else if (currComponent.getStart() == prevComponent.getStart()
307
&& currComponent.getDuration().getTime() <= prevComponent.getDuration().getTime()) {
308
prevComponent = currComponent;
312
return prevComponent;
316
* Retorna el Primer Componente
318
public Component getFirstComponent(List components) {
319
Component firstComponent = null;
320
for (int i = 0; i < components.size(); i++) {
321
Component currComponent = (Component) components.get(i);
322
if (firstComponent == null || currComponent.getStart() < firstComponent.getStart()) {
323
firstComponent = currComponent;
326
return firstComponent;
330
* Retorna el Ultimo Componente
332
public Component getLastComponent(List components) {
333
Component lastComponent = null;
334
for (int i = 0; i < components.size(); i++) {
335
Component currComponent = (Component) components.get(i);
336
if (lastComponent == null || lastComponent.getStart() < currComponent.getStart()) {
337
lastComponent = currComponent;
340
return lastComponent;
344
* Retorna los componentes en la posicion start
346
public List getComponents(List components,long start) {
347
List componentAtStart = new ArrayList();
348
for (int i = 0; i < components.size(); i++) {
349
Component currComponent = (Component) components.get(i);
350
if (currComponent.getStart() == start) {
351
componentAtStart.add(currComponent);
354
return componentAtStart;
358
* Retorna Un Componente en la posicion start
360
public Component getComponent(List components,long start) {
361
Component component = null;
362
for (int noteIdx = 0; noteIdx < components.size(); noteIdx++) {
363
Component currComponent = (Component) components.get(noteIdx);
364
if (currComponent.getStart() == start) {
365
component = currComponent;
373
* Retorna Todos los desde Start hasta el final del compas
375
public List getComponentsBeforeEnd(List components,long fromStart) {
376
List componentBeforeEnd = new ArrayList();
377
Iterator it = components.iterator();
379
Component currComponent = (Component)it.next();
380
if (currComponent.getStart() >= fromStart) {
381
componentBeforeEnd.add(currComponent);
384
return componentBeforeEnd;
388
* Retorna Un Componente diferente en el mismo beat
390
public Component getComponentAtSameBeat(List components,Component beatComponent) {
391
Component component = null;
392
for (int noteIdx = 0; noteIdx < components.size(); noteIdx++) {
393
Component currComponent = (Component) components.get(noteIdx);
394
if (currComponent.getStart() == beatComponent.getStart() && !currComponent.equals(beatComponent)) {
395
component = currComponent;
403
* Elimina los Componentes que empiecen en Start y esten en la misma cuerda
404
* Si hay un Silencio lo borra sin importar la cuerda
406
public void removeComponentsAt(Measure measure,long start,int string,boolean addSilence){
408
List notes = getNotes(measure,start);
409
Iterator it = notes.iterator();
411
Note note = (Note)it.next();
412
if(note.getString() == string){
413
removeNote(measure,note);
415
//si era el unico componente agrego un silencio
416
if(addSilence && notes.size() == 1){
417
addSilence(measure,new Silence(note.getStart(),(Duration)note.getDuration().clone()));
422
List silences = getSilences(measure,start);
424
Iterator it = silences.iterator();
426
Silence silence = (Silence)it.next();
427
removeSilence(measure,silence);
432
* Elimina todos los Componentes
434
public void removeAllComponents(Measure measure){
435
measure.getNotes().clear();
436
measure.getSilences().clear();
440
* Elimina los Componentes que empiecen en Start
442
public void removeAllComponentsAt(Measure measure,long start){
443
List notes = getNotes(measure,start);
444
Iterator it = notes.iterator();
446
Note note = (Note)it.next();
447
removeNote(measure,note);
450
List silences = getSilences(measure,start);
451
it = silences.iterator();
453
Silence silence = (Silence)it.next();
454
removeSilence(measure,silence);
458
public void orderComponents(List components){
459
for(int i = 0;i < components.size();i++){
460
Component minComponent = null;
461
for(int j = i;j < components.size();j++){
462
Component component = (Component)components.get(j);
463
if(minComponent == null || component.getStart() < minComponent.getStart()){
464
minComponent = component;
467
components.remove(minComponent);
468
components.add(i,minComponent);
473
public void transposeNotes(Measure measure,List strings,int transpose){
474
Iterator it = measure.getNotes().iterator();
476
Note note = (Note)it.next();
477
int value = note.getValue() + transpose;
478
int string = note.getString();
480
while(strings.size() > string){
481
InstrumentString current = (InstrumentString)strings.get((string - 1));
482
InstrumentString next = (InstrumentString)strings.get(string);
484
value += (current.getValue() - next.getValue());
491
note.setValue(value);
492
note.setString(string);
499
* Mueve la nota a la cuerda de arriba
501
public int shiftNoteUp(Measure measure,long start,int string){
502
return shiftNote(measure, start, string,-1);
506
* Mueve la nota a la cuerda de abajo
508
public int shiftNoteDown(Measure measure,long start,int string){
509
return shiftNote(measure, start, string,1);
513
* Mueve la nota a la siguiente cuerda
515
private int shiftNote(Measure measure,long start,int string,int move){
516
Note note = getNote(measure,start,string);
517
SongTrack track = this.songManager.getTrack(measure);
518
if(note != null && track != null){
519
int nextStringNumber = (note.getString() + move);
520
while(getNote(measure,start,nextStringNumber) != null){
521
nextStringNumber += move;
523
if(nextStringNumber >= 1 && nextStringNumber <= track.stringCount()){
524
InstrumentString currentString = track.getString(note.getString());
525
InstrumentString nextString = track.getString(nextStringNumber);
526
int noteValue = (note.getValue() + currentString.getValue());
527
if(noteValue >= nextString.getValue() && ((nextString.getValue() + 30 > noteValue) || track.isPercussionTrack()) ){
528
note.setValue(noteValue - nextString.getValue());
529
note.setString(nextString.getNumber());
530
return note.getString();
538
* Mueve la nota 1 semitono arriba
540
public boolean moveSemitoneUp(Measure measure,long start,int string){
541
return moveSemitone(measure, start, string,1);
545
* Mueve la nota 1 semitono abajo
547
public boolean moveSemitoneDown(Measure measure,long start,int string){
548
return moveSemitone(measure, start, string,-1);
552
* Mueve la nota los semitonos indicados
554
private boolean moveSemitone(Measure measure,long start,int string,int semitones){
555
Note note = getNote(measure,start,string);
556
SongTrack track = this.songManager.getTrack(measure);
557
if(note != null && track != null){
558
int newValue = (note.getValue() + semitones);
559
if(newValue >= 0 && (newValue < 30 || track.isPercussionTrack()) ){
560
note.setValue(newValue);
568
* Verifica si el componente se puede insertar en el compas.
569
* si no puede, con la opcion removeSilences, verifica si el motivo por el
570
* cual no entra es que lo siguen silencios. de ser asi los borra.
572
public boolean canInsert(Measure measure,Component component,boolean removeSilences,boolean tryMove){
573
boolean canInsert = true;
574
int errorMargin = 10;
576
List components = getComponents(measure);
577
orderComponents(components);
579
//Si es una nota, Verifico si hay un componente en el mismo lugar, y comparo las duraciones.
580
if(component instanceof Note){
581
Component componentAtBeat = getComponentAtSameBeat(components,component);
582
if(componentAtBeat instanceof Note){
583
if(component.getDuration().getTime() <= componentAtBeat.getDuration().getTime()){
589
//Verifico si hay lugar para meter la nota-----------------
590
Component nextComponent = getNextComponent(components,component);
591
//si el componente es null, verifico el fin del compas
593
long componentEnd = component.getStart() + component.getDuration().getTime();
594
if(nextComponent == null){
595
if(componentEnd > (measure.getStart() + measure.getLength() + errorMargin)){
598
}else if(componentEnd > (nextComponent.getStart() + errorMargin)){
602
//---Busca si hay espacio disponible de silencios entre el componente y el el que le sigue.. si encuentra lo borra
603
if(removeSilences && !canInsert && nextComponent instanceof Silence){
604
//Verifico si lo que sigue es un silencio. y lo borro
605
long nextComponentEnd = 0;
606
List nextSilences = new ArrayList();
607
while(nextComponent instanceof Silence){
608
nextSilences.add(nextComponent);
609
nextComponentEnd = nextComponent.getStart() + nextComponent.getDuration().getTime();
610
nextComponent = getNextComponent(components,nextComponent);
612
if(nextComponent == null){
613
nextComponentEnd = measure.getStart() + measure.getLength();
614
}else if(nextComponent instanceof Note){
615
nextComponentEnd = nextComponent.getStart();
617
if(componentEnd <= (nextComponentEnd + errorMargin)){
618
while(!nextSilences.isEmpty()){
619
Silence currSilence = (Silence)nextSilences.get(0);
620
measure.removeSilence(currSilence);
621
nextSilences.remove(currSilence);
627
//---Busca si hay espacio disponible de silencios entre el componente y el final.. si encuentra mueve todo
628
if(!canInsert && removeSilences && tryMove){
629
nextComponent = getNextComponent(components,component);
630
if(nextComponent != null){
631
long requiredLength = (component.getDuration().getTime() - (nextComponent.getStart() - component.getStart()));
634
long nextSilenceLength = 0;
635
List nextSilences = new ArrayList();
636
Silence nextSilence = getNextSilence(measure,component);
637
while(nextSilence != null){
638
nextSilences.add(nextSilence);
639
nextSilenceLength += nextSilence.getDuration().getTime();
640
nextSilence = getNextSilence(measure,nextSilence);
642
if(requiredLength <= (nextSilenceLength + errorMargin)){
643
components = getComponentsBeforeEnd(components,nextComponent.getStart());
644
while(!components.isEmpty()){
645
Component currComponent = (Component)components.get(0);
646
if(currComponent instanceof Silence){
647
Silence currSilence = (Silence)currComponent;
648
requiredLength -= currSilence.getDuration().getTime();
649
measure.removeSilence(currSilence);
650
}else if(requiredLength > 0){
651
moveComponent(currComponent,requiredLength);
655
components.remove(0);
668
* Cambia la Duracion del componente.
670
public void changeDuration(Measure measure,Component component,Duration duration){
671
changeDuration(measure,component,duration,true);
675
* Cambia la Duracion del componente.
677
public void changeDuration(Measure measure,Component component,Duration duration,boolean tryMove){
678
//obtengo la duracion vieja
679
Duration oldDuration = (Duration)component.getDuration().clone();
681
//asigno la nueva duracion
682
component.setDuration((Duration)duration.clone());
684
//si no entra vuelvo a dejar la vieja
685
//if(canInsert(measure,component,true,true)){
686
if(canInsert(measure,component,true,tryMove)){
687
//se lo agrego a todas las notas en la posicion
688
List components = getNotes(measure,component.getStart());
689
Iterator it = components.iterator();
691
Component currComponent = (Component)it.next();
692
currComponent.setDuration((Duration)duration.clone());
695
//trato de agregar un silencio similar al lado
696
boolean move = (component.getDuration().getTime() > oldDuration.getTime());
697
tryChangeSilenceAfter(measure,component,move);
700
component.setDuration(oldDuration);
706
public void tryChangeSilenceAfter(Measure measure,Component component){
707
tryChangeSilenceAfter(measure,component,true);
710
public void tryChangeSilenceAfter(Measure measure,Component component,boolean tryMove){
711
List components = getComponents(measure);
712
autoCompleteSilences(measure,components);
713
Component nextComponent = getNextComponent(getComponents(measure),component);
715
long componentEnd = (component.getStart() + component.getDuration().getTime());
716
long measureEnd = (measure.getStart() + measure.getLength());
717
if(nextComponent instanceof Silence && componentEnd <= measureEnd){
719
long theMove = (getRealStart(measure,componentEnd)) - getRealStart(measure,nextComponent.getStart());
720
//long theMove = (componentEnd - nextComponent.getStart());
722
if((nextComponent.getStart() + theMove) < measureEnd && (nextComponent.getStart() + nextComponent.getDuration().getTime() + theMove) <= measureEnd){
723
moveComponent(nextComponent,theMove);
724
changeDuration(measure,nextComponent,(Duration)component.getDuration().clone(),tryMove);
729
public void autoCompleteSilences(Measure measure){
730
autoCompleteSilences(measure,getComponents(measure));
734
* Calcula si hay espacios libres. y crea nuevos silencios
736
public void autoCompleteSilences(Measure measure,List components){
738
long start = measure.getStart();
741
Component component = getFirstComponent(components);
743
while (component != null) {
744
end = component.getStart() + component.getDuration().getTime();
745
if(component.getStart() > start){
746
diff = component.getStart() - start;
748
createSilences(measure,start,diff);
752
component = getNextComponent(components,component);
754
end = measure.getStart() + measure.getLength();
757
createSilences(measure,start,diff);
762
* Crea Silencios temporarios en base a length
764
public void createSilences(Measure measure,long start,long length){
765
List durations = TablatureUtil.createDurations(length);
766
Iterator it = durations.iterator();
768
Duration duration = (Duration)it.next();
769
Silence silence = new Silence(start,duration);
770
addSilence(measure,silence);
771
start += duration.getTime();
776
public long getRealStart(Measure measure,long currStart){
777
long beatLength = TablatureUtil.getBeatLength(measure.getTimeSignature());
778
long start = currStart;
780
boolean startBeat = (start % beatLength == 0);
784
Duration minDuration = new Duration(Duration.SIXTY_FOURTH,false,false,new Tupleto(3,2));
785
for(int i = 0;i < minDuration.getTime();i++){
787
startBeat = (start % beatLength == 0);
801
public boolean areInSameBeat(Measure measure,Component arg0,Component arg1){
802
long measureEnd = measure.getStart() + measure.getLength();
803
long beatLength = TablatureUtil.getBeatLength(measure.getTimeSignature());
804
long start1 = getRealStart(measure,arg0.getStart());
805
long start2 = getRealStart(measure,arg1.getStart());
807
long currStart = measure.getStart();
810
boolean finish = false;
812
if(start1 >= currStart && start1 < currStart + beatLength && start2 >= currStart && start2 < currStart + beatLength){
815
currStart += beatLength;
816
if(currStart > measureEnd){
828
public void changeTieNote(Measure measure,long start,int string){
829
Note note = getNote(measure,start,string);
838
public void changeTieNote(Note note){
839
note.setTiedNote(!note.isTiedNote());
840
note.getEffect().setDeadNote(false);
848
public void changeVibratoNote(Measure measure,long start,int string){
849
Note note = getNote(measure,start,string);
851
note.getEffect().setVibrato(!note.getEffect().isVibrato());
856
* Agrega una nota muerta
858
public void changeDeadNote(Note note){
859
//note.getEffect().set(note.getEffect().isVibrato(),null,!note.getEffect().isDeadNote(),false,false);
860
note.getEffect().setDeadNote(!note.getEffect().isDeadNote());
861
note.setTiedNote(false);
867
public void changeSlideNote(Measure measure,long start,int string){
868
Note note = getNote(measure,start,string);
870
note.getEffect().setSlide(!note.getEffect().isSlide());
871
//note.getEffect().set(note.getEffect().isVibrato(),null,false,!note.getEffect().isSlide(),false);
879
public void changeHammerNote(Measure measure,long start,int string){
880
Note note = getNote(measure,start,string);
882
note.getEffect().setHammer(!note.getEffect().isHammer());
883
//note.getEffect().set(note.getEffect().isVibrato(),null,false,false,!note.getEffect().isHammer());
889
* Agrega un palm-mute
891
public void changePalmMute(Measure measure,long start,int string){
892
Note note = getNote(measure,start,string);
894
note.getEffect().setPalmMute(!note.getEffect().isPalmMute());
901
public void changeStaccato(Measure measure,long start,int string){
902
Note note = getNote(measure,start,string);
904
note.getEffect().setStaccato(!note.getEffect().isStaccato());
911
public void changeTapping(Measure measure,long start,int string){
912
Note note = getNote(measure,start,string);
914
note.getEffect().setTapping(!note.getEffect().isTapping());
921
public void changeSlapping(Measure measure,long start,int string){
922
Note note = getNote(measure,start,string);
924
note.getEffect().setSlapping(!note.getEffect().isSlapping());
931
public void changePopping(Measure measure,long start,int string){
932
Note note = getNote(measure,start,string);
934
note.getEffect().setPopping(!note.getEffect().isPopping());
941
public void changeBendNote(Measure measure,long start,int string,BendEffect bend){
942
Note note = getNote(measure,start,string);
944
note.getEffect().setBend(bend);
950
* Agrega un tremoloBar
952
public void changeTremoloBar(Measure measure,long start,int string,TremoloBarEffect tremoloBar){
953
Note note = getNote(measure,start,string);
955
note.getEffect().setTremoloBar(tremoloBar);
960
* Agrega un GhostNote
962
public void changeGhostNote(Measure measure,long start,int string){
963
Note note = getNote(measure,start,string);
965
note.getEffect().setGhostNote(!note.getEffect().isGhostNote());
971
* Agrega un AccentuatedNote
973
public void changeAccentuatedNote(Measure measure,long start,int string){
974
Note note = getNote(measure,start,string);
976
note.getEffect().setAccentuatedNote(!note.getEffect().isAccentuatedNote());
981
* Agrega un GhostNote
983
public void changeHeavyAccentuatedNote(Measure measure,long start,int string){
984
Note note = getNote(measure,start,string);
986
note.getEffect().setHeavyAccentuatedNote(!note.getEffect().isHeavyAccentuatedNote());
993
public void changeHarmonicNote(Measure measure,long start,int string,HarmonicEffect harmonic){
994
Note note = getNote(measure,start,string);
996
note.getEffect().setHarmonic(harmonic);
1003
public void changeGraceNote(Measure measure,long start,int string,GraceEffect grace){
1004
Note note = getNote(measure,start,string);
1006
note.getEffect().setGrace(grace);
1013
public void changeTrillNote(Measure measure,long start,int string,TrillEffect trill){
1014
Note note = getNote(measure,start,string);
1016
note.getEffect().setTrill(trill);
1021
* Agrega un tremolo picking
1023
public void changeTremoloPicking(Measure measure,long start,int string,TremoloPickingEffect tremoloPicking){
1024
Note note = getNote(measure,start,string);
1026
note.getEffect().setTremoloPicking(tremoloPicking);
1033
public void changeFadeIn(Measure measure,long start,int string){
1034
Note note = getNote(measure,start,string);
1036
note.getEffect().setFadeIn(!note.getEffect().isFadeIn());
1041
* Cambia el Velocity
1043
public void changeVelocity(int velocity,Measure measure,long start,int string){
1044
Note note = getNote(measure,start,string);
1046
note.setVelocity(velocity);
1050
public void calculateNoteStartWithRepetitions(Measure measure,long startMove) {
1051
for (int noteIdx = 0; noteIdx < measure.getNotes().size(); noteIdx++) {
1052
Note note = (Note) measure.getNotes().get(noteIdx);
1053
//asigno el start con repeticiones
1054
note.setStartWithRepetitions(note.getStart() + startMove);