← 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/effects/BendEditor.java

  • Committer: Bazaar Package Importer
  • Author(s): Philippe Coval
  • Date: 2007-02-04 01:41:23 UTC
  • Revision ID: james.westby@ubuntu.com-20070204014123-9pv7okph0iaiqkvw
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/herac/tuxguitar/gui/effects/BendEditor.java
 
1
/*
 
2
 * Created on 28-dic-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.gui.effects;
 
8
 
 
9
import java.util.ArrayList;
 
10
import java.util.Iterator;
 
11
import java.util.List;
 
12
 
 
13
import org.eclipse.swt.SWT;
 
14
import org.eclipse.swt.events.MouseAdapter;
 
15
import org.eclipse.swt.events.PaintEvent;
 
16
import org.eclipse.swt.events.PaintListener;
 
17
import org.eclipse.swt.events.SelectionAdapter;
 
18
import org.eclipse.swt.events.SelectionEvent;
 
19
import org.eclipse.swt.graphics.GC;
 
20
import org.eclipse.swt.graphics.Point;
 
21
import org.eclipse.swt.layout.GridData;
 
22
import org.eclipse.swt.layout.GridLayout;
 
23
import org.eclipse.swt.widgets.Button;
 
24
import org.eclipse.swt.widgets.Composite;
 
25
import org.eclipse.swt.widgets.Shell;
 
26
import org.herac.tuxguitar.gui.TuxGuitar;
 
27
import org.herac.tuxguitar.song.models.Note;
 
28
import org.herac.tuxguitar.song.models.effects.BendEffect;
 
29
/**
 
30
 * @author julian
 
31
 *
 
32
 * TODO To change the template for this generated type comment go to
 
33
 * Window - Preferences - Java - Code Style - Code Templates
 
34
 */
 
35
public class BendEditor{
 
36
    public static final int X_SPAN = 30;
 
37
    public static final int Y_SPAN = 15;    
 
38
    private static final int X_LENGTH = BendEffect.MAX_POSITION_LENGTH + 1;
 
39
    private static final int Y_LENGTH = BendEffect.MAX_VALUE_LENGTH + 1;
 
40
 
 
41
    private Composite editor;
 
42
    private int[] x; 
 
43
    private int[] y;
 
44
    private int width;
 
45
    private int height;    
 
46
    private List points;
 
47
    
 
48
    private DefaultBend[] defaultBends;
 
49
    private boolean isEditing;    
 
50
    
 
51
    private BendEffect result;
 
52
    
 
53
    public BendEditor() {
 
54
        this.init();                
 
55
    }
 
56
 
 
57
    private void init(){
 
58
        this.x = new int[X_LENGTH];
 
59
        this.y = new int[Y_LENGTH];
 
60
        this.width = ((X_SPAN * X_LENGTH) - X_SPAN);
 
61
        this.height = ((Y_SPAN * Y_LENGTH) - Y_SPAN);
 
62
        this.points = new ArrayList();
 
63
        
 
64
        for(int i = 0;i < x.length;i++){
 
65
            this.x[i] = ((i + 1) * X_SPAN);            
 
66
        }
 
67
        for(int i = 0;i < y.length;i++){
 
68
            this.y[i] = ((i + 1) * Y_SPAN);
 
69
        }        
 
70
    }    
 
71
    
 
72
    public BendEffect show(Shell shell,final Note note){
 
73
        final Shell dialog = new Shell(shell, SWT.DIALOG_TRIM | SWT.APPLICATION_MODAL);
 
74
   
 
75
        dialog.setLayout(new GridLayout());        
 
76
        dialog.setText(TuxGuitar.getProperty("bend.editor"));
 
77
        
 
78
        //----------------------------------------------------------------------
 
79
        Composite composite = new Composite(dialog,SWT.NONE);
 
80
        composite.setLayout(new GridLayout(3,false));
 
81
        composite.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true));         
 
82
        
 
83
        Composite leftComposite = new Composite(composite,SWT.NONE); 
 
84
        leftComposite.setLayout(new GridLayout());              
 
85
        leftComposite.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true));        
 
86
        
 
87
        Composite rightComposite = new Composite(composite,SWT.NONE); 
 
