← Back to branch summary

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

« back to all changes in this revision

Viewing changes to TuxGuitar/src/org/herac/tuxguitar/gui/editors/tab/edit/EditorKit.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:
TuxGuitar/src/org/herac/tuxguitar/gui/editors/tab/edit/EditorKit.java
 
1
package org.herac.tuxguitar.gui.editors.tab.edit;
 
2
 
 
3
import java.util.Iterator;
 
4
 
 
5
import org.eclipse.swt.events.MenuEvent;
 
6
import org.eclipse.swt.events.MenuListener;
 
7
import org.eclipse.swt.events.MouseEvent;
 
8
import org.eclipse.swt.events.MouseListener;
 
9
import org.eclipse.swt.events.MouseMoveListener;
 
10
import org.eclipse.swt.events.MouseTrackListener;
 
11
import org.eclipse.swt.graphics.Point;
 
12
import org.herac.tuxguitar.gui.TuxGuitar;
 
13
import org.herac.tuxguitar.gui.editors.tab.TGBeatImpl;
 
14
import org.herac.tuxguitar.gui.editors.tab.TGMeasureImpl;
 
15
import org.herac.tuxguitar.gui.editors.tab.TGTrackImpl;
 
16
import org.herac.tuxguitar.gui.editors.tab.Tablature;
 
17
import org.herac.tuxguitar.gui.editors.tab.layout.TrackSpacing;
 
18
import org.herac.tuxguitar.gui.editors.tab.layout.ViewLayout;
 
19
import org.herac.tuxguitar.gui.system.config.TGConfigKeys;
 
20
import org.herac.tuxguitar.song.models.TGBeat;
 
21
import org.herac.tuxguitar.song.models.TGString;
 
