← 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/system/config/items/StylesOption.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/system/config/items/StylesOption.java
 
1
package org.herac.tuxguitar.gui.system.config.items;
 
2
 
 
3
import org.eclipse.swt.SWT;
 
4
import org.eclipse.swt.events.SelectionAdapter;
 
5
import org.eclipse.swt.events.SelectionEvent;
 
6
import org.eclipse.swt.graphics.Color;
 
7
import org.eclipse.swt.graphics.Font;
 
8
import org.eclipse.swt.graphics.FontData;
 
9
import org.eclipse.swt.graphics.GC;
 
10
import org.eclipse.swt.graphics.Image;
 
11
import org.eclipse.swt.graphics.RGB;
 
12
import org.eclipse.swt.layout.GridData;
 
13
import org.eclipse.swt.layout.GridLayout;
 
14
import org.eclipse.swt.widgets.Button;
 
15
import org.eclipse.swt.widgets.ColorDialog;
 
16
import org.eclipse.swt.widgets.Composite;
 
17
import org.eclipse.swt.widgets.FontDialog;
 
18
import org.eclipse.swt.widgets.ToolBar;
 
19
import org.herac.tuxguitar.gui.SystemImages;
 
20
import org.herac.tuxguitar.gui.TuxGuitar;
 
21
import org.herac.tuxguitar.gui.system.config.ConfigKeys;
 
22
import org.herac.tuxguitar.gui.system.config.ConfigEditor;
 
23
 
 
24
public class StylesOption extends Option{
 
25
        private static final int BUTTON_WIDTH = 85;
 
26
        private static final int BUTTON_HEIGHT = 30;
 
27
        
 
28
        private FontData defaultFontData;
 
29
        private FontData noteFontData;
 
30
        private FontData timeSignatureFontData;         
 
31
        private FontData printerDefaultFontData;
 
32
        private FontData printerNoteFontData;
 
33
        private FontData printerTimeSignatureFontData;                  
 
34
        private RGB scoreNoteRGB;       
 
35
        private RGB tabNoteRGB;
 
36
        private RGB playNoteRGB;
 
37
        private RGB linesRGB;
 
38
        
 
39
    public StylesOption(ConfigEditor configEditor,ToolBar toolBar,final Composite parent){
 
40
        super(configEditor,toolBar,parent,TuxGuitar.getProperty("settings.config.styles"));
 
41
        this.defaultFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_DEFAULT);
 
42
        this.noteFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_NOTE);
 
43
        this.timeSignatureFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_TIME_SIGNATURE);            
 
44
        this.printerDefaultFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_PRINTER_DEFAULT);
 
45
        this.printerNoteFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_PRINTER_NOTE);
 
46
        this.printerTimeSignatureFontData = TuxGuitar.instance().getConfig().getFontDataConfigValue(ConfigKeys.FONT_PRINTER_TIME_SIGNATURE);
 
47
        
 
48
        this.scoreNoteRGB = TuxGuitar.instance().getConfig().getRGBConfigValue(ConfigKeys.COLOR_SCORE_NOTE);
 
49
        this.tabNoteRGB = TuxGuitar.instance().getConfig().getRGBConfigValue(ConfigKeys.COLOR_TAB_NOTE);
 
50
        this.playNoteRGB = TuxGuitar.instance().getConfig().getRGBConfigValue(ConfigKeys.COLOR_PLAY_NOTE);
 
51
        this.linesRGB = TuxGuitar.instance().getConfig().getRGBConfigValue(ConfigKeys.COLOR_LINE);
 
52
        if(this.scoreNoteRGB == null){
 
53
                this.scoreNoteRGB  = TuxGuitar.instance().getTablatureEditor().getTablature().getScoreNoteColor().getRGB();
 
54
        }
 
55
        if(this.tabNoteRGB == null){
 
56
                this.tabNoteRGB  = TuxGuitar.instance().getTablatureEditor().getTablature().getTabNoteColor().getRGB();
 
57
        }
 
