← Back to branch summary

~ubuntu-branches/ubuntu/vivid/drmips/vivid-backports

« back to all changes in this revision

Viewing changes to src/pc/DrMIPS/src/com/jtattoo/plaf/acryl/AcrylBorders.java

  • Committer: Package Import Robot
  • Author(s): Bruno Nova
  • Date: 2014-09-27 12:24:17 UTC
  • Revision ID: package-import@ubuntu.com-20140927122417-2gadkwt9k0u7j4zu
Tags: upstream-1.2.3
Import upstream version 1.2.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pc/DrMIPS/src/com/jtattoo/plaf/acryl/AcrylBorders.java
 
1
/*
 
2
* Copyright (c) 2002 and later by MH Software-Entwicklung. All Rights Reserved.
 
3
*  
 
4
* JTattoo is multiple licensed. If your are an open source developer you can use
 
5
* it under the terms and conditions of the GNU General Public License version 2.0
 
6
* or later as published by the Free Software Foundation.
 
7
*  
 
8
* see: gpl-2.0.txt
 
9
* 
 
10
* If you pay for a license you will become a registered user who could use the
 
11
* software under the terms and conditions of the GNU Lesser General Public License
 
12
* version 2.0 or later with classpath exception as published by the Free Software
 
13
* Foundation.
 
14
* 
 
15
* see: lgpl-2.0.txt
 
16
* see: classpath-exception.txt
 
17
* 
 
18
* Registered users could also use JTattoo under the terms and conditions of the 
 
19
* Apache License, Version 2.0 as published by the Apache Software Foundation.
 
20
*  
 
21
* see: APACHE-LICENSE-2.0.txt
 
22
*/
 
23
 
 
24
package com.jtattoo.plaf.acryl;
 
25
 
 
26
import com.jtattoo.plaf.*;
 
27
import java.awt.*;
 
28
import javax.swing.AbstractButton;
 
29
import javax.swing.ButtonModel;
 
30
import javax.swing.border.AbstractBorder;
 
31
import javax.swing.border.Border;
 
32
import javax.swing.plaf.UIResource;
 
33
 
 
34
/**
 
35
 * @author Michael Hagen
 
36
 */
 
37
public class AcrylBorders extends BaseBorders {
 
38
 
 
39
    //------------------------------------------------------------------------------------
 
40
    // Lazy access methods
 
41
    //------------------------------------------------------------------------------------
 
42
    public static Border getTextBorder() {
 
43
        if (textFieldBorder == null) {
 
44
            textFieldBorder = new TextFieldBorder();
 
45
        }
 
46
        return textFieldBorder;
 
47
    }
 
48
 
 
49
    public static Border getSpinnerBorder() {
 
50
        if (spinnerBorder == null) {
 
51
            spinnerBorder = new SpinnerBorder();
 
52
        }
 
53
        return spinnerBorder;
 
54
    }
 
55
 
 
56
    public static Border getTextFieldBorder() {
 
57
        return getTextBorder();
 
58
    }
 
59
 
 
60
    public static Border getComboBoxBorder() {
 
61
        if (comboBoxBorder == null) {
 
62
            comboBoxBorder = new ComboBoxBorder();
 
63
        }
 
64
        return comboBoxBorder;
 
65
    }
 
66
 
 
67
    public static Border getScrollPaneBorder() {
 
68
        if (scrollPaneBorder == null) {
 
69
            scrollPaneBorder = new ScrollPaneBorder(false);
 
70
        }
 
71
        return scrollPaneBorder;
 
72
    }
 
73
 
 
74
    public static Border getTableScrollPaneBorder() {
 
75
        if (tableScrollPaneBorder == null) {
 
76
            tableScrollPaneBorder = new ScrollPaneBorder(true);
 
77
        }
 
78
        return tableScrollPaneBorder;
 
79
    }
 
80
 
 
81
    public static Border getButtonBorder() {
 
82
        if (buttonBorder == null) {
 
83
            buttonBorder = new ButtonBorder();
 
84
        }
 
85
        return buttonBorder;
 
86
    }
 
87
 
 
88
    public static Border getToggleButtonBorder() {
 
89
        return getButtonBorder();
 
90
    }
 
91
 
 
92
    public static Border getRolloverToolButtonBorder() {
 
93
        if (rolloverToolButtonBorder == null) {
 
94
            rolloverToolButtonBorder = new RolloverToolButtonBorder();
 
95
        }
 
96
        return rolloverToolButtonBorder;
 
97
    }
 
98
 
 
99
    public static Border getInternalFrameBorder() {
 
100
        if (internalFrameBorder == null) {
 
101
            internalFrameBorder = new InternalFrameBorder();
 
102
        }
 
103
        return internalFrameBorder;
 
104
    }
 
105
 
 
106
    //------------------------------------------------------------------------------------
 
107
    // Implementation of border classes
 
108
    //------------------------------------------------------------------------------------
 
109
    public static class TextFieldBorder extends AbstractBorder implements UIResource {
 
110
 
 
111
        private static final Insets insets = new Insets(2, 2, 2, 2);
 
112
 
 
113
        public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
 
114
            Color borderColor = ColorHelper.brighter(AbstractLookAndFeel.getTheme().getFrameColor(), 50);
 
115
            g.setColor(borderColor);
 
116
            g.drawRect(x, y, width - 1, height - 1);
 
117
        }
 
118
 
 
119
        public Insets getBorderInsets(Component c) {
 
120
            return new Insets(insets.top, insets.left, insets.bottom, insets.right);
 
121
        }
 
122
 
 
123
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
124
            borderInsets.left = insets.left;
 
125
            borderInsets.top = insets.top;
 
126
            borderInsets.right = insets.right;
 
127
            borderInsets.bottom = insets.bottom;
 
128
            return borderInsets;
 
129
        }
 