22
 
 
23
public class EditorKit implements MouseListener,MouseMoveListener,MouseTrackListener,MenuListener{
 
24
        
 
25
        public static final int MOUSE_MODE_SELECTION = 1;
 
26
        public static final int MOUSE_MODE_EDITION = 2;
 
27
        
 
28
        private int mouseMode;
 
29
        private boolean natural;
 
30
        private Tablature tablature;
 
31
        private MouseKit mouseKit;
 
32
        private Point position;
 
33
        private boolean menuOpen;
 
34
        
 
35
        public EditorKit(Tablature tablature){
 
36
                this.tablature = tablature;
 
37
                this.mouseKit = new MouseKit(this);
 
38
                this.position = new Point(0,0);
 
39
                this.menuOpen = false;
 
40
                this.tablature.addMouseListener(this);
 
41
                this.tablature.addMouseMoveListener(this);
 
42
                this.tablature.addMouseTrackListener(this);
 
43
                this.setDefaults();
 
44
        }
 
45
        
 
46
        private void setDefaults(){
 
47
                this.setMouseMode(TuxGuitar.instance().getConfig().getIntConfigValue(TGConfigKeys.EDITOR_MOUSE_MODE,MOUSE_MODE_EDITION));
 
48
                this.setNatural(TuxGuitar.instance().getConfig().getBooleanConfigValue(TGConfigKeys.EDITOR_NATURAL_KEY_MODE,true));
 
49
        }
 
50
        
 
51
        public int getMouseMode() {
 
52
                return this.mouseMode;
 
53
        }
 
54
        
 
55
        public void setMouseMode(int mouseMode) {
 
56
                this.mouseMode = mouseMode;
 
57
        }
 
58
        
 
59
        public boolean isNatural() {
 
60
                return this.natural;
 
61
        }
 
62
        
 
63
        public void setNatural(boolean natural) {
 
64
                this.natural = natural;
 
65
        }
 
66
        
 
67
        public Tablature getTablature() {
 
68
                return this.tablature;
 
69
        }       
 
70
        
 
71
        public void tryBack(){
 
72
                this.mouseKit.tryBack();
 
73
        }
 
74
        
 
75
        public boolean select() {
 
76
                int x = this.position.x;
 
77
                int y = this.position.y;
 
78
                if(x >= 0 && y >= 0){
 
79
                        TGTrackImpl track = findSelectedTrack(y);
 
80
                        if (track != null) {
 
81
                                TGMeasureImpl measure = findSelectedMeasure(track, x, y);
 
82
                                if (measure != null) {
 
83
                                        TGBeat beat = findSelectedBeat(measure, x);
 
84
                                        TGString tgString = findSelectedString(measure, y);
 
85
                                        if (beat != null) {
 
86
                                                int string = (tgString != null)?tgString.getNumber():getTablature().getCaret().getSelectedString().getNumber();
 
87
                                                getTablature().getCaret().moveTo(track, measure, beat, string);
 
88
                                        }
 
89
                                        return true;
 
90
                                }
 
91
                        }
 
92
                }
 
93
                return false;
 
94
        }
 
95
        
 
96
        private boolean isScoreEnabled(){
 
97
                return ( (getTablature().getViewLayout().getStyle() & ViewLayout.DISPLAY_SCORE) != 0 );
 
98
        }
 
99
        
 
100
        public TGTrackImpl findSelectedTrack(int y){
 
101
                ViewLayout layout = getTablature().getViewLayout();
 
102
                int number = layout.getTrackNumberAt(y);
 
103
                if(number >= 0){
 
104
                        return (TGTrackImpl)layout.getSongManager().getTrack(number);
 
105
                }
 
106
                return null;
 
107
        }
 
108
        
 
109
        public TGMeasureImpl findSelectedMeasure(TGTrackImpl track,int x,int y){
 
110
                TGMeasureImpl measure = null;
 
111
                int minorDistance = 0;
 
112
                
 
113
                Iterator it = track.getMeasures();
 
114
                while(it.hasNext()){
 
115
                        TGMeasureImpl m = (TGMeasureImpl)it.next();
 
116
                        if(!m.isOutOfBounds() && m.getTs() != null){
 
117
                                boolean isAtX = (x >= m.getPosX() && x <= m.getPosX() + m.getWidth(getTablature().getViewLayout()) + m.getSpacing());
 
118
                                if(isAtX){
 
119
                                        int measureHeight = m.getTs().getSize();
 
120
                                        int distanceY = Math.min(Math.abs(y - (m.getPosY())),Math.abs(y - ( m.getPosY() + measureHeight - 10)));
 
121
                                        if(measure == null || distanceY < minorDistance){
 
122
                                                measure = m;
 
123
                                                minorDistance = distanceY;
 
124
                                        }
 
125
                                }
 
126
                        }
 
127
                }
 
128
                return measure;
 
129
        }
 
130
        
 
131
        public TGBeatImpl findSelectedBeat(TGMeasureImpl measure, int x){
 
132
                int posX = measure.getHeaderImpl().getLeftSpacing(getTablature().getViewLayout()) + measure.getPosX();
 
133
                int bestDiff = -1;
 
134
                TGBeatImpl bestBeat = null;
 
135
                Iterator it = measure.getBeats().iterator();
 
136
                while(it.hasNext()){
 
137
                        TGBeatImpl beat = (TGBeatImpl)it.next();
 
138
                        int diff = Math.abs(x - (posX + (beat.getPosX() + beat.getSpacing())));
 
139
                        if(bestDiff == -1 || diff < bestDiff){
 
140
                                bestBeat = beat;
 
141
                                bestDiff = diff;
 
142
                        }
 
143
                }
 
144
                return bestBeat;
 
145
        }
 
146
        
 
147
        public TGString findSelectedString(TGMeasureImpl measure,int y) {
 
148
                TGString string = null;
 
149
                int stringSpacing = getTablature().getViewLayout().getStringSpacing();
 
150
                int minorDistance = 0;
 
151
                int firstStringY = measure.getPosY() + measure.getTs().getPosition(TrackSpacing.POSITION_TABLATURE);
 
152
                
 
153
                Iterator it = measure.getTrack().getStrings().iterator();
 
154
                while(it.hasNext()){
 
155
                        TGString currString = (TGString)it.next();
 
156
                        int distanceX = Math.abs(y - (firstStringY + ((currString.getNumber() * stringSpacing) - stringSpacing)));
 
157
                        if(string == null || distanceX < minorDistance){
 
158
                                string = currString;
 
159
                                minorDistance = distanceX;
 
160
                        }
 
161
                }
 
162
                
 
163
                return string;
 
164
        }
 
165
        
 
166
        public void mouseDown(MouseEvent e) {
 
167
                this.position.x = e.x;
 
168
                this.position.y = e.y;
 
169
        }
 
170
        
 
171
        public void mouseUp(MouseEvent e) {
 
172
                this.position.x = e.x;
 
173
                this.position.y = e.y;
 
174
                this.tablature.setFocus();
 
175
                if(select()){
 
176
                        TuxGuitar.instance().updateCache(true);
 
177
                        if(!this.menuOpen && e.button == 1 && !TuxGuitar.instance().getPlayer().isRunning() && isScoreEnabled() && getMouseMode() == MOUSE_MODE_EDITION){
 
178
                                this.mouseKit.mouseUp(e);
 
179
                        }
 
180
                }
 
181
        }
 
182
        
 
183
        public void mouseMove(MouseEvent e) {
 
184
                if(!this.menuOpen && !TuxGuitar.instance().getPlayer().isRunning()){
 
185
                        if(isScoreEnabled() && getMouseMode() == MOUSE_MODE_EDITION){
 
186
                                this.mouseKit.mouseMove(e);
 
187
                        }
 
188
                }
 
189
        }
 
190
        
 
191
        public void mouseExit(MouseEvent e) {
 
192
                if(!this.menuOpen && !TuxGuitar.instance().getPlayer().isRunning()){
 
193
                        if(isScoreEnabled() && getMouseMode() == MOUSE_MODE_EDITION){
 
194
                                this.mouseKit.mouseExit();
 
195
                        }
 
196
                }
 
197
        }
 
198
        
 
199
        public void menuShown(MenuEvent e) {
 
200
                this.menuOpen = true;
 
201
                this.select();
 
202
                TuxGuitar.instance().updateCache(true);
 
203
        }
 
204
        
 
205
        public void menuHidden(MenuEvent e){
 
206
                this.menuOpen = false;
 
207
                TuxGuitar.instance().updateCache(true);
 
208
        }
 
209
        
 
210
        public void mouseDoubleClick(MouseEvent e) {
 
211
                //not implemented
 
212
        }
 
213
        
 
214
        public void mouseEnter(MouseEvent e) {
 
215
                //not implemented
 
216
        }
 
217
        
 
218
        public void mouseHover(MouseEvent e) {
 
219
                //not implemented
 
220
        }
 
221
}