58
        if(this.playNoteRGB == null){
 
59
                this.playNoteRGB  = TuxGuitar.instance().getTablatureEditor().getTablature().getPlayNoteColor().getRGB();
 
60
        }     
 
61
        if(this.linesRGB == null){
 
62
                this.linesRGB  = TuxGuitar.instance().getTablatureEditor().getTablature().getLineColor().getRGB();
 
63
        }             
 
64
    }
 
65
    
 
66
    public void createOption(){         
 
67
                getToolItem().setText(TuxGuitar.getProperty("settings.config.styles")); 
 
68
                getToolItem().setImage(SystemImages.OPTION_STYLE);
 
69
                getToolItem().addSelectionListener(this);
 
70
                
 
71
                Composite styles = new Composite(getComposite(),SWT.NONE);
 
72
                styles.setLayout(new GridLayout(2,false));
 
73
                styles.setLayoutData(new GridData(SWT.FILL,SWT.FILL,true,true));
 
74
                                                
 
75
                showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.default"));                
 
76
            Button defaultFontButton = new Button(styles, SWT.PUSH);
 
77
            defaultFontButton.setLayoutData(makeButtonData());
 
78
            defaultFontButton.setText(TuxGuitar.getProperty("choose"));
 
79
            defaultFontButton.addSelectionListener(new SelectionAdapter() {                     
 
80
                        public void widgetSelected(SelectionEvent arg0) {
 
81
                                FontData[] datas = null;
 
82
                                if(defaultFontData != null){
 
83
                                        Font font = new Font(getDisplay(),defaultFontData);
 
84
                                        datas = font.getFontData();
 
85
                                        font.dispose();
 
86
                                }
 
87
                                if(datas == null){
 
88
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getDefaultFont().getFontData();
 
89
                                }                                       
 
90
                                FontDialog fontDialog = new FontDialog(getShell());
 
91
                                fontDialog.setFontList(datas);
 
92
                                FontData data = fontDialog.open();
 
93
                                if(data != null){
 
94
                                        defaultFontData = data;
 
95
                                }
 
96
                        }                       
 
97
                });
 
98
                                
 
99
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.note"));           
 
100
            Button noteFontButton = new Button(styles, SWT.PUSH);
 
101
            noteFontButton.setLayoutData(makeButtonData());
 
102
            noteFontButton.setText(TuxGuitar.getProperty("choose"));
 
103
            noteFontButton.addSelectionListener(new SelectionAdapter() {                        
 
104
                        public void widgetSelected(SelectionEvent arg0) {
 
105
                                FontData[] datas = null;
 
106
                                if(noteFontData != null){
 
107
                                        Font font = new Font(getDisplay(),noteFontData);
 
108
                                        datas = font.getFontData();
 
109
                                        font.dispose();
 
110
                                }
 
111
                                if(datas == null){
 
112
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getNoteFont().getFontData();
 
113
                                }                                               
 
114
                                FontDialog fontDialog = new FontDialog(getShell());
 
115
                                fontDialog.setFontList(datas);
 
116
                                FontData data = fontDialog.open();
 
117
                                if(data != null){
 
118
                                        noteFontData = data;
 
119
                                }
 
120
                        }                       
 
121
                });
 
122
                                
 
123
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.time-signature"));         
 
124
            Button timeSignatureButton = new Button(styles, SWT.PUSH);
 
125
            timeSignatureButton.setLayoutData(makeButtonData());
 
126
            timeSignatureButton.setText(TuxGuitar.getProperty("choose"));
 
127
            timeSignatureButton.addSelectionListener(new SelectionAdapter() {                   
 
128
                        public void widgetSelected(SelectionEvent arg0) {
 
129
                                FontData[] datas = null;
 
130
                                if(timeSignatureFontData != null){
 
131
                                        Font font = new Font(getDisplay(),timeSignatureFontData);
 
132
                                        datas = font.getFontData();
 
133
                                        font.dispose();
 
134
                                }
 
135
                                if(datas == null){
 
136
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getTimeSignatureFont().getFontData();
 
137
                                }                                               
 
138
                                FontDialog fontDialog = new FontDialog(getShell());
 
139
                                fontDialog.setFontList(datas);
 
140
                                FontData data = fontDialog.open();
 
141
                                if(data != null){
 
142
                                        timeSignatureFontData = data;
 
143
                                }
 
144
                        }                       
 
145
                });                 
 
146
 
 
147
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.printer-default"));                
 
148
            Button printerDefaultFontButton = new Button(styles, SWT.PUSH);
 
149
            printerDefaultFontButton.setLayoutData(makeButtonData());
 
150
            printerDefaultFontButton.setText(TuxGuitar.getProperty("choose"));
 
151
            printerDefaultFontButton.addSelectionListener(new SelectionAdapter() {                      
 
152
                        public void widgetSelected(SelectionEvent arg0) {
 
153
                                FontData[] datas = null;
 
154
                                if(printerDefaultFontData != null){
 
155
                                        Font font = new Font(getDisplay(),printerDefaultFontData);
 
156
                                        datas = font.getFontData();
 
157
                                        font.dispose();
 
158
                                }
 
159
                                if(datas == null){
 
160
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getPrinterDefaultFont().getFontData();
 
161
                                }                                       
 
162
                                FontDialog fontDialog = new FontDialog(getShell());
 
163
                                fontDialog.setFontList(datas);
 
164
                                FontData data = fontDialog.open();
 
165
                                if(data != null){
 
166
                                        printerDefaultFontData = data;
 
167
                                }
 
168
                        }                       
 
169
                });
 
170
                                
 
171
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.printer-note"));           
 
172
            Button printerNoteFontButton = new Button(styles, SWT.PUSH);
 
173
            printerNoteFontButton.setLayoutData(makeButtonData());
 
174
            printerNoteFontButton.setText(TuxGuitar.getProperty("choose"));
 
175
            printerNoteFontButton.addSelectionListener(new SelectionAdapter() {                 
 
176
                        public void widgetSelected(SelectionEvent arg0) {
 
177
                                FontData[] datas = null;
 
178
                                if(printerNoteFontData != null){
 
179
                                        Font font = new Font(getDisplay(),printerNoteFontData);
 
180
                                        datas = font.getFontData();
 
181
                                        font.dispose();
 
182
                                }
 
183
                                if(datas == null){
 
184
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getPrinterNoteFont().getFontData();
 
185
                                }                                               
 
186
                                FontDialog fontDialog = new FontDialog(getShell());
 
187
                                fontDialog.setFontList(datas);
 
188
                                FontData data = fontDialog.open();
 
189
                                if(data != null){
 
190
                                        printerNoteFontData = data;
 
191
                                }
 
192
                        }                       
 
193
                });
 
194
                        
 
195
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.font.printer-time-signature"));         
 
196
            Button printerTimeSignatureButton = new Button(styles, SWT.PUSH);
 
197
            printerTimeSignatureButton.setLayoutData(makeButtonData());
 
198
            printerTimeSignatureButton.setText(TuxGuitar.getProperty("choose"));
 
199
            printerTimeSignatureButton.addSelectionListener(new SelectionAdapter() {                    
 
200
                        public void widgetSelected(SelectionEvent arg0) {
 
201
                                FontData[] datas = null;
 
202
                                if(printerTimeSignatureFontData != null){
 
203
                                        Font font = new Font(getDisplay(),printerTimeSignatureFontData);
 
204
                                        datas = font.getFontData();
 
205
                                        font.dispose();
 
206
                                }
 
207
                                if(datas == null){
 
208
                                        datas = TuxGuitar.instance().getTablatureEditor().getTablature().getPrinterTimeSignatureFont().getFontData();
 
209
                                }                                               
 
210
                                FontDialog fontDialog = new FontDialog(getShell());
 
211
                                fontDialog.setFontList(datas);
 
212
                                FontData data = fontDialog.open();
 
213
                                if(data != null){
 
214
                                        printerTimeSignatureFontData = data;
 
215
                                }
 
216
                        }                       
 
217
                });                 
 
218
            
 
219
            showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.color.score-note"));
 
220
        final Button scoreNoteColorButton = new Button(styles, SWT.PUSH);
 
221
        scoreNoteColorButton.setLayoutData(makeButtonData());
 
222
        setButtonColor(scoreNoteColorButton,this.scoreNoteRGB);
 
223
        scoreNoteColorButton.addSelectionListener(new SelectionAdapter() {
 
224
            public void widgetSelected(SelectionEvent event) {
 
225
                ColorDialog dlg = new ColorDialog(getShell());
 
226
                dlg.setRGB(getDisplay().getSystemColor(SWT.COLOR_BLACK).getRGB());
 
227
                dlg.setText(TuxGuitar.getProperty("choose-color"));
 
228
                RGB rgb = dlg.open();
 
229
                if (rgb != null) {
 
230
                        scoreNoteRGB = new RGB(rgb.red,rgb.green,rgb.blue);
 
231
                    setButtonColor(scoreNoteColorButton,rgb);                        
 
232
                }
 
233
            }
 
234
        });
 
235
        
 
236
        showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.color.tab-note"));
 
237
        final Button tabNoteColorButton = new Button(styles, SWT.PUSH);
 
238
        tabNoteColorButton.setLayoutData(makeButtonData());
 
239
        setButtonColor(tabNoteColorButton,this.tabNoteRGB);
 
240
        tabNoteColorButton.addSelectionListener(new SelectionAdapter() {
 
241
            public void widgetSelected(SelectionEvent event) {
 
242
                ColorDialog dlg = new ColorDialog(getShell());
 
243
                dlg.setRGB(getDisplay().getSystemColor(SWT.COLOR_BLACK).getRGB());
 
244
                dlg.setText(TuxGuitar.getProperty("choose-color"));
 
245
                RGB rgb = dlg.open();
 
246
                if (rgb != null) {
 
247
                        tabNoteRGB = new RGB(rgb.red,rgb.green,rgb.blue);
 
248
                    setButtonColor(tabNoteColorButton,rgb);                        
 
249
                }
 
250
            }
 
251
        });               
 
252
        
 
253
        showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.color.play-note"));
 
254
        final Button playNoteColorButton = new Button(styles, SWT.PUSH);
 
255
        playNoteColorButton.setLayoutData(makeButtonData());
 
256
        setButtonColor(playNoteColorButton, this.playNoteRGB);
 
257
        playNoteColorButton.addSelectionListener(new SelectionAdapter() {
 
258
            public void widgetSelected(SelectionEvent event) {
 
259
                ColorDialog dlg = new ColorDialog(getShell());
 
260
                dlg.setRGB(getDisplay().getSystemColor(SWT.COLOR_BLACK).getRGB());
 
261
                dlg.setText(TuxGuitar.getProperty("choose-color"));
 
262
                RGB rgb = dlg.open();
 
263
                if (rgb != null) {
 
264
                        playNoteRGB = new RGB(rgb.red,rgb.green,rgb.blue);
 
265
                    setButtonColor(playNoteColorButton,rgb);                        
 
266
                }
 
267
            }
 
268
        });            
 
269
        
 
270
        showLabel(styles,SWT.LEFT | SWT.WRAP,SWT.NORMAL,0,TuxGuitar.getProperty("settings.config.styles.color.lines"));
 
271
        final Button linesColorButton = new Button(styles, SWT.PUSH);
 
272
        linesColorButton.setLayoutData(makeButtonData());
 
273
        setButtonColor(linesColorButton, this.linesRGB);
 
274
        linesColorButton.addSelectionListener(new SelectionAdapter() {
 
275
            public void widgetSelected(SelectionEvent event) {
 
276
                ColorDialog dlg = new ColorDialog(getShell());
 
277
                dlg.setRGB(getDisplay().getSystemColor(SWT.COLOR_BLACK).getRGB());
 
278
                dlg.setText(TuxGuitar.getProperty("choose-color"));
 
279
                RGB rgb = dlg.open();
 
280
                if (rgb != null) {
 
281
                        linesRGB = new RGB(rgb.red,rgb.green,rgb.blue);
 
282
                    setButtonColor(linesColorButton,rgb);                        
 
283
                }
 
284
            }
 
285
        });                  
 
286
    }                        
 
