← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/org/herac/tuxguitar/gui/editors/tab/MeasureTimeHelper.java

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/gui/editors/tab/MeasureTimeHelper.java
1
 
package org.herac.tuxguitar.gui.editors.tab;
2
 
 
3
 
import org.herac.tuxguitar.gui.editors.tab.layout.ViewLayout;
4
 
 
5
 
 
6
 
public class MeasureTimeHelper {
7
 
        private static final int SCORE_MIDDLE_KEYS[] = new int[]{55,40,40,50};
8
 
        private static final int SCORE_SHARP_POSITIONS[] = new int[]{7,7,6,6,5,4,4,3,3,2,2,1};  
9
 
        private static final int SCORE_FLAT_POSITIONS[] = new int[]{7,6,6,5,5,4,3,3,2,2,1,1};
10
 
        
11
 
        public static final int DIRECTION_UP = 1;
12
 
        public static final int DIRECTION_DOWN = 2;
13
 
                
14
 
        public static final int UP_OFFSET = 28;
15
 
        public static final int DOWN_OFFSET = 35;
16
 
        
17
 
        private int direction;
18
 
        private NoteCoords firstMinNote;
19
 
        private NoteCoords firstMaxNote;
20
 
        private NoteCoords lastMinNote;
21
 
        private NoteCoords lastMaxNote;
22
 
        private NoteCoords maxNote;
23
 
        private NoteCoords minNote;
24
 
        
25
 
        public MeasureTimeHelper(){
26
 
                this.direction = DIRECTION_UP;
27
 
                this.firstMinNote = null;
28
 
                this.firstMaxNote = null;
29
 
                this.lastMinNote = null;
30
 
                this.lastMaxNote = null;
31
 
                this.maxNote = null;
32
 
                this.minNote = null;
33
 
        }
34
 
        
35
 
        public void check(NoteCoords note,int clef){
36
 
                int value = note.getRealValue();
37
 
                
38
 
                //FIRST MIN NOTE
39
 
                if(firstMinNote == null || note.getStart() < firstMinNote.getStart()){                  
40
 
                        firstMinNote = note;
41
 
                }else if(note.getStart() == firstMinNote.getStart()){
42
 
                        if(note.getRealValue() < firstMinNote.getRealValue()){
43
 
                                firstMinNote = note;
44
 
                        }
45
 
                }
46
 
                //FIRST MAX NOTE
47
 
                if(firstMaxNote == null || note.getStart() < firstMaxNote.getStart()){                  
48
 
                        firstMaxNote = note;
49
 
                }else if(note.getStart() == firstMaxNote.getStart()){
50
 
                        if(note.getRealValue() > firstMaxNote.getRealValue()){
51
 
                                firstMaxNote = note;
52
 
                        }
53
 
                }
54
 
                                
55
 
                //LAST MIN NOTE
56
 
                if(lastMinNote == null || note.getStart() > lastMinNote.getStart()){
57
 
                        lastMinNote = note;
58
 
                }else if(note.getStart() == lastMinNote.getStart()){
59
 
                        if(note.getRealValue() < lastMinNote.getRealValue()){
60
 
                                lastMinNote = note;
61
 
                        }
62
 
                }       
63
 
                //LAST MIN NOTE
64
 
                if(lastMaxNote == null || note.getStart() > lastMaxNote.getStart()){
65
 
                        lastMaxNote = note;
66
 
                }else if(note.getStart() == lastMaxNote.getStart()){
67
 
                        if(note.getRealValue() > lastMaxNote.getRealValue()){
68
 
                                lastMaxNote = note;
69
 
                        }
70
 
                }       
71
 
                
72
 
                if(maxNote == null || value > maxNote.getRealValue()){
73
 
                        maxNote = note;
74
 
                }
75
 
                if(minNote == null || value < minNote.getRealValue()){
76
 
                        minNote = note;
77
 
                }
78
 
                                                
79
 
                int max = Math.abs(minNote.getRealValue() - (SCORE_MIDDLE_KEYS[clef - 1] + 100));
80
 
                int min = Math.abs(maxNote.getRealValue() - (SCORE_MIDDLE_KEYS[clef - 1] - 100));               
81
 
                if(max > min){
82
 
                        this.direction = DIRECTION_UP;                  
83
 
                }else{
84
 
                        this.direction = DIRECTION_DOWN;
85
 
                }
86
 
        }
87
 
 
88
 