130
 
 
131
    } // class TextFieldBorder
 
132
 
 
133
    public static class SpinnerBorder extends AbstractBorder implements UIResource {
 
134
 
 
135
        private static final Insets insets = new Insets(1, 1, 1, 1);
 
136
 
 
137
        public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
 
138
            Color borderColor = ColorHelper.brighter(AbstractLookAndFeel.getTheme().getFrameColor(), 50);
 
139
            g.setColor(borderColor);
 
140
            g.drawRect(x, y, width - 1, height - 1);
 
141
        }
 
142
 
 
143
        public Insets getBorderInsets(Component c) {
 
144
            return new Insets(insets.top, insets.left, insets.bottom, insets.right);
 
145
        }
 
146
 
 
147
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
148
            borderInsets.left = insets.left;
 
149
            borderInsets.top = insets.top;
 
150
            borderInsets.right = insets.right;
 
151
            borderInsets.bottom = insets.bottom;
 
152
            return borderInsets;
 
153
        }
 
154
 
 
155
    } // class SpinnerBorder
 
156
 
 
157
    public static class ComboBoxBorder extends AbstractBorder implements UIResource {
 
158
 
 
159
        private static final Insets insets = new Insets(1, 1, 1, 1);
 
160
 
 
161
        public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
 
162
            Color borderColor = ColorHelper.brighter(AbstractLookAndFeel.getTheme().getFrameColor(), 50);
 
163
            g.setColor(borderColor);
 
164
            g.drawRect(x, y, width - 1, height - 1);
 
165
        }
 
166
 
 
167
        public Insets getBorderInsets(Component c) {
 
168
            return new Insets(insets.top, insets.left, insets.bottom, insets.right);
 
169
        }
 
170
 
 
171
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
172
            borderInsets.left = insets.left;
 
173
            borderInsets.top = insets.top;
 
174
            borderInsets.right = insets.right;
 
175
            borderInsets.bottom = insets.bottom;
 
176
            return borderInsets;
 
177
        }
 
178
 
 
179
    } // class ComboBoxBorder
 
180
 
 
181
    public static class ScrollPaneBorder extends AbstractBorder implements UIResource {
 
182
 
 
183
        private static final Insets insets = new Insets(2, 2, 2, 2);
 
184
        private static final Insets tableInsets = new Insets(1, 1, 1, 1);
 
185
 
 
186
        private boolean tableBorder = false;
 
187
 
 
188
        public ScrollPaneBorder(boolean tableBorder) {
 
189
            this.tableBorder = tableBorder;
 
190
        }
 
191
 
 
192
        public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
 
193
            g.setColor(ColorHelper.brighter(AbstractLookAndFeel.getTheme().getFrameColor(), 50));
 
194
            g.drawRect(x, y, w - 1, h - 1);
 
195
            g.setColor(ColorHelper.brighter(AbstractLookAndFeel.getTheme().getBackgroundColor(), 50));
 
196
            g.drawRect(x + 1, y + 1, w - 3, h - 3);
 
197
        }
 