88
        rightComposite.setLayout(new GridLayout());              
 
89
        rightComposite.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true));        
 
90
        
 
91
        //-------------EDITOR---------------------------------------------------        
 
92
        this.isEditing = (note.getEffect().isBend());                
 
93
        this.editor = new Composite(leftComposite, SWT.BORDER | SWT.DOUBLE_BUFFERED);
 
94
        this.editor.setBackground(editor.getDisplay().getSystemColor(SWT.COLOR_WHITE));        
 
95
        this.editor.setLayoutData(resizeData(new GridData(SWT.FILL,SWT.FILL,true,true) , getWidth() + (X_SPAN * 2),getHeight() + (Y_SPAN * 2))  );
 
96
        this.editor.addPaintListener(new PaintListener() {
 
97
            public void paintControl(PaintEvent e) {
 
98
                paintEditor(e.gc);
 
99
                e.gc.dispose();
 
100
            }
 
101
        });
 
102
        this.editor.addMouseListener(new MouseAdapter() {
 
103
            public void mouseUp(org.eclipse.swt.events.MouseEvent e) {
 
104
                checkPoint(e.x,e.y);
 
105
                editor.redraw();
 
106
            }
 
107
        });         
 
108
        if(isEditing){
 
109
            setBend(note.getEffect().getBend());
 
110
        }                
 
111
 
 
112
        //-------------DEFAULT BEND LIST---------------------------------------------------       
 
113
        final org.eclipse.swt.widgets.List defaultBendList = new org.eclipse.swt.widgets.List(rightComposite,SWT.BORDER);         
 
114
        this.resetDefaultBends();
 
115
        for(int i = 0;i < defaultBends.length;i++){
 
116
            defaultBendList.add(this.defaultBends[i].getName());
 
117
        }
 
118
        defaultBendList.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true));  
 
119
        defaultBendList.addSelectionListener(new SelectionAdapter() {
 
120
            public void widgetSelected(SelectionEvent e) {
 
121
                if(!isEditing){
 
122
                    setBend(defaultBends[defaultBendList.getSelectionIndex()].getBend());
 
123
                    editor.redraw();
 
124
                }
 
125
                isEditing = false;
 
126
            }
 
127
        });                                    
 
128
 
 
129
        //------------------BUTTONS--------------------------  
 
130
        Button buttonClean = new Button(rightComposite, SWT.PUSH);
 
131
        buttonClean.setLayoutData(resizeData(new GridData(SWT.FILL,SWT.BOTTOM,true,true), 80,25));         
 
132
        buttonClean.setText(TuxGuitar.getProperty("clean"));
 
133
        buttonClean.addSelectionListener(new SelectionAdapter() {
 
134
            public void widgetSelected(SelectionEvent arg0) {
 
135
                result = null;
 
136
                dialog.dispose();
 
137
            }
 
138
        });                
 
139
        Button buttonOK = new Button(rightComposite, SWT.PUSH);
 
140
        buttonOK.setLayoutData(resizeData(new GridData(SWT.FILL,SWT.BOTTOM,true,false), 80,25));         
 
141
        buttonOK.setText(TuxGuitar.getProperty("ok"));
 
142
        buttonOK.addSelectionListener(new SelectionAdapter() {
 
143
            public void widgetSelected(SelectionEvent arg0) {  
 
144
                result = getBend();
 
145
                dialog.dispose();
 
146
            }
 
147
        });
 
148
        Button buttonCancel = new Button(rightComposite, SWT.PUSH);
 
149
        buttonCancel.setLayoutData(resizeData(new GridData(SWT.FILL,SWT.BOTTOM,true,false), 80,25));         
 
150
        buttonCancel.setText(TuxGuitar.getProperty("cancel"));
 
151
        buttonCancel.addSelectionListener(new SelectionAdapter() {
 
152
            public void widgetSelected(SelectionEvent arg0) {
 
153
                result = note.getEffect().getBend();
 
154
                dialog.dispose();
 
155
            }
 
156
        });
 
157
 
 
158
        dialog.pack();
 
159
        int x = shell.getBounds().x + (shell.getBounds().width - dialog.getSize().x) / 2;
 
