2
* Created on 26-nov-2005
4
* TODO To change the template for this generated file go to
5
* Window - Preferences - Java - Code Style - Code Templates
7
package org.herac.tuxguitar.gui.editors.tab;
9
import java.util.ArrayList;
10
import java.util.Iterator;
11
import java.util.List;
13
import org.eclipse.swt.SWT;
14
import org.eclipse.swt.graphics.GC;
15
import org.eclipse.swt.graphics.Image;
16
import org.eclipse.swt.graphics.Rectangle;
17
import org.herac.tuxguitar.gui.SystemImages;
18
import org.herac.tuxguitar.gui.TuxGuitar;
19
import org.herac.tuxguitar.gui.editors.tab.layout.TrackSpacing;
20
import org.herac.tuxguitar.gui.editors.tab.layout.ViewLayout;
21
import org.herac.tuxguitar.song.managers.SongManager;
22
import org.herac.tuxguitar.song.models.Component;
23
import org.herac.tuxguitar.song.models.Duration;
24
import org.herac.tuxguitar.song.models.InstrumentString;
25
import org.herac.tuxguitar.song.models.Measure;
26
import org.herac.tuxguitar.song.models.Note;
27
import org.herac.tuxguitar.song.models.NoteEffect;
28
import org.herac.tuxguitar.song.models.Silence;
32
* TODO To change the template for this generated type comment go to Window - Preferences - Java - Code Style - Code Templates
34
public class MeasureCoords {
36
public static final int SCORE_KEY_OFFSETS[] = new int[]{30,18,22,24};
38
private static final int SCORE_NATURAL_POSITIONS[] = new int[]{7,7,6,6,5,4,4,3,3,2,2,1};
40
* Espacio por defecto de la clave
42
public static final int DEFAULT_CLEF_SPAN = 40;
44
* Espacio por defecto entre negra y negra
46
public static final int DEFAULT_QUARTER_SPAN = 30;
49
* Widget de la tablatura
51
private Tablature tablature;
55
private MeasureHeaderGui header;
65
* Espacio entre negras
67
private int quarterSpan;
69
* Espacio entre pulsos
71
private long beatLength;
73
* Boolean para saber si hay que pintar la clave
75
private boolean paintClef = true;
77
* Boolean para saber si hay que pintar el KeySignature
79
private boolean paintKeySignature = true;
81
* Coordenadas de notas
83
private List measureComponents;
85
* Compas de Referencia
87
private Measure measure;
91
private Measure prevMeasure;
95
private SongTrackCoords trackCoords;
99
private SongManager songManager;
101
* Boolean para saber si el compas esta en el area de pantalla
103
private boolean outOfBounds;
105
* Boolean para saber si el compas es el primero de la linea
107
private boolean firstOfLine;
109
private Rectangle clefSrcBounds;
111
private Rectangle clefDstBounds;
115
private TrackSpacing ts;
121
private List timeHelpers;
122
private List beatPositions;
123
private CacheImage cache;
124
private boolean cacheEnabled;
126
private int lastEffectSpan;
128
private int lyricBeatIndex;
130
private boolean accentuated;
131
private boolean harmonic;
132
private boolean tapping;
133
private boolean palmMute;
134
private boolean vibrato;
135
private boolean tupleto;
136
private boolean fadeIn;
138
public MeasureCoords(SongManager songManager,Tablature tablature,MeasureHeaderGui header,Measure measure, SongTrackCoords trackCoords) {
139
this.measure = measure;
140
this.header = header;
141
this.trackCoords = trackCoords;
142
this.tablature = tablature;
143
this.songManager = songManager;
144
this.measureComponents = new ArrayList();
145
this.beatPositions = new ArrayList();
146
this.timeHelpers = new ArrayList();
147
this.cache = new CacheImage(tablature.getDisplay());
152
* Crea los valores necesarios
154
public void create(ViewLayout layout) {
155
this.measureComponents.clear();
156
this.beatLength = TablatureUtil.getBeatLength(getMeasure().getTimeSignature());
157
autoCompleteSilences();
158
calculateQuarterSpan(layout);
159
calculateMeasureChanges(layout);
160
this.header.notifyQuarterSpan(getQuarterSpan());
165
* Actualiza los valores para dibujar
167
public void update(ViewLayout layout) {
168
this.setQuarterSpan(this.header.getMaxQuarterSpan());
171
calculateClefBounds(layout);
172
calcuateComponents(layout);
173
updateComponents(layout);
175
setOutOfBounds(true);
176
setCacheEnabled(false);
180
* Calcula el espacio que debe haber entre negras
182
private void calculateQuarterSpan(ViewLayout layout) {
183
if (measure.getNotes().isEmpty() && measure.getSilences().isEmpty()) {
184
this.quarterSpan = DEFAULT_QUARTER_SPAN;
186
Duration minDuration = null;
187
if(!measure.getNotes().isEmpty()){
189
for (int noteIdx = 0; noteIdx < measure.getNotes().size(); noteIdx++) {
190
Note currentNote = (Note) measure.getNotes().get(noteIdx);
192
if (minNote == null || currentNote.getDuration().getTime() <= minNote.getDuration().getTime()) {
193
minNote = currentNote;
196
minDuration = minNote.getDuration();
198
if(!measure.getSilences().isEmpty()){
199
Silence minSilence = null;
200
for (int silenceIdx = 0; silenceIdx < measure.getSilences().size(); silenceIdx++) {
201
Silence currentSilence = (Silence) measure.getSilences().get(silenceIdx);
203
if (minSilence == null || currentSilence.getDuration().getTime() <= minSilence.getDuration().getTime()) {
204
minSilence = currentSilence;
208
if(minDuration == null || minSilence.getDuration().getTime() <= minDuration.getTime()){
209
minDuration = minSilence.getDuration();
212
this.quarterSpan = layout.getSpanForQuarter(minDuration);
218
* Calcula si debe pintar el TimeSignature
221
public void calculateMeasureChanges(ViewLayout layout) {
222
this.paintClef = false;
223
this.paintKeySignature = false;
224
if(layout.isScoreEnabled()){
225
MeasureCoords prevMeasureCoords = null;
226
if(!layout.isFirstMeasure(getMeasure())){
227
prevMeasureCoords = this.trackCoords.getPrevMeasure(this);
228
if(prevMeasureCoords != null){
229
this.prevMeasure = prevMeasureCoords.getMeasure();
232
if(this.prevMeasure == null || getMeasure().getClef() != this.prevMeasure.getClef()){
233
this.paintClef = true;
234
this.header.notifyClefSpan(DEFAULT_CLEF_SPAN);
237
if(this.prevMeasure == null || getMeasure().getKeySignature() != this.prevMeasure.getKeySignature()){
238
this.paintKeySignature = true;
239
this.header.notifyKeySignatureSpan(calculateKeySignatureSpan());
244
private void calculateClefBounds(ViewLayout layout){
246
if(measure.getClef() == Measure.CLEF_TREBLE){
247
clefSrcBounds = SystemImages.CLEF_TREBLE.getBounds();
248
}else if(measure.getClef() == Measure.CLEF_BASS){
249
clefSrcBounds = SystemImages.CLEF_BASS.getBounds();
250
}else if(measure.getClef() == Measure.CLEF_TENOR){
251
clefSrcBounds = SystemImages.CLEF_TENOR.getBounds();
252
}else if(measure.getClef() == Measure.CLEF_ALTO){
253
clefSrcBounds = SystemImages.CLEF_ALTO.getBounds();
255
clefDstBounds = new Rectangle(clefSrcBounds.x,clefSrcBounds.y,clefSrcBounds.width,(layout.getScoreLineSpan() * clefSrcBounds.height / 10));
260
* Calcula las coordenadas de los componentes
262
private void calcuateComponents(ViewLayout layout){
263
this.measureComponents.clear();
264
calculateComponentsCoords(layout);
268
* Calcula las coordenadas de las notas y silencios
270
private void calculateComponentsCoords(ViewLayout layout) {
273
int span = header.getFirstNoteSpan();
274
//---------------------------------Notas-------------------------------------
275
for (int noteIdx = 0; noteIdx < measure.getNotes().size(); noteIdx++) {
276
Note note = (Note) measure.getNotes().get(noteIdx);
277
posY = ((note.getString() * layout.getStringSpan()) - layout.getStringSpan());
278
posX = (TablatureUtil.getStartPosition(measure, note.getStart(), this.quarterSpan) + 10);
279
measureComponents.add(new NoteCoords(this.tablature,this.trackCoords,this, note, posX + span, posY));
281
//---------------------------------Silencios---------------------------------
282
for (int silenceIdx = 0; silenceIdx < measure.getSilences().size(); silenceIdx++) {
283
Silence silence = (Silence) measure.getSilences().get(silenceIdx);
284
posX = TablatureUtil.getStartPosition(measure, silence.getStart(), this.quarterSpan) + 10;
285
measureComponents.add(new SilenceCoords(this.tablature,this,silence,posX + span));
290
* Calcula si hay espacios libres. y crea nuevos silencios
292
private void autoCompleteSilences(){
293
songManager.getMeasureManager().autoCompleteSilences(measure);
297
* Llama a update de todas las notas del compas
299
private void updateComponents(ViewLayout layout) {
300
this.beatPositions.clear();
301
this.timeHelpers.clear();
304
MeasureTimeHelper timeHelper = null;
305
BeatPosition beat = null;
306
NoteCoords prevNote = null;
308
Iterator components = measureComponents.iterator();
309
while (components.hasNext()) {
310
MeasureComponent component = (MeasureComponent) components.next();
311
if(component instanceof NoteCoords){
312
NoteCoords note = (NoteCoords)component;
314
if(prevNote == null || !areInSameBeat(prevNote,component)){
315
timeHelper = new MeasureTimeHelper();
316
timeHelpers.add(timeHelper);
318
if(prevNote == null || component.getStart() != prevNote.getStart()){
319
beat = new BeatPosition(note.getStart(),note.getDuration(),note.getPosX());
320
beatPositions.add(beat);
322
checkEffects(layout,note.getNote().getEffect());
323
beat.checkValues(note);
324
timeHelper.check(note,getMeasure().getClef());
325
note.setMeasureTimeHelper(timeHelper);
328
if(!component.getDuration().getTupleto().isEqual(Duration.NO_TUPLETO)){
331
component.update(layout);
334
if(ViewLayout.AUTO_SPACING_ENABLED){
335
Iterator beats = timeHelpers.iterator();
336
while (beats.hasNext()) {
337
MeasureTimeHelper helper = (MeasureTimeHelper)beats.next();
338
checkValue(helper.getMinNote(),helper.getDirection());
339
checkValue(helper.getMaxNote(),helper.getDirection());
344
private void checkValue(NoteCoords note,int direction){
345
int y = note.getScorePosY();
347
if(direction == MeasureTimeHelper.DIRECTION_UP && y > this.maxY ){
349
}else if(direction == MeasureTimeHelper.DIRECTION_DOWN && (y + MeasureTimeHelper.DOWN_OFFSET) > this.maxY ){
350
this.maxY = (y + MeasureTimeHelper.DOWN_OFFSET + 2);
353
if(direction == MeasureTimeHelper.DIRECTION_UP && (y - MeasureTimeHelper.UP_OFFSET) < this.minY ){
354
this.minY = (y - MeasureTimeHelper.UP_OFFSET - 2);
355
}else if(direction == MeasureTimeHelper.DIRECTION_DOWN && y < this.minY ){
360
private void checkEffects(ViewLayout layout,NoteEffect effect){
361
if(effect.isAccentuatedNote() || effect.isHeavyAccentuatedNote()){
362
this.accentuated = true;
364
if(effect.isHarmonic() && !layout.isScoreEnabled()){
365
this.harmonic = true;
367
if(effect.isTapping() || effect.isSlapping() || effect.isPopping()){
370
if(effect.isPalmMute()){
371
this.palmMute = true;
373
if(effect.isFadeIn()){
376
if(effect.isVibrato() || effect.isTrill()){
381
private void resetEffects(){
382
this.tupleto = false;
383
this.accentuated = false;
384
this.harmonic = false;
385
this.tapping = false;
386
this.palmMute = false;
388
this.vibrato = false;
391
public void registerEffects(TrackSpacing ts){
393
ts.setSize(TrackSpacing.POSITION_TUPLETO,10);
395
if(this.accentuated){
396
ts.setSize(TrackSpacing.POSITION_ACCENTUATED_EFFECT,ViewLayout.DEFAULT_EFFECT_SPAN);
399
ts.setSize(TrackSpacing.POSITION_HARMONIC_EFFEC,ViewLayout.DEFAULT_EFFECT_SPAN);
402
ts.setSize(TrackSpacing.POSITION_TAPPING_EFFEC,ViewLayout.DEFAULT_EFFECT_SPAN);
405
ts.setSize(TrackSpacing.POSITION_PALM_MUTE_EFFEC,ViewLayout.DEFAULT_EFFECT_SPAN);
408
ts.setSize(TrackSpacing.POSITION_FADE_IN,ViewLayout.DEFAULT_EFFECT_SPAN);
411
ts.setSize(TrackSpacing.POSITION_VIBRATO_EFFEC,ViewLayout.DEFAULT_EFFECT_SPAN);
415
private void orderNotes(){
416
songManager.getMeasureManager().orderNotes(measure);
419
private void orderComponents(){
420
for(int i = 0;i < measureComponents.size();i++){
421
MeasureComponent minComponent = null;
422
for(int j = i;j < measureComponents.size();j++){
423
MeasureComponent component = (MeasureComponent)measureComponents.get(j);
424
if(minComponent == null || component.getStart() < minComponent.getStart()){
425
minComponent = component;
428
measureComponents.remove(minComponent);
429
measureComponents.add(i,minComponent);
433
public void paintMeasure(ViewLayout layout,GC eventGC,Rectangle clientArea) {
434
setOutOfBounds(false);
436
cache.setSize(getWidth() + getSpan(),getTs().getSize());
437
GC gc = cache.getGC();
439
layout.setDefaultStyle(gc);
440
layout.paintLines(trackCoords,getTs(),gc,0,0, getWidth() + getSpan());
442
paintTimeSignature(layout,gc);
443
paintClef(layout,gc);
444
paintKeySignature(layout,gc);
445
paintComponents(layout,gc,clientArea);
447
setCacheEnabled(true);
449
this.cache.paintImage(eventGC,getPosX(),getPosY());
451
layout.setDefaultStyle(eventGC);
452
eventGC.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_BLACK));
454
this.paintTempo(layout,eventGC);
455
this.paintTripletFeel(layout,eventGC);
456
this.paintDivisions(layout,eventGC);
457
this.paintPlayMode(layout,eventGC);
460
private boolean shouldRepaint(){
461
return (isDisposed() || !isCacheEnabled());
468
public void paintComponents(ViewLayout layout,GC gc,Rectangle clientArea) {
471
if(layout.isScoreEnabled()){
472
for(int i = 0; i < beatPositions.size(); i++){
473
BeatPosition beat = (BeatPosition)beatPositions.get(i);
474
beat.paintExtraLines(gc, layout);
477
for (int i = 0; i < measureComponents.size(); i++) {
478
MeasureComponent component = (MeasureComponent) measureComponents.get(i);
479
component.paint(layout,gc,MeasureHeaderGui.DEFAULT_LEFT_SPAN ,0);
486
* Pinta las divisiones del compas
488
private void paintDivisions(ViewLayout layout,GC gc) {
489
//-----SCORE ------------------------------------//
490
if(layout.isScoreEnabled()){
491
int scoreY1 = getPosY() + getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
492
int scoreY2 = scoreY1 + (layout.getScoreLineSpan() * 4);
493
int offsetY = scoreY2;
494
if(layout.isTablatureEnabled() && (layout.isFirstMeasure(getMeasure()) || isFirstOfLine())){
495
offsetY = getPosY() + ts.getPosition(TrackSpacing.POSITION_TABLATURE);
499
String number = Integer.toString(measure.getNumber());
500
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_RED));
501
gc.drawString(number,getPosX() + 1,scoreY1 - (gc.stringExtent(number).y));
502
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_BLACK));
505
if(measure.isRepeatStart()){
507
gc.drawLine(getPosX(), scoreY1, getPosX(), offsetY + 1);
509
gc.drawOval(getPosX() + 7, scoreY1 + ((scoreY2 - scoreY1) / 2) - 7,1,2);
510
gc.drawOval(getPosX() + 7, scoreY1 + ((scoreY2 - scoreY1) / 2) + 7,1,2);
513
gc.drawLine(getPosX() + 3, scoreY1, getPosX() + 3, offsetY);
514
}else if(layout.isFirstMeasure(getMeasure())){
516
gc.drawLine(getPosX(), scoreY1, getPosX(), offsetY + 1);
518
gc.drawLine(getPosX() + 3, scoreY1, getPosX() + 3, offsetY);
520
gc.drawLine(getPosX(), scoreY1, getPosX(), offsetY);
524
if(measure.getNumberOfRepetitions() > 0){
526
gc.drawLine(getPosX() + getWidth() - 1 + getSpan(), scoreY1, getPosX() + getWidth() - 1 + getSpan(), scoreY2 + 1);
528
gc.drawOval(getPosX() + getWidth() -9 + getSpan(), scoreY1 + ((scoreY2 - scoreY1) / 2) - 7,1,2);
529
gc.drawOval(getPosX() + getWidth() -9 + getSpan(), scoreY1 + ((scoreY2 - scoreY1) / 2) + 7,1,2);
532
gc.drawLine(getPosX() + getWidth() - 4 + getSpan(), scoreY1, getPosX() + getWidth() - 4 + getSpan(), scoreY2);
534
String repetitions = "x" + Integer.toString(measure.getNumberOfRepetitions());
535
gc.drawString(repetitions,getPosX() + getWidth() - gc.stringExtent(repetitions).x + getSpan(),scoreY1 - gc.stringExtent(repetitions).y);
536
}else if(layout.isLastMeasure(getMeasure())){
538
gc.drawLine(getPosX() + getWidth() + getSpan(), scoreY1, getPosX() + getWidth() + getSpan(), scoreY2 + 1);
540
gc.drawLine(getPosX() + getWidth() - 3 + getSpan(), scoreY1, getPosX() + getWidth() - 3 + getSpan(), scoreY2);
542
gc.drawLine(getPosX() + getWidth() + getSpan(), scoreY1, getPosX() + getWidth() + getSpan(), scoreY2);
548
//-----TABLATURE ------------------------------------//
549
if(layout.isTablatureEnabled()){
550
int y1 = getPosY() + ts.getPosition(TrackSpacing.POSITION_TABLATURE);
551
int y2 = y1 + ((trackCoords.getTrack().getStrings().size() - 1 ) * layout.getStringSpan());
554
if(!layout.isScoreEnabled()){
555
String number = Integer.toString(measure.getNumber());
556
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_RED));
557
gc.drawString(number,getPosX() + 1,y1 - (gc.stringExtent(number).y));
558
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_BLACK));
562
if(measure.isRepeatStart()){
564
gc.drawLine(getPosX(), y1, getPosX(), y2 + 1);
566
gc.drawOval(getPosX() + 7, y1 + ((y2 - y1) / 2) - 7,1,2);
567
gc.drawOval(getPosX() + 7, y1 + ((y2 - y1) / 2) + 7,1,2);
570
gc.drawLine(getPosX() + 3, y1, getPosX() + 3, y2);
571
}else if(layout.isFirstMeasure(getMeasure())){
573
gc.drawLine(getPosX(), y1, getPosX(), y2 + 1);
575
gc.drawLine(getPosX() + 3, y1, getPosX() + 3, y2);
577
gc.drawLine(getPosX(), y1, getPosX(), y2);
581
if(measure.getNumberOfRepetitions() > 0){
583
gc.drawLine(getPosX() + getWidth() - 1 + getSpan(), y1, getPosX() + getWidth() - 1 + getSpan(), y2 + 1);
585
gc.drawOval(getPosX() + getWidth() -9 + getSpan(), y1 + ((y2 - y1) / 2) - 7,1,2);
586
gc.drawOval(getPosX() + getWidth() -9 + getSpan(), y1 + ((y2 - y1) / 2) + 7,1,2);
589
gc.drawLine(getPosX() + getWidth() - 4 + getSpan(), y1, getPosX() + getWidth() - 4 + getSpan(), y2);
591
if(!layout.isScoreEnabled()){
592
String repetitions = "x" + Integer.toString(measure.getNumberOfRepetitions());
593
gc.drawString(repetitions,getPosX() + getWidth() - gc.stringExtent(repetitions).x + getSpan(),y1 - gc.stringExtent(repetitions).y);
595
}else if(layout.isLastMeasure(getMeasure())){
597
gc.drawLine(getPosX() + getWidth() + getSpan(), y1, getPosX() + getWidth() + getSpan(), y2 + 1);
599
gc.drawLine(getPosX() + getWidth() - 3 + getSpan(), y1, getPosX() + getWidth() - 3 + getSpan(), y2);
601
gc.drawLine(getPosX() + getWidth() + getSpan(), y1, getPosX() + getWidth() + getSpan(), y2);
612
private void paintClef(ViewLayout layout,GC gc) {
613
//-----SCORE ------------------------------------//
614
if(layout.isScoreEnabled() && this.paintClef){
616
int y = getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
617
if(measure.getClef() == Measure.CLEF_TREBLE){
618
gc.drawImage(SystemImages.CLEF_TREBLE,0,0,clefSrcBounds.width,clefSrcBounds.height,x,y - 8,clefDstBounds.width,clefDstBounds.height);
620
else if(measure.getClef() == Measure.CLEF_BASS){
621
gc.drawImage(SystemImages.CLEF_BASS,0,0,clefSrcBounds.width,clefSrcBounds.height,x,y - 2,clefDstBounds.width,clefDstBounds.height);
623
else if(measure.getClef() == Measure.CLEF_TENOR){
624
gc.drawImage(SystemImages.CLEF_TENOR,0,0,clefSrcBounds.width,clefSrcBounds.height,x,y - 9,clefDstBounds.width,clefDstBounds.height);
626
else if(measure.getClef() == Measure.CLEF_ALTO){
627
gc.drawImage(SystemImages.CLEF_ALTO,0,0,clefSrcBounds.width,clefSrcBounds.height,x,y - 1,clefDstBounds.width,clefDstBounds.height);
633
* Pinta la Armadura de Clave
635
private void paintKeySignature(ViewLayout layout,GC gc) {
636
if(layout.isScoreEnabled() && this.paintKeySignature){
637
int x = header.getClefSpan() + 10;
638
int y = getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
639
double scale = (layout.getScoreLineSpan() / 2);
640
double minY = y - scale;
642
double clefOffset = 0;
643
switch(measure.getClef()){
644
case Measure.CLEF_TREBLE:
647
case Measure.CLEF_BASS:
650
case Measure.CLEF_TENOR:
653
case Measure.CLEF_ALTO:
659
if(measure.getKeySignature() >= 1 && measure.getKeySignature() <= 7){
662
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,1 + (int)clefOffset,minY,6);
663
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 1 && prevMeasure.getKeySignature() <=7){
666
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,1 + (int)clefOffset,minY,9);
669
if(measure.getKeySignature() >= 2 && measure.getKeySignature() <= 7){
672
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,4 + (int)clefOffset,minY,6);
673
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 2 && prevMeasure.getKeySignature() <=7){
676
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,4 + (int)clefOffset,minY,9);
679
if(measure.getKeySignature() >= 3 && measure.getKeySignature() <= 7){
682
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,0 + (int)clefOffset,minY,6);
683
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 3 && prevMeasure.getKeySignature() <=7){
686
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,0 + (int)clefOffset,minY,9);
689
if(measure.getKeySignature() >= 4 && measure.getKeySignature() <= 7){
692
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,3 + (int)clefOffset,minY,6);
693
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 4 && prevMeasure.getKeySignature() <=7){
696
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,3 + (int)clefOffset,minY,9);
699
if(measure.getKeySignature() >= 5 && measure.getKeySignature() <= 7){
702
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,6 + (int)clefOffset,minY,6);
703
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 5 && prevMeasure.getKeySignature() <=7){
706
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,6 + (int)clefOffset,minY,9);
709
if(measure.getKeySignature() >= 6 && measure.getKeySignature() <= 7){
712
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,2 + (int)clefOffset,minY,6);
713
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 6 && prevMeasure.getKeySignature() <=7){
716
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,2 + (int)clefOffset,minY,9);
719
if(measure.getKeySignature() >= 7 && measure.getKeySignature() <= 7){
722
paintKeySignatureImage(gc,SystemImages.KEY_SHARP,x,y,scale,5 + (int)clefOffset,minY,6);
723
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 7 && prevMeasure.getKeySignature() <=7){
726
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,5 + (int)clefOffset,minY,9);
730
if(measure.getKeySignature() >= 1 + 7){
733
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,5 + (int)clefOffset,minY,6);
734
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 1 + 7){
737
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,5 + (int)clefOffset,minY,9);
740
if(measure.getKeySignature() >= 2 + 7){
743
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,2 + (int)clefOffset,minY,6);
744
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 2 + 7){
747
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,2 + (int)clefOffset,minY,9);
750
if(measure.getKeySignature() >= 3 + 7){
753
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,6 + (int)clefOffset,minY,6);
754
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 3 + 7){
757
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,6 + (int)clefOffset,minY,9);
760
if(measure.getKeySignature() >= 4 + 7){
763
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,3 + (int)clefOffset,minY,6);
764
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 4 + 7){
767
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,3 + (int)clefOffset,minY,9);
770
if(measure.getKeySignature() >= 5 + 7){
773
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,0 + (int)clefOffset,minY,6);
774
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 5 + 7){
777
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,0 + (int)clefOffset,minY,9);
780
if(measure.getKeySignature() >= 6 + 7){
783
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,4 + (int)clefOffset,minY,6);
784
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 6 + 7){
787
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,4 + (int)clefOffset,minY,9);
790
if(measure.getKeySignature() >= 7 + 7){
793
paintKeySignatureImage(gc,SystemImages.KEY_FLAT,x,y,scale,1 + (int)clefOffset,minY,6);
794
}else if(prevMeasure != null && prevMeasure.getKeySignature() >= 7 + 7){
797
paintKeySignatureImage(gc,SystemImages.KEY_NATURAL,x,y,scale,1 + (int)clefOffset,minY,9);
803
private void paintKeySignatureImage(GC gc,Image image,int x,int y,double scale,int position,double minY,int center){
804
int scoreLineY = (int)(y + ((scale * position) - scale) - center);
805
scoreLineY =(int) ((position < 0)?(scoreLineY + (scale * 7)):scoreLineY);
806
gc.drawImage(image,x,(int)scoreLineY);
809
private void paintTimeSignature(ViewLayout layout,GC gc){
810
if(this.header.shouldPaintTimeSignature()){
811
layout.setTimeSignatureStyle(gc);
812
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_BLACK));
814
int x = (header.getClefSpan() + header.getKeySignatureSpan() + MeasureHeaderGui.DEFAULT_LEFT_SPAN + 10);
815
String numerator = Integer.toString(getMeasure().getTimeSignature().getNumerator());
816
String denominator = Integer.toString(getMeasure().getTimeSignature().getDenominator().getValue());
817
if(layout.isScoreEnabled()){
818
int y = getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
820
int y2 = ((y + (layout.getScoreLineSpan() * 4)) - gc.stringExtent(denominator).y) + 3;
821
gc.drawString(numerator,x,y1,true);
822
gc.drawString(denominator,x,y2,true);
823
}else if(layout.isTablatureEnabled()){
824
int y = getTs().getPosition(TrackSpacing.POSITION_TABLATURE);
825
int move = (8 - trackCoords.getTrack().stringCount());
827
int y2 = ((y + trackCoords.getTabHeight()) - gc.stringExtent(denominator).y) + move;
828
gc.drawString(numerator,x,y1,true);
829
gc.drawString(denominator,x,y2,true);
831
layout.setDefaultStyle(gc);
836
private void paintTempo(ViewLayout layout,GC gc){
837
if(this.header.shouldPaintTempo()){
838
int x = (getPosX() + 15);
839
int y = (getPosY() - SystemImages.TEMPO_IMAGE.getBounds().height);
840
if(layout.isScoreEnabled()){
841
y += getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
842
}else if(layout.isTablatureEnabled()){
843
y += getTs().getPosition(TrackSpacing.POSITION_TABLATURE);
845
gc.setForeground(tablature.getDisplay().getSystemColor(SWT.COLOR_BLACK));
846
gc.drawImage(SystemImages.TEMPO_IMAGE,x - 5,y - 10);
847
gc.drawString(" = " + getMeasure().getTempo().getValue(),x + 10,y);
851
private void paintTripletFeel(ViewLayout layout,GC gc){
852
if(this.header.shouldPaintTripletFeel()){
853
int x = (getPosX() + header.getTempoSpan());
854
int y = (getPosY() - SystemImages.TEMPO_IMAGE.getBounds().height);
855
if(layout.isScoreEnabled()){
856
y += getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
857
}else if(layout.isTablatureEnabled()){
858
y += getTs().getPosition(TrackSpacing.POSITION_TABLATURE);
860
gc.drawImage(SystemImages.getTripletFeel(getMeasure().getTripletFeel()),x + 10,y - 13);
864
private void paintPlayMode(ViewLayout layout,GC gc){
865
if(layout.isPlayModeEnabled() && isPlaying()){
866
int width = getWidth() + getSpan();
871
if(layout.isScoreEnabled() && layout.isTablatureEnabled()){
872
y1 += (getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES) - layout.getScoreLineSpan());
873
y2 += (getTs().getPosition(TrackSpacing.POSITION_TABLATURE) + trackCoords.getTabHeight() + layout.getStringSpan());
874
}else if(layout.isScoreEnabled() && !layout.isTablatureEnabled()){
875
y1 += (getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES) - layout.getScoreLineSpan());
876
y2 += (getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES) + (layout.getStringSpan() * 5));
877
} else if(!layout.isScoreEnabled() && layout.isTablatureEnabled()){
878
y1 += (getTs().getPosition(TrackSpacing.POSITION_TABLATURE) - layout.getStringSpan());
879
y2 += (getTs().getPosition(TrackSpacing.POSITION_TABLATURE) + trackCoords.getTabHeight() + layout.getStringSpan());
882
gc.setLineStyle(SWT.LINE_DASH);
883
gc.drawRectangle(getPosX() + 5,y1,width - 10,(y2 - y1));
885
gc.setLineStyle(SWT.LINE_SOLID);
890
* Retorna true si se esta reproduciendo y la posicion del player esta en este compas.
892
public boolean isPlaying(){
893
if(TuxGuitar.instance().getPlayer().isRunning() && getTrackCoords().hasCaret()){
894
long playerTickPosition = TuxGuitar.instance().getPlayer().getTickPosition();
895
if(playerTickPosition >= getMeasure().getStart() && playerTickPosition < getMeasure().getStart() + getMeasure().getLength()){
902
public int getSpanForComponent(Component component){
903
return (int)((component.getStart() - getMeasure().getStart()) * getSpan() / getMeasure().getLength());
906
public boolean hasTrack(int number){
907
return (trackCoords.getTrack().getNumber() == number);
911
* Retorna el ancho del Compas
913
public int getWidth() {
914
return this.header.getWidth();//this.width;
917
private int calculateKeySignatureSpan(){
919
if(paintKeySignature){
920
if(measure.getKeySignature() <= 7){
921
span += 6 * (measure.getKeySignature());
923
span += 6 * (measure.getKeySignature() - 7);
925
if(prevMeasure != null ){
926
if(prevMeasure.getKeySignature() <= 7){
927
span += 6 * (prevMeasure.getKeySignature());
929
span += 6 * (prevMeasure.getKeySignature() - 7);
936
public int getFirstNoteSpan(){
937
return header.getFirstNoteSpan();
940
* Retorna el Componente Anterior
942
public MeasureComponent getPreviousComponent(MeasureComponent component) {
943
MeasureComponent prevComponent = null;
944
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
945
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
947
if (currComponent.getStart() < component.getStart()) {
948
if (prevComponent == null) {
949
prevComponent = currComponent;
950
} else if (currComponent.getStart() > prevComponent.getStart()) {
951
prevComponent = currComponent;
952
} else if (currComponent.getStart() == prevComponent.getStart()
953
&& currComponent.getDuration().getTime() <= prevComponent.getDuration().getTime()) {
954
prevComponent = currComponent;
958
return prevComponent;
962
* Retorna el Siguiente Componente
964
public MeasureComponent getNextComponent(MeasureComponent component) {
965
MeasureComponent nextComponent = null;
966
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
967
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
969
if (currComponent.getStart() > component.getStart()) {
970
if (nextComponent == null) {
971
nextComponent = currComponent;
972
} else if (currComponent.getStart() < nextComponent.getStart()) {
973
nextComponent = currComponent;
974
} else if (currComponent.getStart() == nextComponent.getStart()
975
&& currComponent.getDuration().getTime() <= nextComponent.getDuration().getTime()) {
976
nextComponent = currComponent;
980
return nextComponent;
984
* Retorna el Primer Componente
986
public MeasureComponent getFirstComponent() {
987
MeasureComponent firstComponent = null;
988
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
989
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
990
if (firstComponent == null || currComponent.getStart() < firstComponent.getStart()) {
991
firstComponent = currComponent;
994
return firstComponent;
998
* Retorna el Ultimo Componente
1000
public MeasureComponent getLastComponent() {
1001
MeasureComponent lastComponent = null;
1002
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1003
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1004
if (lastComponent == null || lastComponent.getStart() < currComponent.getStart()) {
1005
lastComponent = currComponent;
1008
return lastComponent;
1012
* Retorna Un Componente en la posicion start
1014
public MeasureComponent getComponent(long start) {
1015
MeasureComponent component = null;
1016
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1017
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1019
if (currComponent.getStart() <= start && (currComponent.getStart() + currComponent.getDuration().getTime() > start)) {
1020
component = currComponent;
1028
* Retorna Todos los Componentes en la posicion Start
1030
public List getComponents(long start) {
1031
List components = new ArrayList();
1032
Iterator it = measureComponents.iterator();
1033
while(it.hasNext()){
1034
MeasureComponent currComponent = (MeasureComponent)it.next();
1035
if (currComponent.getStart() == start) {
1036
components.add(currComponent);
1043
* Retorna Todos los Componentes en la posicion Start
1045
public List getComponentsBetween(long start) {
1046
List components = new ArrayList();
1047
Iterator it = measureComponents.iterator();
1048
while(it.hasNext()){
1049
MeasureComponent currComponent = (MeasureComponent)it.next();
1050
if (currComponent.getStart() <= start && currComponent.getStart() + currComponent.getDuration().getTime() > start) {
1051
components.add(currComponent);
1058
* Retorna el Componente en la posicion Start, y en la cuerda
1060
public MeasureComponent getComponent(long start,int string) {
1061
MeasureComponent component = null;
1062
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1063
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1064
if(currComponent instanceof NoteCoords){
1065
NoteCoords note = (NoteCoords)currComponent;
1066
if (note.getStart() <= start && (note.getStart() + note.getDuration().getTime() > start) && note.getNote().getString() == string) {
1067
component = currComponent;
1076
* Retorna el Componente en la posicion Start, y en la cuerda
1078
public MeasureComponent getComponentOrSilence(long start,int string) {
1079
MeasureComponent component = getComponent(start,string);
1080
if(component == null){
1081
component = getComponent(start);
1087
* Retorna Todos los desde Start hasta el final del compas
1089
public List getComponentsBeforeEnd(long fromStart) {
1090
List components = new ArrayList();
1091
Iterator it = measureComponents.iterator();
1092
while(it.hasNext()){
1093
MeasureComponent currComponent = (MeasureComponent)it.next();
1094
if (currComponent.getStart() >= fromStart) {
1095
components.add(currComponent);
1102
public List getComponents(){
1103
return this.measureComponents;
1108
* Retorna el Siguiente Componente en la cuerda. que sea de una nota
1110
public MeasureComponent getNextNoteComponent(MeasureComponent component,int string) {
1111
MeasureComponent nextComponent = null;
1112
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1113
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1114
if(currComponent instanceof NoteCoords){
1115
Note currNote = ((NoteCoords)currComponent).getNote();
1116
if(currNote.getString() == string && currNote.getStart() > component.getStart()){
1117
if(nextComponent == null || currNote.getStart() < nextComponent.getStart()){
1118
nextComponent = currComponent;
1123
return nextComponent;
1127
* Retorna el Siguiente Componente que sea de una nota
1129
public MeasureComponent getNextNoteComponent(MeasureComponent component) {
1130
MeasureComponent nextComponent = null;
1131
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1132
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1133
if(currComponent instanceof NoteCoords){
1134
if (currComponent.getStart() > component.getStart()) {
1135
if (nextComponent == null) {
1136
nextComponent = currComponent;
1137
} else if (currComponent.getStart() < nextComponent.getStart()) {
1138
nextComponent = currComponent;
1139
} else if (currComponent.getStart() == nextComponent.getStart()
1140
&& currComponent.getDuration().getTime() <= nextComponent.getDuration().getTime()) {
1141
nextComponent = currComponent;
1146
return nextComponent;
1151
* Retorna el Siguiente Componente que sea de un silencio
1153
public MeasureComponent getNextSilenceComponent(MeasureComponent component) {
1154
MeasureComponent nextComponent = null;
1155
for (int noteIdx = 0; noteIdx < measureComponents.size(); noteIdx++) {
1156
MeasureComponent currComponent = (MeasureComponent) measureComponents.get(noteIdx);
1157
if(currComponent instanceof SilenceCoords){
1158
if (currComponent.getStart() > component.getStart()) {
1159
if (nextComponent == null) {
1160
nextComponent = currComponent;
1161
} else if (currComponent.getStart() < nextComponent.getStart()) {
1162
nextComponent = currComponent;
1163
} else if (currComponent.getStart() == nextComponent.getStart()
1164
&& currComponent.getDuration().getTime() <= nextComponent.getDuration().getTime()) {
1165
nextComponent = currComponent;
1170
return nextComponent;
1175
* Retorna el componente mas cercano a X
1177
public MeasureComponent getComponentAt(int x){
1178
MeasureComponent component = null;
1179
Iterator it = measureComponents.iterator();
1180
while(it.hasNext()){
1181
MeasureComponent currComponent = (MeasureComponent)it.next();
1182
if(component == null){
1183
component = currComponent;
1185
int distanceX = Math.abs(x - (MeasureHeaderGui.DEFAULT_LEFT_SPAN + getPosX() + component.getPosX() + component.getSpan()));
1186
int currDistanceX = Math.abs(x - (MeasureHeaderGui.DEFAULT_LEFT_SPAN + getPosX() + currComponent.getPosX() + currComponent.getSpan()));
1187
if(currDistanceX < distanceX){
1188
component = currComponent;
1197
* Retorna la cuerda en la posicion y
1199
public InstrumentString getStringAt(int y) {
1200
InstrumentString string = null;
1201
int stringSpan = this.tablature.getViewLayout().getStringSpan();
1202
int minorDistance = 0;
1203
int firstStringY = getPosY() + ts.getPosition(TrackSpacing.POSITION_TABLATURE);
1205
Iterator it = trackCoords.getTrack().getStrings().iterator();
1206
while(it.hasNext()){
1207
InstrumentString currString = (InstrumentString)it.next();
1208
int distanceX = Math.abs(y - (firstStringY + ((currString.getNumber() * stringSpan) - stringSpan)));
1209
if(string == null || distanceX < minorDistance){
1210
string = currString;
1211
minorDistance = distanceX;
1219
public long getBeatLength(){
1220
return this.beatLength;
1223
public boolean areInSameBeat(MeasureComponent arg0,MeasureComponent arg1){
1224
return songManager.getMeasureManager().areInSameBeat(measure,arg0.getComponent(),arg1.getComponent());
1228
* Reproduce las notas en el pulso
1230
public void playBeat(long start){
1231
if(!TuxGuitar.instance().getPlayer().isRunning()){
1232
List notes = songManager.getMeasureManager().getNotes(measure,start);
1233
TuxGuitar.instance().getPlayer().playBeat(getTrackCoords().getTrack(),notes);
1237
public boolean isCacheEnabled() {
1238
return cacheEnabled;
1241
public void setCacheEnabled(boolean cacheEnabled) {
1242
this.cacheEnabled = cacheEnabled;
1246
* Retorna la posicion X dentro del compas
1248
public int getPosX() {
1253
* Asigna la posicion X dentro del compas
1255
public void setPosX(int posX) {
1260
* Retorna la posicion Y dentro del compas
1262
public int getPosY() {
1267
* Asigna la posicion Y dentro del compas
1269
public void setPosY(int posY) {
1274
* Asigna el span de negras
1276
public void setQuarterSpan(int quarterSpan){
1277
this.quarterSpan = quarterSpan;
1281
* Retorna el span de negras
1283
public int getQuarterSpan(){
1284
return this.quarterSpan;
1290
public Measure getMeasure(){
1291
return this.measure;
1294
public int getSpan() {
1297
public void setSpan(int span) {
1298
if(span != this.span){
1299
setCacheEnabled(false);
1304
public boolean isOutOfBounds() {
1308
public void setOutOfBounds(boolean outOfBounds) {
1309
this.outOfBounds = outOfBounds;
1312
public boolean isFirstOfLine() {
1316
public void setFirstOfLine(boolean firstOfLine) {
1317
this.firstOfLine = firstOfLine;
1321
public SongTrackCoords getTrackCoords(){
1322
return this.trackCoords;
1326
public TrackSpacing getTs() {
1330
public void setTs(TrackSpacing ts) {
1331
if(getTs() == null){
1332
setCacheEnabled(false);
1333
}else if(getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES) != ts.getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES)){
1334
setCacheEnabled(false);
1335
}else if(getTs().getPosition(TrackSpacing.POSITION_TABLATURE) != ts.getPosition(TrackSpacing.POSITION_TABLATURE)){
1336
setCacheEnabled(false);
1341
public int getMaxY() {
1345
public int getMinY() {
1349
public List getBeatPositions(){
1350
return this.beatPositions;
1353
public int getLyricBeatIndex() {
1354
return lyricBeatIndex;
1357
public void setLyricBeatIndex(int lyricBeatIndex) {
1358
this.lyricBeatIndex = lyricBeatIndex;
1361
public void dispose(){
1362
this.cache.dispose();
1365
public boolean isDisposed(){
1366
return this.cache.isDisposed();
1370
* Implementacion de Component para crear un pulso de lyric
1373
public class BeatPosition implements Component{
1376
private Duration duration;
1377
private NoteCoords maxNote;
1378
private NoteCoords minNote;
1380
public BeatPosition(long start,Duration duration,int posX){
1382
this.duration = duration;
1386
public void checkValues(NoteCoords note){
1387
int value = note.getRealValue();
1388
if(maxNote == null || value > maxNote.getRealValue()){
1391
if(minNote == null || value < minNote.getRealValue()){
1396
public int getPosX(){
1397
return (this.posX + getSpanForComponent(this));
1400
public void setDuration(Duration duration) {
1401
this.duration = duration;
1403
public Duration getDuration() {
1404
return this.duration;
1407
public long getStart() {
1410
public void setStart(long start) {
1414
public boolean isPlayingBeat(){
1416
long playerTickPosition = TuxGuitar.instance().getPlayer().getTickPosition();
1417
if(playerTickPosition >= getStart() && playerTickPosition < getStart() + getDuration().getTime()){
1425
public NoteCoords getMinNote(){
1426
return this.minNote;
1429
public NoteCoords getMaxNote(){
1430
return this.maxNote;
1433
public void paintExtraLines(GC gc,ViewLayout layout){
1434
int scoreY = getTs().getPosition(TrackSpacing.POSITION_SCORE_MIDDLE_LINES);
1435
paintExtraLines(gc,layout,getMinNote(),scoreY);
1436
paintExtraLines(gc,layout,getMaxNote(),scoreY);
1439
private void paintExtraLines(GC gc,ViewLayout layout,NoteCoords note,int scoreY){
1440
int y = scoreY + note.getScorePosY();
1441
int x = MeasureHeaderGui.DEFAULT_LEFT_SPAN + note.getPosX() + note.getSpan();
1443
int scoreLineSpan = layout.getScoreLineSpan();
1446
layout.setLineColor(gc);
1447
for(int i = scoreY;i > y;i -= scoreLineSpan){
1448
gc.drawLine(x - 4,i,x + 12,i);
1450
}else if(y > (scoreY + (scoreLineSpan * 4))){
1451
layout.setLineColor(gc);
1452
for(int i = (scoreY +(scoreLineSpan * 5));i < (y + scoreLineSpan);i += scoreLineSpan){
1453
gc.drawLine(x - 4,i,x + 12,i);
1458
public Object clone(){
1459
return new BeatPosition(this.start,(Duration)this.duration.clone(),this.posX);
b'\\ No newline at end of file'