198
 
 
199
        public Insets getBorderInsets(Component c) {
 
200
            if (tableBorder) {
 
201
                return new Insets(tableInsets.top, tableInsets.left, tableInsets.bottom, tableInsets.right);
 
202
            } else {
 
203
                return new Insets(insets.top, insets.left, insets.bottom, insets.right);
 
204
            }
 
205
        }
 
206
 
 
207
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
208
            Insets ins = getBorderInsets(c);
 
209
            borderInsets.left = ins.left;
 
210
            borderInsets.top = ins.top;
 
211
            borderInsets.right = ins.right;
 
212
            borderInsets.bottom = ins.bottom;
 
213
            return borderInsets;
 
214
        }
 
215
 
 
216
    } // class ScrollPaneBorder
 
217
 
 
218
    public static class ButtonBorder implements Border, UIResource {
 
219
 
 
220
        private static final Insets insets = new Insets(3, 6, 3, 6);
 
221
 
 
222
        public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
 
223
            AbstractButton button = (AbstractButton) c;
 
224
            ButtonModel model = button.getModel();
 
225
            Graphics2D g2D = (Graphics2D) g;
 
226
            Color frameColor = ColorHelper.brighter(AbstractLookAndFeel.getTheme().getFrameColor(), 50);
 
227
            if (!JTattooUtilities.isFrameActive(button)) {
 
228
                frameColor = ColorHelper.brighter(frameColor, 30);
 
229
            }
 
230
            if (model.isRollover() && !model.isPressed() && !model.isArmed()) {
 
231
                frameColor = AbstractLookAndFeel.getTheme().getRolloverColorDark();
 
232
            }
 
233
            Object savedRederingHint = g2D.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
 
234
            g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
235
 
 
236
            g2D.setColor(Color.white);
 
237
            g2D.drawRoundRect(x, y, w - 1, h - 1, 6, 6);
 
238
 
 
239
            g2D.setColor(frameColor);
 
240
            g2D.drawRoundRect(x, y, w - 2, h - 2, 6, 6);
 
241
 
 
242
            g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, savedRederingHint);
 
243
        }
 
244
 
 
245
        public Insets getBorderInsets(Component c) {
 
246
            return insets;
 
247
        }
 
248
 
 
249
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
250
            borderInsets.left = insets.left;
 
251
            borderInsets.top = insets.top;
 
252
            borderInsets.right = insets.right;
 
253
            borderInsets.bottom = insets.bottom;
 
254
            return borderInsets;
 
255
        }
 
256
 
 
257
        public boolean isBorderOpaque() {
 
258
            return true;
 
259
        }
 
260
    } // class ButtonBorder
 
261
 
 
262
    public static class RolloverToolButtonBorder implements Border, UIResource {
 
263
 
 
264
        private static final Insets insets = new Insets(2, 2, 2, 2);
 
265
 
 
266
        public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
 
267
            AbstractButton button = (AbstractButton) c;
 
268
            ButtonModel model = button.getModel();
 
269
            if (model.isEnabled()) {
 
270
                if ((model.isPressed() && model.isArmed()) || model.isSelected()) {
 
271
                    Color frameColor = ColorHelper.darker(AbstractLookAndFeel.getToolbarBackgroundColor(), 30);
 
272
                    g.setColor(frameColor);
 
273
                    g.drawRect(x, y, w - 1, h - 1);
 
274
                    Graphics2D g2D = (Graphics2D) g;
 
275
                    Composite savedComposit = g2D.getComposite();
 
276
                    AlphaComposite alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.1f);
 
277
                    g2D.setComposite(alpha);
 
278
                    g.setColor(Color.black);
 
279
                    g.fillRect(x + 1, y + 1, w - 2, h - 2);
 
280
                    g2D.setComposite(savedComposit);
 
281
                } else if (model.isRollover()) {
 
282
                    Color frameColor = AbstractLookAndFeel.getToolbarBackgroundColor();
 
283
                    Color frameHiColor = ColorHelper.darker(frameColor, 5);
 
284
                    Color frameLoColor = ColorHelper.darker(frameColor, 30);
 
285
                    JTattooUtilities.draw3DBorder(g, frameHiColor, frameLoColor, x, y, w, h);
 
286
                    frameHiColor = Color.white;
 
287
                    frameLoColor = ColorHelper.brighter(frameLoColor, 60);
 
288
                    JTattooUtilities.draw3DBorder(g, frameHiColor, frameLoColor, x + 1, y + 1, w - 2, h - 2);
 
289
 
 
290
                    Graphics2D g2D = (Graphics2D) g;
 
291
                    Composite composite = g2D.getComposite();
 
292
                    AlphaComposite alpha = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, 0.4f);
 
293
                    g2D.setComposite(alpha);
 
294
                    g.setColor(Color.white);
 
295
                    g.fillRect(x + 2, y + 2, w - 4, h - 4);
 
296
                    g2D.setComposite(composite);
 
297
                } else if (model.isSelected()) {
 
298
                    Color frameColor = AbstractLookAndFeel.getToolbarBackgroundColor();
 
299
                    Color frameHiColor = Color.white;
 
300
                    Color frameLoColor = ColorHelper.darker(frameColor, 30);
 
301
                    JTattooUtilities.draw3DBorder(g, frameLoColor, frameHiColor, x, y, w, h);
 
302
                }
 