160
        int y = shell.getBounds().y + (shell.getBounds().height - dialog.getSize().y) / 2;        
 
161
        dialog.setLocation(x, y);
 
162
        dialog.open(); 
 
163
        
 
164
                while (!dialog.isDisposed()) {
 
165
            if (!dialog.getDisplay().readAndDispatch()) {
 
166
                dialog.getDisplay().sleep();
 
167
            }
 
168
        }
 
169
        
 
170
                return result;          
 
171
        
 
172
    }    
 
173
    
 
174
    
 
175
    private GridData resizeData(GridData data,int minimumWidth,int minimumHeight){    
 
176
        data.minimumWidth = minimumWidth;
 
177
        data.minimumHeight = minimumHeight;    
 
178
        return data;
 
179
    }
 
180
    
 
181
    private void paintEditor(GC gc){        
 
182
        for(int i = 0;i < x.length;i++){
 
183
            this.setStyleX(gc,i);
 
184
            gc.drawLine(this.x[i],Y_SPAN,this.x[i],Y_SPAN + this.height);
 
185
        }
 
186
        for(int i = 0;i < y.length;i++){
 
187
            this.setStyleY(gc,i);
 
188
            gc.drawLine(X_SPAN,this.y[i],X_SPAN + this.width,this.y[i]);
 
189
        }       
 
190
        
 
191
        
 
192
        Iterator it = null;
 
193
        Point prevPoint = null;
 
194
        gc.setLineStyle(SWT.LINE_SOLID);
 
195
        gc.setLineWidth(2);
 
196
        gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_GRAY));        
 
197
        it = this.points.iterator();
 
198
        while(it.hasNext()){
 
199
            Point point = (Point)it.next();            
 
200
            if(prevPoint != null){                                
 
201
                gc.drawLine(prevPoint.x,prevPoint.y,point.x,point.y);
 
202
            }            
 
203
            prevPoint = point;
 
204
        }        
 
205
        
 
206
        
 
207
        gc.setLineWidth(5);
 
208
        gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_BLACK));                                       
 
209
        it = this.points.iterator();
 
210
        while(it.hasNext()){
 
211
            Point point = (Point)it.next();                       
 
212
 
 
213
            gc.drawRectangle(point.x - 2,point.y - 2,5,5);           
 
214
        }
 
215
        gc.setLineWidth(1);
 
216
    }
 
217
 
 
218
 
 
219
    
 
220
    private void setStyleX(GC gc,int i){
 
221
        gc.setLineStyle(SWT.LINE_SOLID);
 
222
        if(i == 0 || i == (X_LENGTH - 1)){
 
223
            gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_BLACK));
 
224
        }else{            
 
225
            gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_BLUE));
 
226
            if((i % 3) > 0){
 
227
                gc.setLineStyle(SWT.LINE_DOT);            
 
228
            }
 
229
        }
 
230
    }    
 
231
    
 
232
    private void setStyleY(GC gc,int i){
 
233
        gc.setLineStyle(SWT.LINE_SOLID);
 
234
        if(i == 0 || i == (Y_LENGTH - 1)){
 
235
            gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_BLACK));
 
236
        }else{         
 
237
            gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_RED));
 
238
        
 
239
            if((i % 2) > 0){
 
240
                gc.setLineStyle(SWT.LINE_DOT);
 
241
                gc.setForeground(this.editor.getDisplay().getSystemColor(SWT.COLOR_GRAY));
 
242
            }else if((i % 4) > 0){
 
243
                gc.setLineStyle(SWT.LINE_DOT);         
 
244
            }
 
245
        }
 
246
    }
 
247
    
 
248
    
 
249
    
 
250
    private void checkPoint(int x,int y){        
 
251
        Point point = new Point(this.getX(x),this.getY(y));
 
252
        if(!this.removePoint(point)){
 
253
            this.removePointsAtXLine(point.x);
 
254
            this.addPoint(point);
 
255
            this.orderPoints();
 
256
        }
 
257
    }
 
258
    
 
259
    private boolean removePoint(Point point){
 
260
        Iterator it = this.points.iterator();
 
261
        while(it.hasNext()){
 
262
            Point currPoint = (Point)it.next();
 
263
            if(currPoint.x == point.x && currPoint.y == point.y){
 
264
                this.points.remove(point);
 
265
                return true;
 
266
            }
 
267
        }  
 
268
        return false;
 
269
    }
 