287
   
 
288
        public GridData makeButtonData(){
 
289
                GridData data = new GridData(SWT.RIGHT,SWT.CENTER,true,true);
 
290
        data.minimumWidth = BUTTON_WIDTH;
 
291
        data.minimumHeight = BUTTON_HEIGHT;
 
292
                return data;
 
293
        }
 
294
    
 
295
    private void setButtonColor(Button button,RGB rgb) {
 
296
        Color color = new Color(getDisplay(),rgb);
 
297
        Image image = new Image(getDisplay(),(BUTTON_WIDTH - 10),(BUTTON_HEIGHT - 10));
 
298
        GC gc = new GC(image);
 
299
        gc.setBackground(color);
 
300
        gc.fillRectangle(0, 0, (BUTTON_WIDTH - 10), (BUTTON_HEIGHT - 10));        
 
301
        gc.dispose();
 
302
        button.setImage(image);
 
303
    }        
 
304
    
 
305
    public void updateConfig(){                 
 
306
        if(defaultFontData != null){
 
307
                getConfig().setProperty(ConfigKeys.FONT_DEFAULT,defaultFontData.getName() + "," + defaultFontData.getHeight()  + "," + defaultFontData.getStyle());
 
308
        }
 
309
        if(noteFontData != null){
 
310
                getConfig().setProperty(ConfigKeys.FONT_NOTE,noteFontData.getName() + "," + noteFontData.getHeight() + "," + noteFontData.getStyle());
 
311
        }
 
312
        if(timeSignatureFontData != null){
 
313
                getConfig().setProperty(ConfigKeys.FONT_TIME_SIGNATURE,timeSignatureFontData.getName() + "," + timeSignatureFontData.getHeight() + "," + timeSignatureFontData.getStyle());             
 
314
        }   
 
315
        if(printerDefaultFontData != null){
 
316
                getConfig().setProperty(ConfigKeys.FONT_PRINTER_DEFAULT,printerDefaultFontData.getName() + "," + printerDefaultFontData.getHeight()  + "," + printerDefaultFontData.getStyle());
 
317
        }
 
318
        if(printerNoteFontData != null){
 
319
                getConfig().setProperty(ConfigKeys.FONT_PRINTER_NOTE,printerNoteFontData.getName() + "," + printerNoteFontData.getHeight() + "," + printerNoteFontData.getStyle());
 
320
        }
 
321
        if(printerTimeSignatureFontData != null){
 
322
                getConfig().setProperty(ConfigKeys.FONT_PRINTER_TIME_SIGNATURE,printerTimeSignatureFontData.getName() + "," + printerTimeSignatureFontData.getHeight() + "," + printerTimeSignatureFontData.getStyle());                
 
323
        }               
 
324
        if(scoreNoteRGB != null){
 
325
                getConfig().setProperty(ConfigKeys.COLOR_SCORE_NOTE,scoreNoteRGB.red + "," + scoreNoteRGB.green + "," + scoreNoteRGB.blue);
 
326
        }
 
327
        if(tabNoteRGB != null){
 
328
                getConfig().setProperty(ConfigKeys.COLOR_TAB_NOTE,tabNoteRGB.red + "," + tabNoteRGB.green + "," + tabNoteRGB.blue);
 
329
        }
 
330
        if(playNoteRGB != null){
 
331
                getConfig().setProperty(ConfigKeys.COLOR_PLAY_NOTE,playNoteRGB.red + "," + playNoteRGB.green + "," + playNoteRGB.blue);
 
332
        }                  
 
333
        if(linesRGB != null){
 
334
                getConfig().setProperty(ConfigKeys.COLOR_LINE,linesRGB.red + "," + linesRGB.green + "," + linesRGB.blue);
 
335
        }                 
 
336
    }
 
337
    
 
338
    public void applyConfig(boolean force){
 
339
        TuxGuitar.instance().loadStyles();
 
340
    }
 
341
}
 
 
b'\\ No newline at end of file'