303
            }
 
304
        }
 
305
 
 
306
        public Insets getBorderInsets(Component c) {
 
307
            return new Insets(insets.top, insets.left, insets.bottom, insets.right);
 
308
        }
 
309
 
 
310
        public Insets getBorderInsets(Component c, Insets borderInsets) {
 
311
            borderInsets.left = insets.left;
 
312
            borderInsets.top = insets.top;
 
313
            borderInsets.right = insets.right;
 
314
            borderInsets.bottom = insets.bottom;
 
315
            return borderInsets;
 
316
        }
 
317
 
 
318
        public boolean isBorderOpaque() {
 
319
            return true;
 
320
        }
 
321
    } // class RolloverToolButtonBorder
 
322
 
 
323
    public static class InternalFrameBorder extends BaseInternalFrameBorder {
 
324
 
 
325
        public InternalFrameBorder() {
 
326
            insets.top = 3;
 
327
        }
 
328
 
 
329
        public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
 
330
            boolean active = isActive(c);
 
331
            int th = getTitleHeight(c);
 
332
            Color titleColor = ColorHelper.brighter(AbstractLookAndFeel.getWindowInactiveTitleColorLight(), 10);
 
333
            Color borderColor = AbstractLookAndFeel.getWindowInactiveTitleColorLight();
 
334
            Color frameColor = ColorHelper.darker(AbstractLookAndFeel.getWindowInactiveBorderColor(), 10);
 
335
            if (active) {
 
336
                titleColor = AbstractLookAndFeel.getWindowTitleColorLight();
 
337
                borderColor = AbstractLookAndFeel.getWindowTitleColorLight();
 
338
                frameColor = ColorHelper.darker(AbstractLookAndFeel.getWindowBorderColor(), 10);
 
339
            }
 
340
            g.setColor(titleColor);
 
341
            g.fillRect(x, y + 1, w, insets.top - 1);
 
342
            g.setColor(borderColor);
 
343
            g.fillRect(x + 1, y + h - dw, w - 2, dw - 1);
 
344
 
 
345
            if (active) {
 
346
                JTattooUtilities.fillHorGradient(g, AbstractLookAndFeel.getTheme().getWindowTitleColors(), 1, insets.top, dw, th + 1);
 
347
                JTattooUtilities.fillHorGradient(g, AbstractLookAndFeel.getTheme().getWindowTitleColors(), w - dw, insets.top, dw, th + 1);
 
348
            } else {
 
349
                JTattooUtilities.fillHorGradient(g, AbstractLookAndFeel.getTheme().getWindowInactiveTitleColors(), 1, insets.top, dw - 1, th + 1);
 
350
                JTattooUtilities.fillHorGradient(g, AbstractLookAndFeel.getTheme().getWindowInactiveTitleColors(), w - dw, insets.top, dw - 1, th + 1);
 
351
            }
 
352
            g.setColor(borderColor);
 
353
            g.fillRect(1, insets.top + th + 1, dw - 1, h - th - dw);
 
354
            g.fillRect(w - dw, insets.top + th + 1, dw - 1, h - th - dw);
 
355
 
 
356
            g.setColor(frameColor);
 
357
            g.drawRect(x, y, w - 1, h - 1);
 
358
            g.drawLine(x + dw - 1, y + insets.top + th, x + dw - 1, y + h - dw);
 
359
            g.drawLine(x + w - dw, y + insets.top + th, x + w - dw, y + h - dw);
 
360
            g.drawLine(x + dw - 1, y + h - dw, x + w - dw, y + h - dw);
 
361
        }
 
362
 
 
363
    } // class InternalFrameBorder
 
364
 
 
365
} // class AcrylBorders
 
366