        public int getY1(ViewLayout layout,NoteCoords note,int key,int clef){
89
 
                double scale = (layout.getScoreLineSpan() / 2.00);
90
 
                int noteValue = note.getRealValue();
91
 
                
92
 
                int scoreLineY = 0;
93
 
                if(key <= 7){
94
 
                        scoreLineY = (int)((SCORE_SHARP_POSITIONS[noteValue % 12]) * scale - (7 * (noteValue / 12)) * scale);
95
 
                }else{
96
 
                        scoreLineY = (int)((SCORE_FLAT_POSITIONS[noteValue % 12]) * scale - (7 * (noteValue / 12)) * scale);
97
 
                }
98
 
 
99
 
                scoreLineY += MeasureCoords.SCORE_KEY_OFFSETS[clef - 1] * scale; 
100
 
 
101
 
                return scoreLineY;
102
 
        }
103
 
        
104
 
        public int getY2(ViewLayout layout,int x,int key,int clef){             
105
 
                int maxDistance = 10;
106
 
                if(direction == DIRECTION_DOWN){
107
 
                        if(minNote != firstMinNote && minNote != lastMinNote){
108
 
                                return getY1(layout,minNote,key,clef) + DOWN_OFFSET;    
109
 
                        }
110
 
                        
111
 
                        int x1 = firstMinNote.getPosX() + firstMinNote.getSpan();
112
 
                        int x2 = lastMinNote.getPosX() + lastMinNote.getSpan();                                         
113
 
                        int y1 = getY1(layout,firstMinNote,key,clef) + DOWN_OFFSET;
114
 
                        int y2 = getY1(layout,lastMinNote,key,clef) + DOWN_OFFSET;
115
 
                        
116
 
                        if(y1 > y2 && (y1 - y2) > maxDistance) y2 = (y1 - maxDistance);
117
 
                        if(y2 > y1 && (y2 - y1) > maxDistance) y1 = (y2 - maxDistance);                 
118
 
                        int y = (int)((((double)y1 -(double)y2) / ((double)x1 - (double)x2)) * ((double)x1 - (double)x));
119
 
                        return y1 - y;
120
 
                }else{
121
 
                        if(maxNote != firstMaxNote && maxNote != lastMaxNote){
122
 
                                return getY1(layout,maxNote,key,clef) - UP_OFFSET;      
123
 
                        }                       
124
 
                        int x1 = firstMaxNote.getPosX() + firstMaxNote.getSpan();
125
 
                        int x2 = lastMaxNote.getPosX() + lastMaxNote.getSpan();                                                                                 
126
 
                        int y1 = getY1(layout,firstMaxNote,key,clef) - UP_OFFSET;
127
 
                        int y2 = getY1(layout,lastMaxNote,key,clef) - UP_OFFSET;
128
 
                        
129
 
                        if(y1 < y2 && (y2 - y1) > maxDistance) y2 = (y1 + maxDistance);
130
 
                        if(y2 < y1 && (y1 - y2) > maxDistance) y1 = (y2 + maxDistance);                 
131
 
                        int y = (int)((((double)y1 -(double)y2) / ((double)x1 - (double)x2)) * ((double)x1 - (double)x));
132
 
                        return y1 - y;                          
133
 
                }
134
 
                
135
 
        }       
136
 
 
137
 
        public int getDirection() {
138
 
                return direction;
139
 
        }
140
 
        
141
 
        public NoteCoords getMinNote(){
142
 
                return this.minNote;
143
 
        }
144
 
        
145
 
        public NoteCoords getMaxNote(){
146
 
                return this.maxNote;
147
 
        }
148
 
}