270
    
 
271
    private void orderPoints(){
 
272
        for(int i = 0;i < this.points.size();i++){
 
273
            Point minPoint = null;
 
274
            for(int noteIdx = i;noteIdx < this.points.size();noteIdx++){
 
275
                Point point = (Point)this.points.get(noteIdx);
 
276
                if(minPoint == null || point.x < minPoint.x){
 
277
                    minPoint = point;
 
278
                }
 
279
            }
 
280
            this.points.remove(minPoint);
 
281
            this.points.add(i,minPoint);
 
282
        }
 
283
    }    
 
284
    
 
285
    private void removePointsAtXLine(int x){
 
286
        Iterator it = this.points.iterator();
 
287
        while(it.hasNext()){
 
288
            Point point = (Point)it.next();
 
289
            if(point.x == x){
 
290
                this.points.remove(point);
 
291
                break;
 
292
            }
 
293
        }  
 
294
    }     
 
295
    
 
296
    private void addPoint(Point point){
 
297
        this.points.add(point);
 
298
    }
 
299
    
 
300
    private int getX(int pointX){  
 
301
        int currPointX = -1;        
 
302
        for(int i = 0;i < this.x.length;i++){                    
 
303
            if(currPointX < 0){
 
304
                currPointX = this.x[i];
 
305
            }else{                    
 
306
                int distanceX = Math.abs(pointX - currPointX);
 
307
                int currDistanceX = Math.abs(pointX - this.x[i]);
 
308
                if(currDistanceX < distanceX){
 
309
                    currPointX = this.x[i];
 
310
                }
 
311
            }
 
312
            
 
313
        }
 
314
        return currPointX;
 
315
    }     
 
316
    
 
317
    private int getY(int pointY){  
 
318
        int currPointY = -1;        
 
319
        for(int i = 0;i < this.y.length;i++){                    
 
320
            if(currPointY < 0){
 
321
                currPointY = this.y[i];
 
322
            }else{                    
 
323
                int distanceX = Math.abs(pointY - currPointY);
 
324
                int currDistanceX = Math.abs(pointY - this.y[i]);
 
325
                if(currDistanceX < distanceX){
 
326
                    currPointY = this.y[i];
 
327
                }
 
328
            }
 
329
            
 
330
        }
 
331
        return currPointY;
 
332
    }  
 
333
    
 
334
    public boolean isEmpty(){
 
335
        return this.points.isEmpty();
 
336
    }
 
337
    
 
338
    public BendEffect getBend(){
 
339
        if(this.points != null && !this.points.isEmpty()){
 
340
                BendEffect bend = new BendEffect();     
 
341
                Iterator it = this.points.iterator();
 
342
                while(it.hasNext()){
 
343
                        Point point = (Point)it.next();            
 
344
                        addBendPoint(bend,point);
 
345
                }              
 
346
                return bend;
 
347
        }
 
348
        return null;
 
349
    }
 
350
    
 
351
    private void addBendPoint(BendEffect effect,Point point){
 
352
        int position = 0;
 
353
        int value = 0;
 
354
        for(int i=0;i<this.x.length;i++){
 
355
            if(point.x == this.x[i]){
 
356
                position = i;
 
357
            }
 
358
        }
 
359
        for(int i=0;i<this.y.length;i++){
 
360
            if(point.y == this.y[i]){
 
361
                value = (this.y.length - i) -1;
 
362
            }
 
363
        }        
 
364
        effect.addPoint(position,value); 
 
365
    }
 
366
    
 
367
    
 
368
    public void setBend(BendEffect effect){
 
369
        this.points.clear();
 
370
        Iterator it = effect.getPoints().iterator();
 
371
        while(it.hasNext()){
 
372
            BendEffect.BendPoint bendPoint = (BendEffect.BendPoint)it.next();
 
373
            this.makePoint(bendPoint);
 
374
        }
 
375
    }
 
376
    
 
377
    private void makePoint(BendEffect.BendPoint bendPoint){
 
378
        int indexX = bendPoint.getPosition();
 
379
        int indexY = (this.y.length - bendPoint.getValue()) - 1;        
 
380
        if(indexX >= 0 && indexX < this.x.length && indexY >= 0 && indexY < this.y.length){
 
381
                Point point = new Point(0,0);
 
382
                point.x = this.x[indexX];
 
383
                point.y = this.y[indexY];         
 
384
                this.points.add(point);
 
385
        }
 
386
    }
 
387
    
 
388
    
 
389
    public int getWidth(){
 
390
        return this.width;        
 
391
    }
 
392
    
 
393
    public int getHeight(){
 
394
        return this.height;
 
395
    }
 
396
    
 
397
  
 
398
    private void resetDefaultBends(){
 
399
        this.defaultBends = new DefaultBend[5];
 
400
        
 
401
        this.defaultBends[0] = new DefaultBend(TuxGuitar.getProperty("bend.bend"),new BendEffect());        
 
402
        this.defaultBends[0].getBend().addPoint(0,0);
 
403
        this.defaultBends[0].getBend().addPoint(6,(BendEffect.SEMITONE_LENGTH * 2));
 
404
        this.defaultBends[0].getBend().addPoint(12,(BendEffect.SEMITONE_LENGTH * 2));               
 
405
        
 
406
        this.defaultBends[1] = new DefaultBend(TuxGuitar.getProperty("bend.bend-release"),new BendEffect());         
 
407
        this.defaultBends[1].getBend().addPoint(0,0);
 
408
        this.defaultBends[1].getBend().addPoint(3,(BendEffect.SEMITONE_LENGTH * 2));
 
409
        this.defaultBends[1].getBend().addPoint(6,(BendEffect.SEMITONE_LENGTH * 2));
 
410
        this.defaultBends[1].getBend().addPoint(9,0);
 
411
        this.defaultBends[1].getBend().addPoint(12,0);
 
412
                
 
413
        this.defaultBends[2] = new DefaultBend(TuxGuitar.getProperty("bend.bend-release-bend"),new BendEffect());         
 
414
        this.defaultBends[2].getBend().addPoint(0,0);
 
415
        this.defaultBends[2].getBend().addPoint(2,(BendEffect.SEMITONE_LENGTH * 2));
 
416
        this.defaultBends[2].getBend().addPoint(4,(BendEffect.SEMITONE_LENGTH * 2));
 
417
        this.defaultBends[2].getBend().addPoint(6,0);
 
418
        this.defaultBends[2].getBend().addPoint(8,0);
 
419
        this.defaultBends[2].getBend().addPoint(10,(BendEffect.SEMITONE_LENGTH * 2));
 
420
        this.defaultBends[2].getBend().addPoint(12,(BendEffect.SEMITONE_LENGTH * 2));
 
421
        
 
422
        this.defaultBends[3] = new DefaultBend(TuxGuitar.getProperty("bend.prebend"),new BendEffect());         
 
423
        this.defaultBends[3].getBend().addPoint(0,(BendEffect.SEMITONE_LENGTH * 2));
 
424
        this.defaultBends[3].getBend().addPoint(12,(BendEffect.SEMITONE_LENGTH * 2));
 
425
        
 
426
        this.defaultBends[4] = new DefaultBend(TuxGuitar.getProperty("bend.prebend-release"),new BendEffect());         
 
427
        this.defaultBends[4].getBend().addPoint(0,(BendEffect.SEMITONE_LENGTH * 2));
 
428
        this.defaultBends[4].getBend().addPoint(4,(BendEffect.SEMITONE_LENGTH * 2));
 
429
        this.defaultBends[4].getBend().addPoint(8,0);
 
430
        this.defaultBends[4].getBend().addPoint(12,0);
 
431
    }       
 
432
    
 
433
 
 
434
    
 
435
    private class DefaultBend{
 
436
        private String name;
 
437
        private BendEffect bend;
 
438
        
 
439
        public DefaultBend(String name,BendEffect bend){
 
440
            this.name = name;
 
441
            this.bend = bend;
 
442
        }                
 
443
        public BendEffect getBend() {
 
444
            return bend;
 
445
        }
 
446
        public String getName() {
 
447
            return name;
 
448
        }
 
449
    }        
 
450
}