/[debian]/libjgoodies-looks-java/trunk/debian/patches/02_windows.patch
ViewVC logotype

Annotation of /libjgoodies-looks-java/trunk/debian/patches/02_windows.patch

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1326 - (hide annotations)
Thu Jun 5 22:42:46 2008 UTC (12 years, 10 months ago) by gregoa
File size: 257169 byte(s) 
Change patch system from dpatch to quilt.
1 gregoa 1326 Author: <gregor+debian@comodo.priv.at>
2     Description: remove windows look
3     --- libjgoodies-looks-java.orig/build.xml
4     +++ libjgoodies-looks-java/build.xml
5     @@ -90,7 +90,7 @@
6     <!-- C O M P I L A T I O N -->
7     <!-- ***************************************************************** -->
8     <target name="compile"
9     - depends="compile-core, compile-demo, compile-tests"
10     + depends="compile-core, compile-tests"
11     description="Compiles the l&amp;fs, demo, and tests." />
12    
13     <!-- ***************************************************************** -->
14     @@ -115,33 +115,11 @@
15     <copy toDir="${build.core.dir}" >
16     <fileset dir="${src.core.dir}"
17     includes="com/jgoodies/looks/common/shadow.png,
18     - com/jgoodies/looks/plastic/icons/**/*,
19     - com/jgoodies/looks/windows/icons/**/*" />
20     + com/jgoodies/looks/plastic/icons/**/*" />
21     </copy>
22     </target>
23    
24     <!-- ***************************************************************** -->
25     - <target name="compile-demo" depends="compile-core"
26     - description="Compiles the demo sources." >
27     - <javac
28     - srcdir ="${src.demo.dir}"
29     - destdir ="${build.demo.dir}"
30     - encoding ="${build.encoding}"
31     - executable ="${build.compile.executable}"
32     - fork ="${build.compile.fork}"
33     - debug ="${build.compile.debug}"
34     - depend ="${build.compile.depend}"
35     - deprecation ="${build.compile.deprecation}"
36     - nowarn ="${build.compile.nowarn}"
37     - optimize ="${build.compile.optimize}"
38     - source ="${build.compile.source}"
39     - target ="${build.compile.target}"
40     - verbose ="${build.compile.verbose}"
41     - classpathref ="classpath.demo" />
42     - <!-- bootclasspath="${build.boot.classpath}" -->
43     - </target>
44     -
45     - <!-- ***************************************************************** -->
46     <target name="compile-tests" depends="compile-core" if="junit.jar.present"
47     description="Compiles the unit tests." >
48     <mkdir dir="${build.test.dir}"/>
49     @@ -209,7 +187,7 @@
50     <!-- J A R -->
51     <!-- ***************************************************************** -->
52     <target name="jar"
53     - depends="jar-all, jar-plastic, jar-windows, jar-demo, jar-tiny, jar-fonttest"
54     + depends="jar-all, jar-plastic, jar-demo, jar-tiny, jar-fonttest"
55     description="Creates library and example jars." >
56     </target>
57    
58     @@ -264,20 +242,6 @@
59     </target>
60    
61     <!-- ***************************************************************** -->
62     - <target name="jar-windows" depends="compile, manifest"
63     - description="Creates the library jar for the windows l&amp;f." >
64     - <jar
65     - destfile="${build.windows.jar}"
66     - manifest="${build.manifest}" >
67     - <fileset dir="${build.core.dir}"
68     - excludes="com/jgoodies/looks/plastic/**/*" />
69     - <zipfileset dir="${descriptors.dir}"
70     - includes="windows.txt"
71     - fullpath="META-INF/services/javax.swing.LookAndFeel" />
72     - </jar>
73     - </target>
74     -
75     - <!-- ***************************************************************** -->
76     <target name="jar-demo" depends="jar-plastic"
77     description="Creates the demo jar." >
78     <jar
79     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/Options.java
80     +++ libjgoodies-looks-java/src/core/com/jgoodies/looks/Options.java
81     @@ -38,8 +38,6 @@
82    
83     import com.jgoodies.looks.common.ShadowPopup;
84     import com.jgoodies.looks.plastic.PlasticLookAndFeel;
85     -import com.jgoodies.looks.windows.WindowsLookAndFeel;
86     -import com.sun.java.swing.plaf.windows.WindowsComboBoxUI;
87    
88     /**
89     * Provides access to optional features of the JGoodies L&amp;Fs
90     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsArrowButton.java
91     +++ /dev/null
92     @@ -1,142 +0,0 @@
93     -/*
94     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
95     - *
96     - * Redistribution and use in source and binary forms, with or without
97     - * modification, are permitted provided that the following conditions are met:
98     - *
99     - * o Redistributions of source code must retain the above copyright notice,
100     - * this list of conditions and the following disclaimer.
101     - *
102     - * o Redistributions in binary form must reproduce the above copyright notice,
103     - * this list of conditions and the following disclaimer in the documentation
104     - * and/or other materials provided with the distribution.
105     - *
106     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
107     - * its contributors may be used to endorse or promote products derived
108     - * from this software without specific prior written permission.
109     - *
110     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
111     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
112     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
113     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
114     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
115     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
116     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
117     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
118     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
119     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
120     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
121     - */
122     -
123     -package com.jgoodies.looks.windows;
124     -
125     -import java.awt.Color;
126     -import java.awt.Dimension;
127     -import java.awt.Graphics;
128     -
129     -import javax.swing.UIManager;
130     -import javax.swing.plaf.basic.BasicArrowButton;
131     -
132     -/**
133     - * The JGoodies Windows Look&amp;Feel implementation for
134     - * arrow buttons used in scrollbars and comboboxes.
135     - * <p>
136     - * It differs from <code>BasicArrowButton</code> in that the preferred size
137     - * is always a square.
138     - * It differs from <code>WindowsScrollBarUI.WindowsArrowButton</code>
139     - * in that the triangle is black and positioned correctly.
140     - *
141     - * @author Karsten Lentzsch
142     - * @version $Revision: 1.3 $
143     - */
144     -final class WindowsArrowButton extends BasicArrowButton {
145     -
146     - public WindowsArrowButton(int direction) {
147     - super(direction);
148     - }
149     -
150     - public Dimension getPreferredSize() {
151     - int width = Math.max(5, UIManager.getInt("ScrollBar.width"));
152     - return new Dimension(width, width);
153     - }
154     -
155     - public void paintTriangle(
156     - Graphics g,
157     - int x,
158     - int y,
159     - int size,
160     - int triangleDirection,
161     - boolean isEnabled) {
162     - Color oldColor = g.getColor();
163     - int mid, i, j;
164     -
165     - j = 0;
166     - size = Math.max(size, 2);
167     - mid = (size - 1) / 2; // Modified by JGoodies
168     -
169     - g.translate(x, y);
170     - if (isEnabled)
171     - g.setColor(Color.black);
172     - else
173     - g.setColor(UIManager.getColor("controlShadow"));
174     -
175     - switch (triangleDirection) {
176     - case NORTH :
177     - for (i = 0; i < size; i++) {
178     - g.drawLine(mid - i, i, mid + i, i);
179     - }
180     - if (!isEnabled) {
181     - g.setColor(UIManager.getColor("controlLtHighlight"));
182     - g.drawLine(mid - i + 2, i, mid + i, i);
183     - }
184     - break;
185     - case SOUTH :
186     - if (!isEnabled) {
187     - g.translate(1, 1);
188     - g.setColor(UIManager.getColor("controlLtHighlight"));
189     - for (i = size - 1; i >= 0; i--) {
190     - g.drawLine(mid - i, j, mid + i, j);
191     - j++;
192     - }
193     - g.translate(-1, -1);
194     - g.setColor(UIManager.getColor("controlShadow"));
195     - }
196     -
197     - j = 0;
198     - for (i = size - 1; i >= 0; i--) {
199     - g.drawLine(mid - i, j, mid + i, j);
200     - j++;
201     - }
202     - break;
203     - case WEST :
204     - for (i = 0; i < size; i++) {
205     - g.drawLine(i, mid - i, i, mid + i);
206     - }
207     - if (!isEnabled) {
208     - g.setColor(UIManager.getColor("controlLtHighlight"));
209     - g.drawLine(i, mid - i + 2, i, mid + i);
210     - }
211     - break;
212     - case EAST :
213     - if (!isEnabled) {
214     - g.translate(1, 1);
215     - g.setColor(UIManager.getColor("controlLtHighlight"));
216     - for (i = size - 1; i >= 0; i--) {
217     - g.drawLine(j, mid - i, j, mid + i);
218     - j++;
219     - }
220     - g.translate(-1, -1);
221     - g.setColor(UIManager.getColor("controlShadow"));
222     - }
223     -
224     - j = 0;
225     - for (i = size - 1; i >= 0; i--) {
226     - g.drawLine(j, mid - i, j, mid + i);
227     - j++;
228     - }
229     - break;
230     - }
231     - g.translate(-x, -y);
232     - g.setColor(oldColor);
233     - }
234     -}
235     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsBorders.java
236     +++ /dev/null
237     @@ -1,589 +0,0 @@
238     -/*
239     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
240     - *
241     - * Redistribution and use in source and binary forms, with or without
242     - * modification, are permitted provided that the following conditions are met:
243     - *
244     - * o Redistributions of source code must retain the above copyright notice,
245     - * this list of conditions and the following disclaimer.
246     - *
247     - * o Redistributions in binary form must reproduce the above copyright notice,
248     - * this list of conditions and the following disclaimer in the documentation
249     - * and/or other materials provided with the distribution.
250     - *
251     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
252     - * its contributors may be used to endorse or promote products derived
253     - * from this software without specific prior written permission.
254     - *
255     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
256     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
257     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
258     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
259     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
260     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
261     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
262     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
263     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
264     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
265     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
266     - */
267     -
268     -package com.jgoodies.looks.windows;
269     -
270     -import java.awt.Color;
271     -import java.awt.Component;
272     -import java.awt.Graphics;
273     -import java.awt.Insets;
274     -
275     -import javax.swing.AbstractButton;
276     -import javax.swing.ButtonModel;
277     -import javax.swing.JButton;
278     -import javax.swing.JToggleButton;
279     -import javax.swing.UIDefaults;
280     -import javax.swing.UIManager;
281     -import javax.swing.border.AbstractBorder;
282     -import javax.swing.border.Border;
283     -import javax.swing.border.CompoundBorder;
284     -import javax.swing.border.EmptyBorder;
285     -import javax.swing.plaf.BorderUIResource;
286     -import javax.swing.plaf.UIResource;
287     -import javax.swing.plaf.basic.BasicBorders;
288     -import javax.swing.plaf.basic.BasicGraphicsUtils;
289     -
290     -/**
291     - * Consists of static inner classes that define different
292     - * <code>Borders</code> used in the JGoodies Windows look&amp;feel.
293     - *
294     - * @author Karsten Lentzsch
295     - * @version $Revision: 1.5 $
296     - */
297     -final class WindowsBorders {
298     -
299     - private WindowsBorders() {
300     - // Overrides default constructor; prevents instantiation.
301     - }
302     -
303     - // Accessing and Creating Borders ***************************************************
304     -
305     - private static Border menuBorder;
306     - private static Border xpMenuBorder;
307     - private static Border menuItemBorder;
308     - private static Border popupMenuBorder;
309     - private static Border noMarginPopupMenuBorder;
310     - private static Border separatorBorder;
311     - private static Border etchedBorder;
312     - private static Border menuBarHeaderBorder;
313     - private static Border toolBarHeaderBorder;
314     - private static Border rolloverButtonBorder;
315     -
316     -
317     - /**
318     - * Returns a <code>Border</code> for a <code>JButton</code>.
319     - */
320     - public static Border getButtonBorder() {
321     - UIDefaults table = UIManager.getLookAndFeelDefaults();
322     - Border outerBorder = new ButtonBorder(table.getColor("Button.shadow"),
323     - table.getColor("Button.darkShadow"), table
324     - .getColor("Button.light"), table
325     - .getColor("Button.highlight"), table
326     - .getColor("controlText"));
327     -
328     - Border buttonBorder = new BorderUIResource.CompoundBorderUIResource(
329     - outerBorder, new BasicBorders.MarginBorder());
330     - return buttonBorder;
331     - }
332     -
333     -
334     - /**
335     - * Returns a Border for a JMenu in classic mode.
336     - */
337     - static Border getMenuBorder() {
338     - if (menuBorder == null) {
339     - menuBorder = new BorderUIResource.CompoundBorderUIResource(
340     - new MenuBorder(),
341     - new BasicBorders.MarginBorder());
342     - }
343     - return menuBorder;
344     - }
345     -
346     - /**
347     - * Returns a Border for a JMenu in XP mode.
348     - */
349     - static Border getXPMenuBorder() {
350     - if (xpMenuBorder == null) {
351     - xpMenuBorder = new BasicBorders.MarginBorder();
352     - }
353     - return xpMenuBorder;
354     - }
355     -
356     - /**
357     - * Returns a border instance for a <code>JMenuItem</code>.
358     - */
359     - static Border getMenuItemBorder() {
360     - if (menuItemBorder == null) {
361     - menuItemBorder = new BorderUIResource(new BasicBorders.MarginBorder());
362     - }
363     - return menuItemBorder;
364     - }
365     -
366     - /**
367     - * Returns a separator border instance for <code>JMenuBar</code> or <code>JToolBar</code>.
368     - */
369     - static Border getSeparatorBorder() {
370     - if (separatorBorder == null) {
371     - separatorBorder = new BorderUIResource.CompoundBorderUIResource(
372     - new SeparatorBorder(),
373     - new BasicBorders.MarginBorder());
374     - }
375     - return separatorBorder;
376     - }
377     -
378     - /**
379     - * Returns an etched border instance for <code>JMenuBar</code> or <code>JToolBar</code>.
380     - */
381     - static Border getEtchedBorder() {
382     - if (etchedBorder == null) {
383     - etchedBorder = new BorderUIResource.CompoundBorderUIResource(
384     - new EtchedBorder(),
385     - new BasicBorders.MarginBorder());
386     - }
387     - return etchedBorder;
388     - }
389     -
390     - /**
391     - * Returns a special border for a <code>JMenuBar</code> that
392     - * is used in a header just above a <code>JToolBar</code>.
393     - */
394     - static Border getMenuBarHeaderBorder() {
395     - if (menuBarHeaderBorder == null) {
396     - menuBarHeaderBorder = new BorderUIResource.CompoundBorderUIResource(
397     - new MenuBarHeaderBorder(),
398     - new BasicBorders.MarginBorder());
399     - }
400     - return menuBarHeaderBorder;
401     - }
402     -
403     - /**
404     - * Returns a border instance for a <code>JPopupMenu</code>.
405     - *
406     - * @return the lazily created popup menu border
407     - */
408     - static Border getPopupMenuBorder() {
409     - if (popupMenuBorder == null) {
410     - popupMenuBorder = new PopupMenuBorder();
411     - }
412     - return popupMenuBorder;
413     - }
414     -
415     - /**
416     - * Returns a no-margin border instance for a <code>JPopupMenu</code>.
417     - *
418     - * @return the lazily created no-margin popup menu border
419     - */
420     - static Border getNoMarginPopupMenuBorder() {
421     - if (noMarginPopupMenuBorder == null) {
422     - noMarginPopupMenuBorder = new NoMarginPopupMenuBorder();
423     - }
424     - return noMarginPopupMenuBorder;
425     - }
426     -
427     - /**
428     - * Returns a special border for a <code>JToolBar</code> that
429     - * is used in a header just below a <code>JMenuBar</code>.
430     - */
431     - static Border getToolBarHeaderBorder() {
432     - if (toolBarHeaderBorder == null) {
433     - toolBarHeaderBorder = new BorderUIResource.CompoundBorderUIResource(
434     - new ToolBarHeaderBorder(),
435     - new BasicBorders.MarginBorder());
436     - }
437     - return toolBarHeaderBorder;
438     - }
439     -
440     - /**
441     - * Returns a border for a rollover <code>AbstractButton</code>.
442     - */
443     - static Border getRolloverButtonBorder() {
444     - if (rolloverButtonBorder == null) {
445     - rolloverButtonBorder = new CompoundBorder( // No UIResource
446     - new RolloverButtonBorder(),
447     - new RolloverMarginBorder());
448     - }
449     - return rolloverButtonBorder;
450     - }
451     -
452     -
453     - // Helper Classes *******************************************************************
454     -
455     -
456     - // Copied from BasicBorders, has correct black color for the outer default rectangle.
457     - private static final class ButtonBorder extends AbstractBorder implements UIResource {
458     -
459     - private static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
460     -
461     - private final Color shadow;
462     - private final Color darkShadow;
463     - private final Color highlight;
464     - private final Color lightHighlight;
465     - private final Color defaultColor;
466     -
467     - public ButtonBorder(Color shadow, Color darkShadow,
468     - Color highlight, Color lightHighlight, Color defaultColor) {
469     - this.shadow = shadow;
470     - this.darkShadow = darkShadow;
471     - this.highlight = highlight;
472     - this.lightHighlight = lightHighlight;
473     - this.defaultColor = defaultColor;
474     - }
475     -
476     - public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
477     - boolean isPressed = false;
478     - boolean isDefault = false;
479     -
480     - if (c instanceof AbstractButton) {
481     - AbstractButton b = (AbstractButton) c;
482     - ButtonModel model = b.getModel();
483     -
484     - isPressed = model.isPressed() && model.isArmed();
485     - if (c instanceof JButton) {
486     - isDefault = ((JButton) c).isDefaultButton();
487     - }
488     - }
489     - drawBezel(g, x, y, width, height, isPressed, isDefault, shadow,
490     - darkShadow, highlight, lightHighlight, defaultColor);
491     - }
492     -
493     - public Insets getBorderInsets(Component c) {
494     - return getBorderInsets(c, EMPTY_INSETS);
495     - }
496     -
497     - public Insets getBorderInsets(Component c, Insets insets) {
498     - // leave room for default visual
499     - insets.top = 2;
500     - insets.left = insets.bottom = insets.right = 3;
501     - return insets;
502     - }
503     -
504     - }
505     -
506     - /**
507     - * An abstract superclass for borders.
508     - */
509     - private abstract static class AbstractButtonBorder extends AbstractBorder implements UIResource {
510     -
511     - private static final Insets INSETS = new Insets(2, 2, 2, 2);
512     -
513     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
514     - AbstractButton button = (AbstractButton) c;
515     - ButtonModel model = button.getModel();
516     -
517     - //
518     - //System.out.println("Pressed=" + model.isPressed() + "; armed=" + model.isArmed());
519     - //if (!model.isArmed()) return;
520     -
521     - if (model.isPressed())
522     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h);
523     - else
524     - WindowsUtils.drawFlush3DBorder(g, x, y, w, h);
525     - }
526     -
527     - public Insets getBorderInsets(Component c) { return INSETS; }
528     - }
529     -
530     -
531     - /**
532     - * A border used for <code>Buttons</code> that have the rollover property enabled.
533     - */
534     - private static final class RolloverButtonBorder extends AbstractButtonBorder {
535     -
536     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
537     - AbstractButton b = (AbstractButton) c;
538     - ButtonModel model = b.getModel();
539     -
540     - if (!model.isEnabled())
541     - return;
542     -
543     - if (!(c instanceof JToggleButton)) {
544     - if (model.isRollover()) // && !( model.isPressed() && !model.isArmed()))
545     - super.paintBorder(c, g, x, y, w, h);
546     - return;
547     - }
548     -
549     - if (model.isSelected())
550     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h);
551     - else if (model.isRollover()) {
552     - super.paintBorder(c, g, x, y, w, h);
553     - /*
554     - if (model.isPressed() && model.isArmed()) {
555     - ExtMetalUtils.drawPressed3DBorder(g, x, y, w, h);
556     - } else {
557     - ExtMetalUtils.drawFlush3DBorder(g, x, y, w, h);
558     - }*/
559     - }
560     - }
561     - }
562     -
563     -
564     - /**
565     - * A border which is like a Margin border but it will only honor the margin
566     - * if the margin has been explicitly set by the developer.
567     - */
568     - private static final class RolloverMarginBorder extends EmptyBorder {
569     -
570     - private RolloverMarginBorder() {
571     - super(1, 1, 1, 1);
572     - }
573     -
574     -
575     - public Insets getBorderInsets(Component c) {
576     - return getBorderInsets(c, new Insets(0, 0, 0, 0));
577     - }
578     -
579     -
580     - public Insets getBorderInsets(Component c, Insets insets) {
581     - Insets margin = null;
582     -
583     - if (c instanceof AbstractButton) {
584     - margin = ((AbstractButton) c).getMargin();
585     - }
586     - if (margin == null || margin instanceof UIResource) {
587     - // default margin so replace
588     - insets.left = left;
589     - insets.top = top;
590     - insets.right = right;
591     - insets.bottom = bottom;
592     - } else {
593     - // Margin which has been explicitly set by the user.
594     - insets.left = margin.left;
595     - insets.top = margin.top;
596     - insets.right = margin.right;
597     - insets.bottom = margin.bottom;
598     - }
599     - return insets;
600     - }
601     - }
602     -
603     - /**
604     - * A border that looks like a separator line; used for menu bars and tool bars.
605     - */
606     - private static final class SeparatorBorder extends AbstractBorder implements UIResource {
607     -
608     - private static final Insets INSETS = new Insets(0, 3, 2, 1);
609     -
610     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
611     - g.translate(x, y);
612     - g.setColor( UIManager.getColor("Separator.foreground"));
613     - g.drawLine( 0, h - 2, w - 1, h - 2 );
614     -
615     - g.setColor( UIManager.getColor("Separator.background"));
616     - g.drawLine( 0, h - 1, w - 1, h - 1 );
617     - g.translate(-x, -y);
618     - }
619     -
620     - public Insets getBorderInsets(Component c) { return INSETS; }
621     - }
622     -
623     -
624     - /**
625     - * A thin raised border.
626     - */
627     - static final class ThinRaisedBorder extends AbstractBorder implements UIResource {
628     -
629     - private static final Insets INSETS = new Insets(1, 1, 1, 1);
630     -
631     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
632     - WindowsUtils.drawFlush3DBorder(g, x, y, w, h);
633     - }
634     -
635     - public Insets getBorderInsets(Component c) { return INSETS; }
636     - }
637     -
638     -
639     - /**
640     - * A thin lowered border.
641     - */
642     - static final class ThinLoweredBorder extends AbstractBorder implements UIResource {
643     -
644     - private static final Insets INSETS = new Insets(1, 1, 1, 1);
645     -
646     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
647     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h);
648     - }
649     -
650     - public Insets getBorderInsets(Component c) { return INSETS; }
651     - }
652     -
653     -
654     - /**
655     - * A border used for menu bars and tool bars in <code>HeaderStyle.SINGLE</code>.
656     - * The bar is wrapped by an inner thin raised border,
657     - * which in turn is wrapped by an outer thin lowered border.
658     - */
659     - private static final class EtchedBorder extends AbstractBorder implements UIResource {
660     -
661     - private static final Insets INSETS = new Insets(2, 2, 2, 2);
662     -
663     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
664     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h);
665     - WindowsUtils.drawFlush3DBorder (g, x + 1, y + 1, w - 2, h - 2);
666     - }
667     -
668     - public Insets getBorderInsets(Component c) { return INSETS; }
669     - }
670     -
671     -
672     - /**
673     - * A border used for menu bars in <code>HeaderStyle.BOTH</code>.
674     - * The menu bar and tool bar are wrapped by a thin raised border,
675     - * both together are wrapped by a thin lowered border.
676     - */
677     - private static final class MenuBarHeaderBorder extends AbstractBorder implements UIResource {
678     -
679     - private static final Insets INSETS = new Insets(2, 2, 1, 2);
680     -
681     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
682     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h + 1);
683     - WindowsUtils.drawFlush3DBorder (g, x + 1, y + 1, w - 2, h - 1);
684     - }
685     -
686     - public Insets getBorderInsets(Component c) { return INSETS; }
687     - }
688     -
689     -
690     - private static final class PopupMenuBorder extends AbstractBorder implements UIResource {
691     -
692     - private static final Insets INSETS = new Insets(3, 3, 3, 3);
693     -
694     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
695     - g.translate(x, y);
696     - g.setColor(UIManager.getColor("controlShadow"));
697     - g.drawRect(0, 0, w-1, h-1);
698     - g.setColor(UIManager.getColor("MenuItem.background"));
699     - g.drawRect(1, 1, w-3, h-3);
700     - g.drawRect(2, 2, w-5, h-5);
701     - g.translate(-x, -y);
702     - }
703     -
704     - public Insets getBorderInsets(Component c) { return INSETS; }
705     - }
706     -
707     -
708     - private static final class NoMarginPopupMenuBorder extends AbstractBorder implements UIResource {
709     -
710     - private static final Insets INSETS = new Insets(1, 1, 1, 1);
711     -
712     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
713     - g.translate(x, y);
714     - g.setColor(UIManager.getColor("controlShadow"));
715     - g.drawRect(0, 0, w-1, h-1);
716     -// g.setColor(UIManager.getColor("MenuItem.background"));
717     -// g.drawRect(1, 1, 0, h-3);
718     - g.translate(-x, -y);
719     - }
720     -
721     - public Insets getBorderInsets(Component c) { return INSETS; }
722     - }
723     -
724     - /**
725     - * A border used for tool bars in <code>HeaderStyle.BOTH</code>.
726     - * The menu bar and tool bar are wrapped by a thin raised border,
727     - * both together are wrapped by a thin lowered border.
728     - */
729     - private static final class ToolBarHeaderBorder extends AbstractBorder implements UIResource {
730     -
731     - private static final Insets INSETS = new Insets(1, 2, 2, 2);
732     -
733     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
734     - WindowsUtils.drawPressed3DBorder(g, x, y - 1, w, h + 1);
735     - WindowsUtils.drawFlush3DBorder (g, x + 1, y, w - 2, h - 1);
736     - }
737     -
738     - public Insets getBorderInsets(Component c) { return INSETS; }
739     - }
740     -
741     -
742     - /**
743     - * A border used for menus.
744     - */
745     - private static final class MenuBorder extends AbstractBorder implements UIResource {
746     -
747     - private static final Insets INSETS = new Insets(1, 1, 1, 1);
748     -
749     - public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
750     - AbstractButton b = (AbstractButton) c;
751     - ButtonModel model = b.getModel();
752     -
753     - //System.out.println("rollover=" + model.isRollover());
754     - //if ((3 < 4) || model.isRollover()) { // && !(model.isPressed() && !model.isArmed())) {
755     - if (model.isSelected())
756     - WindowsUtils.drawPressed3DBorder(g, x, y, w, h);
757     - else if (model.isRollover())
758     - WindowsUtils.drawFlush3DBorder(g, x, y, w, h);
759     - //}
760     - }
761     -
762     - public Insets getBorderInsets(Component c) { return INSETS; }
763     -
764     - }
765     -
766     -
767     - // Helper Code **********************************************************************
768     -
769     - // Copied from BasicGraphicsUtils, has an additional color for the default rectangle.
770     - private static void drawBezel(Graphics g, int x, int y, int w, int h,
771     - boolean isPressed, boolean isDefault,
772     - Color shadow, Color darkShadow,
773     - Color highlight, Color lightHighlight, Color defaultColor)
774     - {
775     - Color oldColor = g.getColor(); // Make no net change to g
776     - g.translate(x, y);
777     -
778     - if (isPressed && isDefault) {
779     - g.setColor(darkShadow);
780     - g.drawRect(0, 0, w - 1, h - 1);
781     - g.setColor(shadow);
782     - g.drawRect(1, 1, w - 3, h - 3);
783     - } else if (isPressed) {
784     - BasicGraphicsUtils.drawLoweredBezel(g, x, y, w, h,
785     - shadow, darkShadow, highlight, lightHighlight);
786     - } else if (isDefault) {
787     - g.setColor(defaultColor);
788     - g.drawRect(0, 0, w-1, h-1);
789     -
790     - g.setColor(lightHighlight);
791     - g.drawLine(1, 1, 1, h-3);
792     - g.drawLine(2, 1, w-3, 1);
793     -
794     - g.setColor(highlight);
795     - g.drawLine(2, 2, 2, h-4);
796     - g.drawLine(3, 2, w-4, 2);
797     -
798     - g.setColor(shadow);
799     - g.drawLine(2, h-3, w-3, h-3);
800     - g.drawLine(w-3, 2, w-3, h-4);
801     -
802     - g.setColor(darkShadow);
803     - g.drawLine(1, h-2, w-2, h-2);
804     - g.drawLine(w-2, h-2, w-2, 1);
805     - } else {
806     - g.setColor(lightHighlight);
807     - g.drawLine(0, 0, 0, h-1);
808     - g.drawLine(1, 0, w-2, 0);
809     -
810     - g.setColor(highlight);
811     - g.drawLine(1, 1, 1, h-3);
812     - g.drawLine(2, 1, w-3, 1);
813     -
814     - g.setColor(shadow);
815     - g.drawLine(1, h-2, w-2, h-2);
816     - g.drawLine(w-2, 1, w-2, h-3);
817     -
818     - g.setColor(darkShadow);
819     - g.drawLine(0, h-1, w-1, h-1);
820     - g.drawLine(w-1, h-1, w-1, 0);
821     - }
822     - g.translate(-x, -y);
823     - g.setColor(oldColor);
824     - }
825     -
826     -}
827     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsButtonUI.java
828     +++ /dev/null
829     @@ -1,71 +0,0 @@
830     -/*
831     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
832     - *
833     - * Redistribution and use in source and binary forms, with or without
834     - * modification, are permitted provided that the following conditions are met:
835     - *
836     - * o Redistributions of source code must retain the above copyright notice,
837     - * this list of conditions and the following disclaimer.
838     - *
839     - * o Redistributions in binary form must reproduce the above copyright notice,
840     - * this list of conditions and the following disclaimer in the documentation
841     - * and/or other materials provided with the distribution.
842     - *
843     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
844     - * its contributors may be used to endorse or promote products derived
845     - * from this software without specific prior written permission.
846     - *
847     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
848     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
849     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
850     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
851     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
852     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
853     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
854     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
855     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
856     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
857     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
858     - */
859     -
860     -package com.jgoodies.looks.windows;
861     -
862     -import java.awt.Dimension;
863     -
864     -import javax.swing.AbstractButton;
865     -import javax.swing.JComponent;
866     -import javax.swing.plaf.ComponentUI;
867     -import javax.swing.plaf.basic.BasicGraphicsUtils;
868     -
869     -/**
870     - * The JGoodies Windows look&amp;feel implementation of <code>ButtonUI</code>.<p>
871     - *
872     - * Unlike its superclass it returns even and odd preferred heights.
873     - *
874     - * @author Karsten Lentzsch
875     - * @version $Revision: 1.3 $
876     - */
877     -public final class WindowsButtonUI extends com.sun.java.swing.plaf.windows.WindowsButtonUI {
878     -
879     - public static ComponentUI createUI(JComponent b) {
880     - return new WindowsButtonUI();
881     - }
882     -
883     - public Dimension getPreferredSize(JComponent c) {
884     - AbstractButton b = (AbstractButton) c;
885     - Dimension d = BasicGraphicsUtils.getPreferredButtonSize(b, b
886     - .getIconTextGap());
887     -
888     - /* Ensure that the width of the button is odd,
889     - * to improve the painting of the dashed focus line
890     - */
891     - if (d != null && b.isFocusPainted()) {
892     - if (d.width % 2 == 0) {
893     - d.width += 1;
894     - }
895     - }
896     - return d;
897     - }
898     -
899     -
900     -}
901     \ No newline at end of file
902     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsComboBoxEditor.java
903     +++ /dev/null
904     @@ -1,71 +0,0 @@
905     -/*
906     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
907     - *
908     - * Redistribution and use in source and binary forms, with or without
909     - * modification, are permitted provided that the following conditions are met:
910     - *
911     - * o Redistributions of source code must retain the above copyright notice,
912     - * this list of conditions and the following disclaimer.
913     - *
914     - * o Redistributions in binary form must reproduce the above copyright notice,
915     - * this list of conditions and the following disclaimer in the documentation
916     - * and/or other materials provided with the distribution.
917     - *
918     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
919     - * its contributors may be used to endorse or promote products derived
920     - * from this software without specific prior written permission.
921     - *
922     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
923     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
924     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
925     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
926     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
927     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
928     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
929     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
930     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
931     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
932     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
933     - */
934     -
935     -package com.jgoodies.looks.windows;
936     -
937     -import javax.swing.plaf.basic.BasicComboBoxEditor;
938     -
939     -import com.jgoodies.looks.common.ComboBoxEditorTextField;
940     -
941     -/**
942     - * The default editor for editable combo boxes in the
943     - * JGoodies Windows Look&amp;Feel.<p>
944     - *
945     - * It differs from its superclass in that the border is quite the same as for
946     - * text fields: a compound border with an inner <code>MarginBorder</code>.
947     - *
948     - * @author Karsten Lentzsch
949     - * @version $Revision: 1.6 $
950     - */
951     -class WindowsComboBoxEditor extends BasicComboBoxEditor {
952     -
953     - WindowsComboBoxEditor(boolean isTableCellEditor) {
954     - editor = new ComboBoxEditorTextField(isTableCellEditor);
955     - }
956     -
957     - public void setItem(Object item) {
958     - super.setItem(item);
959     - editor.selectAll();
960     - }
961     -
962     - /**
963     - * A subclass of BasicComboBoxEditor that implements UIResource.
964     - * BasicComboBoxEditor and WindowsComboBoxEditor don't implement UIResource
965     - * directly so that applications can safely override the cellRenderer
966     - * property with BasicListCellRenderer subclasses.
967     - */
968     - static final class UIResource extends WindowsComboBoxEditor implements
969     - javax.swing.plaf.UIResource {
970     -
971     - UIResource(boolean isTableCellEditor) {
972     - super(isTableCellEditor);
973     - }
974     - }
975     -}
976     \ No newline at end of file
977     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsComboBoxUI.java
978     +++ /dev/null
979     @@ -1,557 +0,0 @@
980     -/*
981     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
982     - *
983     - * Redistribution and use in source and binary forms, with or without
984     - * modification, are permitted provided that the following conditions are met:
985     - *
986     - * o Redistributions of source code must retain the above copyright notice,
987     - * this list of conditions and the following disclaimer.
988     - *
989     - * o Redistributions in binary form must reproduce the above copyright notice,
990     - * this list of conditions and the following disclaimer in the documentation
991     - * and/or other materials provided with the distribution.
992     - *
993     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
994     - * its contributors may be used to endorse or promote products derived
995     - * from this software without specific prior written permission.
996     - *
997     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
998     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
999     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1000     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1001     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1002     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1003     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1004     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1005     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
1006     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
1007     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1008     - */
1009     -
1010     -package com.jgoodies.looks.windows;
1011     -
1012     -import java.awt.*;
1013     -import java.beans.PropertyChangeEvent;
1014     -import java.beans.PropertyChangeListener;
1015     -
1016     -import javax.swing.*;
1017     -import javax.swing.border.Border;
1018     -import javax.swing.border.EmptyBorder;
1019     -import javax.swing.plaf.ComponentUI;
1020     -import javax.swing.plaf.UIResource;
1021     -import javax.swing.plaf.basic.BasicComboBoxRenderer;
1022     -import javax.swing.plaf.basic.BasicComboBoxUI;
1023     -import javax.swing.plaf.basic.BasicComboPopup;
1024     -import javax.swing.plaf.basic.ComboPopup;
1025     -
1026     -import com.jgoodies.looks.LookUtils;
1027     -import com.jgoodies.looks.Options;
1028     -import com.sun.java.swing.plaf.windows.WindowsTextFieldUI;
1029     -
1030     -/**
1031     - * The JGoodies Windows Look&amp;Feel implementation of
1032     - * {@link javax.swing.plaf.ComboBoxUI}.
1033     - * Corrects the editor insets for editable combo boxes
1034     - * as well as the render insets for non-editable combos. And it has
1035     - * the same height as text fields - unless you change the renderer.<p>
1036     - *
1037     - * Also, this class offers to use the combo's popup prototype display value
1038     - * to compute the popup menu width. This is an optional feature of
1039     - * the JGoodies Windows L&amp;f implemented via a client property key.
1040     - *
1041     - * @author Karsten Lentzsch
1042     - * @version $Revision: 1.19 $
1043     - *
1044     - * @see Options#COMBO_POPUP_PROTOTYPE_DISPLAY_VALUE_KEY
1045     - */
1046     -public class WindowsComboBoxUI extends com.sun.java.swing.plaf.windows.WindowsComboBoxUI {
1047     -
1048     - private static final String CELL_EDITOR_KEY = "JComboBox.isTableCellEditor";
1049     -
1050     - /**
1051     - * Used to determine the minimum height of a text field,
1052     - * which in turn is used to answer the combobox's minimum height.
1053     - */
1054     - private static final JTextField PHANTOM = new JTextField("Phantom");
1055     -
1056     - private static final Insets EMPTY_INSETS = new Insets(0, 0, 0, 0);
1057     - private static final Border EMPTY_BORDER = new EmptyBorder(EMPTY_INSETS);
1058     -
1059     -
1060     - private boolean tableCellEditor;
1061     - private PropertyChangeListener propertyChangeListener;
1062     -
1063     -
1064     - // ************************************************************************
1065     -
1066     - public static ComponentUI createUI(JComponent b) {
1067     - ensurePhantomHasWindowsUI();
1068     - return new WindowsComboBoxUI();
1069     - }
1070     -
1071     -
1072     - /**
1073     - * Ensures that the phantom text field has a Windows text field UI.
1074     - */
1075     - private static void ensurePhantomHasWindowsUI() {
1076     - if (!(PHANTOM.getUI() instanceof WindowsTextFieldUI)) {
1077     - PHANTOM.updateUI();
1078     - }
1079     - }
1080     -
1081     -
1082     - // ************************************************************************
1083     -
1084     - public void installUI(JComponent c) {
1085     - super.installUI(c);
1086     - tableCellEditor = isTableCellEditor();
1087     - }
1088     -
1089     - protected void installListeners() {
1090     - super.installListeners();
1091     - propertyChangeListener = new TableCellEditorPropertyChangeHandler();
1092     - comboBox.addPropertyChangeListener(CELL_EDITOR_KEY, propertyChangeListener);
1093     - }
1094     -
1095     - protected void uninstallListeners() {
1096     - super.uninstallListeners();
1097     - comboBox.removePropertyChangeListener(CELL_EDITOR_KEY, propertyChangeListener);
1098     - propertyChangeListener = null;
1099     - }
1100     -
1101     -
1102     - /**
1103     - * Creates the arrow button that is to be used in the combo box.<p>
1104     - *
1105     - * Overridden to paint black triangles.
1106     - */
1107     - protected JButton createArrowButton() {
1108     - return LookUtils.IS_LAF_WINDOWS_XP_ENABLED
1109     - ? super.createArrowButton()
1110     - : new WindowsArrowButton(SwingConstants.SOUTH);
1111     - }
1112     -
1113     -
1114     - /**
1115     - * Creates the editor that is to be used in editable combo boxes.
1116     - * This method only gets called if a custom editor has not already
1117     - * been installed in the JComboBox.
1118     - */
1119     - protected ComboBoxEditor createEditor() {
1120     - return new com.jgoodies.looks.windows.WindowsComboBoxEditor.UIResource(tableCellEditor);
1121     - }
1122     -
1123     -
1124     - /**
1125     - * Creates a layout manager for managing the components which
1126     - * make up the combo box.<p>
1127     - *
1128     - * Overriden to use a layout that has a fixed width arrow button.
1129     - *
1130     - * @return an instance of a layout manager
1131     - */
1132     - protected LayoutManager createLayoutManager() {
1133     - return new WindowsComboBoxLayoutManager();
1134     - }
1135     -
1136     -
1137     - protected void configureEditor() {
1138     - super.configureEditor();
1139     - if (!comboBox.isEnabled()) {
1140     - editor.setBackground(UIManager.getColor("ComboBox.disabledBackground"));
1141     - }
1142     - }
1143     -
1144     - /**
1145     - * Creates a ComboPopup that honors the optional combo popup display value
1146     - * that is used to compute the popup menu width.
1147     - */
1148     - protected ComboPopup createPopup() {
1149     - return new WindowsComboPopup(comboBox);
1150     - }
1151     -
1152     -
1153     - /**
1154     - * Creates the default renderer that will be used in a non-editiable combo
1155     - * box. A default renderer will used only if a renderer has not been
1156     - * explicitly set with <code>setRenderer</code>.<p>
1157     - *
1158     - * This method differs from the superclass implementation in that
1159     - * it uses an empty border with the default left and right text insets,
1160     - * the same as used by a combo box editor.
1161     - *
1162     - * @return a <code>ListCellRender</code> used for the combo box
1163     - * @see javax.swing.JComboBox#setRenderer
1164     - */
1165     - protected ListCellRenderer createRenderer() {
1166     - if (tableCellEditor) {
1167     - return super.createRenderer();
1168     - }
1169     - BasicComboBoxRenderer renderer = new BasicComboBoxRenderer.UIResource();
1170     - renderer.setBorder(UIManager.getBorder("ComboBox.rendererBorder"));
1171     - return renderer;
1172     - }
1173     -
1174     -
1175     - /**
1176     - * The minumum size is the size of the display area plus insets plus the button.
1177     - */
1178     - public Dimension getMinimumSize(JComponent c) {
1179     - if (!isMinimumSizeDirty) {
1180     - return new Dimension(cachedMinimumSize);
1181     - }
1182     - Dimension size = getDisplaySize();
1183     - Insets insets = getInsets();
1184     - size.height += insets.top + insets.bottom;
1185     - int buttonWidth = getEditableButtonWidth();
1186     - size.width += insets.left + insets.right + buttonWidth;
1187     - // The combo editor benefits from extra space for the caret.
1188     - // To make editable and non-editable equally wide,
1189     - // we always add 1 pixel.
1190     - size.width += 1;
1191     -
1192     - // Honor corrections made in #paintCurrentValue
1193     - ListCellRenderer renderer = comboBox.getRenderer();
1194     - if (renderer instanceof JComponent) {
1195     - JComponent component = (JComponent) renderer;
1196     - Insets rendererInsets = component.getInsets();
1197     - Insets editorInsets = UIManager.getInsets("ComboBox.editorInsets");
1198     - int offsetLeft = Math.max(0, editorInsets.left - rendererInsets.left);
1199     - int offsetRight = Math.max(0, editorInsets.right - rendererInsets.right);
1200     - // int offsetTop = Math.max(0, editorInsets.top - rendererInsets.top);
1201     - // int offsetBottom = Math.max(0, editorInsets.bottom - rendererInsets.bottom);
1202     - size.width += offsetLeft + offsetRight;
1203     - //size.height += offsetTop + offsetBottom;
1204     - }
1205     -
1206     - // The height is oriented on the JTextField height
1207     - Dimension textFieldSize = PHANTOM.getMinimumSize();
1208     - size.height = (LookUtils.IS_OS_WINDOWS_VISTA && !LookUtils.IS_LAF_WINDOWS_XP_ENABLED)
1209     - ? textFieldSize.height
1210     - : Math.max(textFieldSize.height, size.height);
1211     -
1212     - cachedMinimumSize.setSize(size.width, size.height);
1213     - isMinimumSizeDirty = false;
1214     -
1215     - return new Dimension(size);
1216     - }
1217     -
1218     - /**
1219     - * Delegates to #getMinimumSize(Component).
1220     - * Overridden to return the same result in JDK 1.5 as in JDK 1.4.
1221     - */
1222     - public Dimension getPreferredSize(JComponent c) {
1223     - return getMinimumSize(c);
1224     - }
1225     -
1226     -
1227     - /**
1228     - * Paints the currently selected item.
1229     - */
1230     - public void paintCurrentValue(Graphics g, Rectangle bounds, boolean hasFocus) {
1231     - ListCellRenderer renderer = comboBox.getRenderer();
1232     - Component c;
1233     - boolean isVistaReadOnlyCombo = isVistaXPStyleReadOnlyCombo();
1234     -
1235     - if (hasFocus && !isPopupVisible(comboBox)) {
1236     - c = renderer.getListCellRendererComponent(listBox,
1237     - comboBox.getSelectedItem(),
1238     - -1,
1239     - true,
1240     - false);
1241     - } else {
1242     - c = renderer.getListCellRendererComponent(listBox,
1243     - comboBox.getSelectedItem(),
1244     - -1,
1245     - false,
1246     - false );
1247     - c.setBackground(UIManager.getColor("ComboBox.background"));
1248     - }
1249     - Border oldBorder = null;
1250     - Rectangle originalBounds = new Rectangle(bounds);
1251     - if ((c instanceof JComponent) && !tableCellEditor) {
1252     - JComponent component = (JComponent) c;
1253     - if (isRendererBorderRemovable(component)) {
1254     - oldBorder = component.getBorder();
1255     - component.setBorder(EMPTY_BORDER); //new WindowsBorders.DashedBorder(c.getForeground(), 1));
1256     - }
1257     - Insets rendererInsets = component.getInsets();
1258     - Insets editorInsets = UIManager.getInsets("ComboBox.editorInsets");
1259     - int offsetLeft = Math.max(0, editorInsets.left - rendererInsets.left);
1260     - int offsetRight = Math.max(0, editorInsets.right - rendererInsets.right);
1261     - int offsetTop = Math.max(0, editorInsets.top - rendererInsets.top);
1262     - int offsetBottom = Math.max(0, editorInsets.bottom - rendererInsets.bottom);
1263     - bounds.x += offsetLeft;
1264     - bounds.y += offsetTop;
1265     - bounds.width -= offsetLeft + offsetRight - 1;
1266     - bounds.height -= offsetTop + offsetBottom;
1267     - }
1268     -
1269     - c.setFont(comboBox.getFont());
1270     - if (hasFocus && !isPopupVisible(comboBox) && !isVistaReadOnlyCombo) {
1271     - c.setForeground(listBox.getSelectionForeground());
1272     - c.setBackground(listBox.getSelectionBackground());
1273     - } else {
1274     - if (comboBox.isEnabled()) {
1275     - c.setForeground(comboBox.getForeground());
1276     - c.setBackground(comboBox.getBackground());
1277     - } else {
1278     - c.setForeground(UIManager.getColor("ComboBox.disabledForeground"));
1279     - c.setBackground(UIManager.getColor("ComboBox.disabledBackground"));
1280     - }
1281     - }
1282     -
1283     - // Fix for 4238829: should lay out the JPanel.
1284     - boolean shouldValidate = c instanceof JPanel;
1285     -
1286     - Boolean oldOpaque = null;
1287     - if (isVistaReadOnlyCombo && (c instanceof JComponent) && !(c instanceof DefaultListCellRenderer)) {
1288     - oldOpaque = Boolean.valueOf(c.isOpaque());
1289     - ((JComponent) c).setOpaque(false);
1290     - }
1291     - currentValuePane.paintComponent(g, c, comboBox, bounds.x, bounds.y,
1292     - bounds.width, bounds.height, shouldValidate);
1293     - if (hasFocus) {
1294     - Color oldColor = g.getColor();
1295     - g.setColor(comboBox.getForeground());
1296     - if (isVistaReadOnlyCombo) {
1297     - int width = originalBounds.width - 2;
1298     - if ((width % 2) == 0) {
1299     - width += 1;
1300     - }
1301     - WindowsUtils.drawRoundedDashedRect(g,
1302     - originalBounds.x+1, originalBounds.y+1,
1303     - width, originalBounds.height-2);
1304     - } /*else {
1305     - BasicGraphicsUtils.drawDashedRect(g,
1306     - bounds.x, bounds.y, bounds.width, bounds.height);
1307     - }*/
1308     - g.setColor(oldColor);
1309     - }
1310     - if (oldOpaque != null) {
1311     - ((JComponent) c).setOpaque(oldOpaque.booleanValue());
1312     - }
1313     - if (oldBorder != null) {
1314     - ((JComponent) c).setBorder(oldBorder);
1315     - }
1316     - }
1317     -
1318     - /**
1319     - * Checks and answer whether the border of the given renderer component
1320     - * can be removed temporarily, so the combo's selection background will
1321     - * be consistent with the default renderer and native appearance.
1322     - * This test is invoked from <code>#paintCurrentValue</code>.<p>
1323     - *
1324     - * It is safe to remove an EmptyBorder if the component doesn't override
1325     - * <code>#update</code>, <code>#paint</code> and <code>#paintBorder</code>.
1326     - * Since we know the default renderer, we can remove its border.<p>
1327     - *
1328     - * Custom renderers may set a hint to make their border removable.
1329     - * To do so, set the client property "isBorderRemovable"
1330     - * to <code>Boolean.TRUE</code>. If this client property is set,
1331     - * its value will be returned. If it is not set, <code>true</code> is returned
1332     - * if and only if the component's border is an EmptyBorder.
1333     - *
1334     - * @param rendererComponent the renderer component to check
1335     - * @return true if the component's border can be removed, false if not
1336     - * @see #paintCurrentValue(Graphics, Rectangle, boolean)
1337     - */
1338     - protected boolean isRendererBorderRemovable(JComponent rendererComponent) {
1339     - if (rendererComponent instanceof BasicComboBoxRenderer.UIResource)
1340     - return true;
1341     - Object hint = rendererComponent.getClientProperty(Options.COMBO_RENDERER_IS_BORDER_REMOVABLE);
1342     - if (hint != null)
1343     - return Boolean.TRUE.equals(hint);
1344     - Border border = rendererComponent.getBorder();
1345     - return border instanceof EmptyBorder;
1346     - }
1347     -
1348     -
1349     - private boolean isVistaXPStyleReadOnlyCombo() {
1350     - return LookUtils.IS_OS_WINDOWS_VISTA
1351     - && LookUtils.IS_LAF_WINDOWS_XP_ENABLED
1352     - && !comboBox.isEditable();
1353     - }
1354     -
1355     -
1356     - /**
1357     - * Returns the area that is reserved for drawing the currently selected item.
1358     - */
1359     - protected Rectangle rectangleForCurrentValue() {
1360     - int width = comboBox.getWidth();
1361     - int height = comboBox.getHeight();
1362     - Insets insets = getInsets();
1363     - int buttonWidth = getEditableButtonWidth();
1364     - if (arrowButton != null) {
1365     - buttonWidth = arrowButton.getWidth();
1366     - }
1367     - if (comboBox.getComponentOrientation().isLeftToRight()) {
1368     - return new Rectangle(
1369     - insets.left,
1370     - insets.top,
1371     - width - (insets.left + insets.right + buttonWidth),
1372     - height - (insets.top + insets.bottom));
1373     - } else {
1374     - return new Rectangle(
1375     - insets.left + buttonWidth,
1376     - insets.top ,
1377     - width - (insets.left + insets.right + buttonWidth),
1378     - height - (insets.top + insets.bottom));
1379     - }
1380     - }
1381     -
1382     -
1383     - // Helper Code ************************************************************
1384     -
1385     - /**
1386     - * Computes and returns the width of the arrow button in editable state.
1387     - *
1388     - * @return the width of the arrow button in editable state
1389     - */
1390     - private int getEditableButtonWidth() {
1391     - return UIManager.getInt("ScrollBar.width");
1392     - }
1393     -
1394     - /**
1395     - * Checks and answers if this UI's combo has a client property
1396     - * that indicates that the combo is used as a table cell editor.
1397     - *
1398     - * @return <code>true</code> if the table cell editor client property
1399     - * is set to <code>Boolean.TRUE</code>, <code>false</code> otherwise
1400     - */
1401     - private boolean isTableCellEditor() {
1402     - return Boolean.TRUE.equals(comboBox.getClientProperty(CELL_EDITOR_KEY));
1403     - }
1404     -
1405     -
1406     - // Collaborator Classes ***************************************************
1407     -
1408     - /**
1409     - * This layout manager handles the 'standard' layout of combo boxes.
1410     - * It puts the arrow button to the right and the editor to the left.
1411     - * If there is no editor it still keeps the arrow button to the right.
1412     - *
1413     - * Overriden to use a fixed arrow button width.
1414     - */
1415     - private final class WindowsComboBoxLayoutManager
1416     - extends BasicComboBoxUI.ComboBoxLayoutManager {
1417     -
1418     - public void layoutContainer(Container parent) {
1419     - JComboBox cb = (JComboBox) parent;
1420     -
1421     - int width = cb.getWidth();
1422     - int height = cb.getHeight();
1423     -
1424     - Insets insets = getInsets();
1425     - int buttonWidth = getEditableButtonWidth();
1426     - int buttonHeight = height - (insets.top + insets.bottom);
1427     -
1428     - if (arrowButton != null) {
1429     - if (cb.getComponentOrientation().isLeftToRight()) {
1430     - arrowButton.setBounds(
1431     - width - (insets.right + buttonWidth),
1432     - insets.top,
1433     - buttonWidth,
1434     - buttonHeight);
1435     - } else {
1436     - arrowButton.setBounds(
1437     - insets.left,
1438     - insets.top,
1439     - buttonWidth,
1440     - buttonHeight);
1441     - }
1442     - }
1443     - if (editor != null) {
1444     - editor.setBounds(rectangleForCurrentValue());
1445     - }
1446     - }
1447     -
1448     - }
1449     -
1450     -
1451     - /**
1452     - * Differs from the BasicComboPopup in that it uses the standard
1453     - * popmenu border and honors an optional popup prototype display value.
1454     - */
1455     - private static final class WindowsComboPopup extends BasicComboPopup {
1456     -
1457     - private WindowsComboPopup(JComboBox combo) {
1458     - super(combo);
1459     - }
1460     -
1461     - /**
1462     - * Calculates the placement and size of the popup portion
1463     - * of the combo box based on the combo box location and
1464     - * the enclosing screen bounds. If no transformations are required,
1465     - * then the returned rectangle will have the same values
1466     - * as the parameters.<p>
1467     - *
1468     - * In addition to the superclass behavior, this class offers
1469     - * to use the combo's popup prototype display value to compute
1470     - * the popup menu width. This is an optional feature of
1471     - * the JGoodies Windows L&amp;f implemented via a client property key.<p>
1472     - *
1473     - * If a prototype is set, the popup width is the maximum of the
1474     - * combobox width and the prototype based popup width.
1475     - * For the latter the renderer is used to render the prototype.
1476     - * The prototype based popup width is the prototype's width
1477     - * plus the scrollbar width - if any. The scrollbar test checks
1478     - * if there are more items than the combo's maximum row count.
1479     - *
1480     - * @param px starting x location
1481     - * @param py starting y location
1482     - * @param pw starting width
1483     - * @param ph starting height
1484     - * @return a rectangle which represents the placement and size of the popup
1485     - *
1486     - * @see Options#COMBO_POPUP_PROTOTYPE_DISPLAY_VALUE_KEY
1487     - * @see JComboBox#getMaximumRowCount()
1488     - */
1489     - protected Rectangle computePopupBounds(int px, int py, int pw, int ph) {
1490     - Rectangle defaultBounds = super.computePopupBounds(px, py, pw, ph);
1491     - Object popupPrototypeDisplayValue = comboBox.getClientProperty(
1492     - Options.COMBO_POPUP_PROTOTYPE_DISPLAY_VALUE_KEY);
1493     - if (popupPrototypeDisplayValue == null) {
1494     - return defaultBounds;
1495     - }
1496     -
1497     - ListCellRenderer renderer = list.getCellRenderer();
1498     - Component c = renderer.getListCellRendererComponent(
1499     - list, popupPrototypeDisplayValue, -1, true, true);
1500     - pw = c.getPreferredSize().width;
1501     - boolean hasVerticalScrollBar =
1502     - comboBox.getItemCount() > comboBox.getMaximumRowCount();
1503     - if (hasVerticalScrollBar) {
1504     - // Add the scrollbar width.
1505     - JScrollBar verticalBar = scroller.getVerticalScrollBar();
1506     - pw += verticalBar.getPreferredSize().width;
1507     - }
1508     - Rectangle prototypeBasedBounds = super.computePopupBounds(px, py, pw, ph);
1509     - return prototypeBasedBounds.width > defaultBounds.width
1510     - ? prototypeBasedBounds
1511     - : defaultBounds;
1512     - }
1513     -
1514     - }
1515     -
1516     -
1517     - // Handling Combo Changes *************************************************
1518     -
1519     - /**
1520     - * Listens to changes in the table cell editor client property
1521     - * and updates the default editor - if any - to use the correct
1522     - * insets for this case.
1523     - */
1524     - private final class TableCellEditorPropertyChangeHandler implements PropertyChangeListener {
1525     - public void propertyChange(PropertyChangeEvent evt) {
1526     - tableCellEditor = isTableCellEditor();
1527     - if (comboBox.getRenderer() == null || comboBox.getRenderer() instanceof UIResource) {
1528     - comboBox.setRenderer(createRenderer());
1529     - }
1530     - if (comboBox.getEditor() == null || comboBox.getEditor() instanceof UIResource) {
1531     - comboBox.setEditor(createEditor());
1532     - }
1533     - }
1534     - }
1535     -
1536     -}
1537     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsFieldCaret.java
1538     +++ /dev/null
1539     @@ -1,347 +0,0 @@
1540     -/*
1541     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
1542     - *
1543     - * Redistribution and use in source and binary forms, with or without
1544     - * modification, are permitted provided that the following conditions are met:
1545     - *
1546     - * o Redistributions of source code must retain the above copyright notice,
1547     - * this list of conditions and the following disclaimer.
1548     - *
1549     - * o Redistributions in binary form must reproduce the above copyright notice,
1550     - * this list of conditions and the following disclaimer in the documentation
1551     - * and/or other materials provided with the distribution.
1552     - *
1553     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
1554     - * its contributors may be used to endorse or promote products derived
1555     - * from this software without specific prior written permission.
1556     - *
1557     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1558     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
1559     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1560     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1561     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1562     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1563     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1564     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1565     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
1566     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
1567     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1568     - */
1569     -
1570     -package com.jgoodies.looks.windows;
1571     -
1572     -import java.awt.*;
1573     -import java.awt.event.FocusEvent;
1574     -import java.awt.event.MouseEvent;
1575     -
1576     -import javax.swing.BoundedRangeModel;
1577     -import javax.swing.JFormattedTextField;
1578     -import javax.swing.JTextField;
1579     -import javax.swing.SwingUtilities;
1580     -import javax.swing.plaf.TextUI;
1581     -import javax.swing.plaf.UIResource;
1582     -import javax.swing.text.*;
1583     -
1584     -/**
1585     - * WindowsFieldCaret has different scrolling behavior than the DefaultCaret.
1586     - * Also, this caret is visible in non-editable fields,
1587     - * and the text is selected after a keyboard focus gained event.
1588     - * For the latter see also issue #4337647 in Sun's bug database.
1589     - *
1590     - * @author Karsten Lentzsch
1591     - * @version $Revision: 1.5 $
1592     - *
1593     - */
1594     -final class WindowsFieldCaret extends DefaultCaret implements UIResource {
1595     -
1596     - private static final LayeredHighlighter.LayerPainter WindowsPainter =
1597     - new WindowsHighlightPainter(null);
1598     -
1599     -
1600     - WindowsFieldCaret() {
1601     - super();
1602     - }
1603     -
1604     -
1605     - // Begin of Added Code ----------------------------------------------
1606     -
1607     - private boolean isKeyboardFocusEvent = true;
1608     -
1609     -
1610     - public void focusGained(FocusEvent e) {
1611     - if (getComponent().isEnabled()) {
1612     - setVisible(true);
1613     - setSelectionVisible(true);
1614     - }
1615     -
1616     - final JTextComponent c = getComponent();
1617     - if (c.isEnabled() && isKeyboardFocusEvent) {
1618     - if (c instanceof JFormattedTextField) {
1619     - EventQueue.invokeLater(new Runnable() {
1620     - public void run() {
1621     - WindowsFieldCaret.super.setDot(0);
1622     - WindowsFieldCaret.super.moveDot(c.getDocument().getLength());
1623     - }
1624     - });
1625     - } else {
1626     - super.setDot(0);
1627     - super.moveDot(c.getDocument().getLength());
1628     - }
1629     - }
1630     - }
1631     -
1632     -
1633     - public void focusLost(FocusEvent e) {
1634     - super.focusLost(e);
1635     - if (!e.isTemporary()) {
1636     - isKeyboardFocusEvent = true;
1637     - }
1638     - }
1639     -
1640     -
1641     - public void mousePressed(MouseEvent e) {
1642     - if (SwingUtilities.isLeftMouseButton(e) || e.isPopupTrigger()) {
1643     - isKeyboardFocusEvent = false;
1644     - }
1645     - super.mousePressed(e);
1646     -
1647     - }
1648     -
1649     -
1650     - public void mouseReleased(MouseEvent e) {
1651     - super.mouseReleased(e);
1652     - // super.mousePressed() does not transfer focus on popup clicks.
1653     - // Windows does.
1654     - if (e.isPopupTrigger()) {
1655     - isKeyboardFocusEvent = false;
1656     - if ((getComponent() != null) && getComponent().isEnabled()
1657     - && getComponent().isRequestFocusEnabled()) {
1658     - getComponent().requestFocus();
1659     - }
1660     - }
1661     - }
1662     -
1663     - // End of Added Code ------------------------------------------------
1664     -
1665     - /**
1666     - * Adjusts the visibility of the caret according to
1667     - * the windows feel which seems to be to move the
1668     - * caret out into the field by about a quarter of
1669     - * a field length if not visible.
1670     - */
1671     - protected void adjustVisibility(Rectangle r) {
1672     - SwingUtilities.invokeLater(new SafeScroller(r));
1673     - }
1674     -
1675     -
1676     - /**
1677     - * Gets the painter for the Highlighter.
1678     - *
1679     - * @return the painter
1680     - */
1681     - protected Highlighter.HighlightPainter getSelectionPainter() {
1682     - return WindowsPainter;
1683     - }
1684     -
1685     -
1686     - private final class SafeScroller implements Runnable {
1687     -
1688     - SafeScroller(Rectangle r) {
1689     - this.r = r;
1690     - }
1691     -
1692     -
1693     - public void run() {
1694     - JTextField field = (JTextField) getComponent();
1695     - if (field != null) {
1696     - TextUI ui = field.getUI();
1697     - int dot = getDot();
1698     - // PENDING: We need to expose the bias in DefaultCaret.
1699     - Position.Bias bias = Position.Bias.Forward;
1700     - Rectangle startRect = null;
1701     - try {
1702     - startRect = ui.modelToView(field, dot, bias);
1703     - } catch (BadLocationException ble) {}
1704     -
1705     - Insets i = field.getInsets();
1706     - BoundedRangeModel vis = field.getHorizontalVisibility();
1707     - int x = r.x + vis.getValue() - i.left;
1708     - int quarterSpan = vis.getExtent() / 4;
1709     - if (r.x < i.left) {
1710     - vis.setValue(x - quarterSpan);
1711     - } else if (r.x + r.width > i.left + vis.getExtent()) {
1712     - vis.setValue(x - (3 * quarterSpan));
1713     - }
1714     - // If we scroll, our visual location will have changed,
1715     - // but we won't have updated our internal location as
1716     - // the model hasn't changed. This checks for the change,
1717     - // and if necessary, resets the internal location.
1718     - if (startRect != null) {
1719     - try {
1720     - Rectangle endRect;
1721     - endRect = ui.modelToView(field, dot, bias);
1722     - if (endRect != null && !endRect.equals(startRect)){
1723     - damage(endRect);
1724     - }
1725     - } catch (BadLocationException ble) {}
1726     - }
1727     - }
1728     - }
1729     -
1730     - private Rectangle r;
1731     - }
1732     -
1733     - // Helper Classes *********************************************************
1734     -
1735     - private static final class WindowsHighlightPainter extends
1736     - DefaultHighlighter.DefaultHighlightPainter {
1737     - WindowsHighlightPainter(Color c) {
1738     - super(c);
1739     - }
1740     -
1741     -
1742     - // --- HighlightPainter methods ---------------------------------------
1743     -
1744     - /**
1745     - * Paints a highlight.
1746     - *
1747     - * @param g the graphics context
1748     - * @param offs0 the starting model offset >= 0
1749     - * @param offs1 the ending model offset >= offs1
1750     - * @param bounds the bounding box for the highlight
1751     - * @param c the editor
1752     - */
1753     - public void paint(Graphics g, int offs0, int offs1, Shape bounds,
1754     - JTextComponent c) {
1755     - Rectangle alloc = bounds.getBounds();
1756     - try {
1757     - // --- determine locations ---
1758     - TextUI mapper = c.getUI();
1759     - Rectangle p0 = mapper.modelToView(c, offs0);
1760     - Rectangle p1 = mapper.modelToView(c, offs1);
1761     -
1762     - // --- render ---
1763     - Color color = getColor();
1764     -
1765     - if (color == null) {
1766     - g.setColor(c.getSelectionColor());
1767     - } else {
1768     - g.setColor(color);
1769     - }
1770     - boolean firstIsDot = false;
1771     - boolean secondIsDot = false;
1772     - if (c.isEditable()) {
1773     - int dot = c.getCaretPosition();
1774     - firstIsDot = (offs0 == dot);
1775     - secondIsDot = (offs1 == dot);
1776     - }
1777     - if (p0.y == p1.y) {
1778     - // same line, render a rectangle
1779     - Rectangle r = p0.union(p1);
1780     - if (r.width > 0) {
1781     - if (firstIsDot) {
1782     - r.x++;
1783     - r.width--;
1784     - } else if (secondIsDot) {
1785     - r.width--;
1786     - }
1787     - }
1788     - g.fillRect(r.x, r.y, r.width, r.height);
1789     - } else {
1790     - // different lines
1791     - int p0ToMarginWidth = alloc.x + alloc.width - p0.x;
1792     - if (firstIsDot && p0ToMarginWidth > 0) {
1793     - p0.x++;
1794     - p0ToMarginWidth--;
1795     - }
1796     - g.fillRect(p0.x, p0.y, p0ToMarginWidth, p0.height);
1797     - if ((p0.y + p0.height) != p1.y) {
1798     - g.fillRect(alloc.x, p0.y + p0.height, alloc.width, p1.y
1799     - - (p0.y + p0.height));
1800     - }
1801     - if (secondIsDot && p1.x > alloc.x) {
1802     - p1.x--;
1803     - }
1804     - g.fillRect(alloc.x, p1.y, (p1.x - alloc.x), p1.height);
1805     - }
1806     - } catch (BadLocationException e) {
1807     - // can't render
1808     - }
1809     - }
1810     -
1811     -
1812     - // --- LayerPainter methods ----------------------------
1813     - /**
1814     - * Paints a portion of a highlight.
1815     - *
1816     - * @param g the graphics context
1817     - * @param offs0 the starting model offset >= 0
1818     - * @param offs1 the ending model offset >= offs1
1819     - * @param bounds the bounding box of the view, which is not
1820     - * necessarily the region to paint.
1821     - * @param c the editor
1822     - * @param view View painting for
1823     - * @return region drawing occured in
1824     - */
1825     - public Shape paintLayer(Graphics g, int offs0, int offs1, Shape bounds,
1826     - JTextComponent c, View view) {
1827     - Color color = getColor();
1828     -
1829     - if (color == null) {
1830     - g.setColor(c.getSelectionColor());
1831     - } else {
1832     - g.setColor(color);
1833     - }
1834     - boolean firstIsDot = false;
1835     - boolean secondIsDot = false;
1836     - if (c.isEditable()) {
1837     - int dot = c.getCaretPosition();
1838     - firstIsDot = (offs0 == dot);
1839     - secondIsDot = (offs1 == dot);
1840     - }
1841     - if (offs0 == view.getStartOffset() && offs1 == view.getEndOffset()) {
1842     - // Contained in view, can just use bounds.
1843     - Rectangle alloc;
1844     - if (bounds instanceof Rectangle) {
1845     - alloc = (Rectangle) bounds;
1846     - } else {
1847     - alloc = bounds.getBounds();
1848     - }
1849     - if (firstIsDot && alloc.width > 0) {
1850     - g.fillRect(alloc.x + 1, alloc.y, alloc.width - 1,
1851     - alloc.height);
1852     - } else if (secondIsDot && alloc.width > 0) {
1853     - g.fillRect(alloc.x, alloc.y, alloc.width - 1, alloc.height);
1854     - } else {
1855     - g.fillRect(alloc.x, alloc.y, alloc.width, alloc.height);
1856     - }
1857     - return alloc;
1858     - } else {
1859     - // Should only render part of View.
1860     - try {
1861     - // --- determine locations ---
1862     - Shape shape = view.modelToView(offs0,
1863     - Position.Bias.Forward, offs1,
1864     - Position.Bias.Backward, bounds);
1865     - Rectangle r = (shape instanceof Rectangle)
1866     - ? (Rectangle) shape
1867     - : shape.getBounds();
1868     - if (firstIsDot && r.width > 0) {
1869     - g.fillRect(r.x + 1, r.y, r.width - 1, r.height);
1870     - } else if (secondIsDot && r.width > 0) {
1871     - g.fillRect(r.x, r.y, r.width - 1, r.height);
1872     - } else {
1873     - g.fillRect(r.x, r.y, r.width, r.height);
1874     - }
1875     - return r;
1876     - } catch (BadLocationException e) {
1877     - // can't render
1878     - }
1879     - }
1880     - // Only if exception
1881     - return null;
1882     - }
1883     -
1884     - }
1885     -
1886     -}
1887     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsFormattedTextFieldUI.java
1888     +++ /dev/null
1889     @@ -1,68 +0,0 @@
1890     -/*
1891     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
1892     - *
1893     - * Redistribution and use in source and binary forms, with or without
1894     - * modification, are permitted provided that the following conditions are met:
1895     - *
1896     - * o Redistributions of source code must retain the above copyright notice,
1897     - * this list of conditions and the following disclaimer.
1898     - *
1899     - * o Redistributions in binary form must reproduce the above copyright notice,
1900     - * this list of conditions and the following disclaimer in the documentation
1901     - * and/or other materials provided with the distribution.
1902     - *
1903     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
1904     - * its contributors may be used to endorse or promote products derived
1905     - * from this software without specific prior written permission.
1906     - *
1907     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1908     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
1909     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1910     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1911     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1912     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1913     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1914     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1915     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
1916     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
1917     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1918     - */
1919     -
1920     -package com.jgoodies.looks.windows;
1921     -
1922     -import javax.swing.JComponent;
1923     -import javax.swing.plaf.ComponentUI;
1924     -import javax.swing.plaf.basic.BasicFormattedTextFieldUI;
1925     -import javax.swing.text.Caret;
1926     -
1927     -/**
1928     - * The JGoodies Windows L&amp;F implementation of <code>FormattedTextFieldUI</code>.
1929     - * It uses a caret that selects all text if the field gains focus
1930     - * after a keyboard focus traversal.
1931     - *
1932     - * @author Karsten Lentzsch
1933     - * @version $Revision: 1.2 $
1934     - */
1935     -public final class WindowsFormattedTextFieldUI extends BasicFormattedTextFieldUI {
1936     -
1937     - /**
1938     - * Creates a UI for a JFormattedTextField.
1939     - *
1940     - * @param c the formatted text field
1941     - * @return the UI
1942     - */
1943     - public static ComponentUI createUI(JComponent c) {
1944     - return new WindowsFormattedTextFieldUI();
1945     - }
1946     -
1947     -
1948     - /**
1949     - * Creates the caret for a field.
1950     - *
1951     - * @return the caret
1952     - */
1953     - protected Caret createCaret() {
1954     - return new WindowsFieldCaret();
1955     - }
1956     -
1957     -}
1958     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsIconFactory.java
1959     +++ /dev/null
1960     @@ -1,219 +0,0 @@
1961     -/*
1962     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
1963     - *
1964     - * Redistribution and use in source and binary forms, with or without
1965     - * modification, are permitted provided that the following conditions are met:
1966     - *
1967     - * o Redistributions of source code must retain the above copyright notice,
1968     - * this list of conditions and the following disclaimer.
1969     - *
1970     - * o Redistributions in binary form must reproduce the above copyright notice,
1971     - * this list of conditions and the following disclaimer in the documentation
1972     - * and/or other materials provided with the distribution.
1973     - *
1974     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
1975     - * its contributors may be used to endorse or promote products derived
1976     - * from this software without specific prior written permission.
1977     - *
1978     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1979     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
1980     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
1981     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
1982     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
1983     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
1984     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
1985     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
1986     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
1987     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
1988     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1989     - */
1990     -
1991     -package com.jgoodies.looks.windows;
1992     -
1993     -import java.awt.Component;
1994     -import java.awt.Graphics;
1995     -import java.io.Serializable;
1996     -
1997     -import javax.swing.AbstractButton;
1998     -import javax.swing.ButtonModel;
1999     -import javax.swing.Icon;
2000     -import javax.swing.JCheckBox;
2001     -import javax.swing.UIManager;
2002     -import javax.swing.plaf.UIResource;
2003     -
2004     -/**
2005     - * Factory class that vends <code>Icon</code>s used in the JGoodies Windows look&amp;feel.
2006     - *
2007     - * @author Karsten Lentzsch
2008     - * @version $Revision: 1.3 $
2009     - */
2010     -final class WindowsIconFactory {
2011     -
2012     - private WindowsIconFactory() {
2013     - // Overrides default constructor; prevents instantiation.
2014     - }
2015     -
2016     - // Accessing and Creating Icons *****************************************************
2017     -
2018     - private static Icon checkBoxIcon;
2019     - private static Icon radioButtonIcon;
2020     -
2021     -
2022     - /**
2023     - * Returns an <code>Icon</code> for a <code>JCheckBox</code>.
2024     - */
2025     - static Icon getCheckBoxIcon() {
2026     - if (checkBoxIcon == null) {
2027     - checkBoxIcon = new CheckBoxIcon();
2028     - }
2029     - return checkBoxIcon;
2030     - }
2031     -
2032     -
2033     - /**
2034     - * Returns an <code>Icon</code> for a <code>JCheckBox</code>.
2035     - */
2036     - static Icon getRadioButtonIcon() {
2037     - if (radioButtonIcon == null) {
2038     - radioButtonIcon = new RadioButtonIcon();
2039     - }
2040     - return radioButtonIcon;
2041     - }
2042     -
2043     -
2044     - // Helper Classes *******************************************************************
2045     -
2046     - // Paints the icon for a check box.
2047     - private static class CheckBoxIcon implements Icon, Serializable {
2048     -
2049     - private static final int SIZE = 13;
2050     -
2051     - public void paintIcon(Component c, Graphics g, int x, int y) {
2052     - JCheckBox cb = (JCheckBox) c;
2053     - ButtonModel model = cb.getModel();
2054     -
2055     - // outer bevel
2056     - if (!cb.isBorderPaintedFlat()) {
2057     - // Outer top/left
2058     - g.setColor(UIManager.getColor("CheckBox.shadow"));
2059     - g.drawLine(x, y, x+11, y);
2060     - g.drawLine(x, y+1, x, y+11);
2061     -
2062     - // Outer bottom/right
2063     - g.setColor(UIManager.getColor("CheckBox.highlight"));
2064     - g.drawLine(x+12, y, x+12, y+12);
2065     - g.drawLine(x, y+12, x+11, y+12);
2066     -
2067     - // Inner top.left
2068     - g.setColor(UIManager.getColor("CheckBox.darkShadow"));
2069     - g.drawLine(x+1, y+1, x+10, y+1);
2070     - g.drawLine(x+1, y+2, x+1, y+10);
2071     -
2072     - // Inner bottom/right
2073     - g.setColor(UIManager.getColor("CheckBox.light"));
2074     - g.drawLine(x+1, y+11, x+11, y+11);
2075     - g.drawLine(x+11, y+1, x+11, y+10);
2076     - } else {
2077     - g.setColor(UIManager.getColor("CheckBox.shadow"));
2078     - g.drawRect(x+1, y+1, SIZE-3, SIZE-3);
2079     - }
2080     - // inside box
2081     - g.setColor(UIManager.getColor(
2082     - (model.isPressed() && model.isArmed()) || !model.isEnabled()
2083     - ? "CheckBox.background"
2084     - : "CheckBox.interiorBackground"));
2085     - g.fillRect(x+2, y+2, SIZE-4, SIZE-4);
2086     -
2087     - g.setColor(UIManager.getColor(model.isEnabled()
2088     - ? "CheckBox.checkColor" // Modified by JGoodies
2089     - : "CheckBox.shadow"));
2090     -
2091     - // paint check
2092     - if (model.isSelected()) {
2093     - g.drawLine(x+9, y+3, x+9, y+3);
2094     - g.drawLine(x+8, y+4, x+9, y+4);
2095     - g.drawLine(x+7, y+5, x+9, y+5);
2096     - g.drawLine(x+6, y+6, x+8, y+6);
2097     - g.drawLine(x+3, y+7, x+7, y+7);
2098     - g.drawLine(x+4, y+8, x+6, y+8);
2099     - g.drawLine(x+5, y+9, x+5, y+9);
2100     - g.drawLine(x+3, y+5, x+3, y+5);
2101     - g.drawLine(x+3, y+6, x+4, y+6);
2102     - }
2103     - }
2104     -
2105     - public int getIconWidth() { return SIZE; }
2106     - public int getIconHeight() { return SIZE; }
2107     - }
2108     -
2109     -
2110     - // Paints the icon for a radio button.
2111     - private static class RadioButtonIcon implements Icon, UIResource, Serializable {
2112     -
2113     - private static final int SIZE = 13;
2114     -
2115     - public void paintIcon(Component c, Graphics g, int x, int y) {
2116     - AbstractButton b = (AbstractButton) c;
2117     - ButtonModel model = b.getModel();
2118     -
2119     - // fill interior
2120     - g.setColor(UIManager.getColor(
2121     - (model.isPressed() && model.isArmed()) || !model.isEnabled()
2122     - ? "RadioButton.background"
2123     - : "RadioButton.interiorBackground"));
2124     - g.fillRect(x+2, y+2, 8, 8);
2125     -
2126     -
2127     - // outter left arc
2128     - g.setColor(UIManager.getColor("RadioButton.shadow"));
2129     - g.drawLine(x+4, y+0, x+7, y+0);
2130     - g.drawLine(x+2, y+1, x+3, y+1);
2131     - g.drawLine(x+8, y+1, x+9, y+1);
2132     - g.drawLine(x+1, y+2, x+1, y+3);
2133     - g.drawLine(x+0, y+4, x+0, y+7);
2134     - g.drawLine(x+1, y+8, x+1, y+9);
2135     -
2136     - // outter right arc
2137     - g.setColor(UIManager.getColor("RadioButton.highlight"));
2138     - g.drawLine(x+2, y+10, x+3, y+10);
2139     - g.drawLine(x+4, y+11, x+7, y+11);
2140     - g.drawLine(x+8, y+10, x+9, y+10);
2141     - g.drawLine(x+10, y+9, x+10, y+8);
2142     - g.drawLine(x+11, y+7, x+11, y+4);
2143     - g.drawLine(x+10, y+3, x+10, y+2);
2144     -
2145     -
2146     - // inner left arc
2147     - g.setColor(UIManager.getColor("RadioButton.darkShadow"));
2148     - g.drawLine(x+4, y+1, x+7, y+1);
2149     - g.drawLine(x+2, y+2, x+3, y+2);
2150     - g.drawLine(x+8, y+2, x+9, y+2);
2151     - g.drawLine(x+2, y+3, x+2, y+3);
2152     - g.drawLine(x+1, y+4, x+1, y+7);
2153     - g.drawLine(x+2, y+8, x+2, y+8);
2154     -
2155     -
2156     - // inner right arc
2157     - g.setColor(UIManager.getColor("RadioButton.light"));
2158     - g.drawLine(x+2, y+9, x+3, y+9);
2159     - g.drawLine(x+4, y+10, x+7, y+10);
2160     - g.drawLine(x+8, y+9, x+9, y+9);
2161     - g.drawLine(x+9, y+8, x+9, y+8);
2162     - g.drawLine(x+10, y+7, x+10, y+4);
2163     - g.drawLine(x+9, y+3, x+9, y+3);
2164     -
2165     -
2166     - // indicate whether selected or not
2167     - if(model.isSelected()) {
2168     - g.setColor(UIManager.getColor("RadioButton.checkColor")); // Modified by JGoodies
2169     - g.fillRect(x+4, y+5, 4, 2);
2170     - g.fillRect(x+5, y+4, 2, 4);
2171     - }
2172     - }
2173     -
2174     - public int getIconWidth() { return SIZE; }
2175     - public int getIconHeight() { return SIZE; }
2176     -
2177     - }
2178     -
2179     -}
2180     \ No newline at end of file
2181     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsLookAndFeel.java
2182     +++ /dev/null
2183     @@ -1,760 +0,0 @@
2184     -/*
2185     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
2186     - *
2187     - * Redistribution and use in source and binary forms, with or without
2188     - * modification, are permitted provided that the following conditions are met:
2189     - *
2190     - * o Redistributions of source code must retain the above copyright notice,
2191     - * this list of conditions and the following disclaimer.
2192     - *
2193     - * o Redistributions in binary form must reproduce the above copyright notice,
2194     - * this list of conditions and the following disclaimer in the documentation
2195     - * and/or other materials provided with the distribution.
2196     - *
2197     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
2198     - * its contributors may be used to endorse or promote products derived
2199     - * from this software without specific prior written permission.
2200     - *
2201     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
2202     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
2203     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2204     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
2205     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2206     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
2207     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
2208     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
2209     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
2210     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
2211     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2212     - */
2213     -
2214     -package com.jgoodies.looks.windows;
2215     -
2216     -import java.awt.Color;
2217     -import java.awt.Font;
2218     -import java.awt.Insets;
2219     -import java.lang.reflect.Method;
2220     -
2221     -import javax.swing.Icon;
2222     -import javax.swing.JComponent;
2223     -import javax.swing.UIDefaults;
2224     -import javax.swing.UIManager;
2225     -import javax.swing.border.Border;
2226     -import javax.swing.border.EmptyBorder;
2227     -import javax.swing.plaf.DimensionUIResource;
2228     -import javax.swing.plaf.IconUIResource;
2229     -import javax.swing.plaf.InsetsUIResource;
2230     -import javax.swing.plaf.basic.BasicBorders;
2231     -
2232     -import com.jgoodies.looks.*;
2233     -import com.jgoodies.looks.common.MinimumSizedIcon;
2234     -import com.jgoodies.looks.common.RGBGrayFilter;
2235     -import com.jgoodies.looks.common.ShadowPopupFactory;
2236     -
2237     -/**
2238     - * The main class of the JGoodies Windows Look&amp;Feel.
2239     - * This look provides several corrections and extensions to Sun's Windows L&F.
2240     - * In addition it tries to provide a unified look for the J2SE 1.4.0x, 1.4.1x,
2241     - * 1.4.2, and 1.5 environments.
2242     - *
2243     - * @author Karsten Lentzsch
2244     - * @version $Revision: 1.36 $
2245     - */
2246     -public final class WindowsLookAndFeel extends com.sun.java.swing.plaf.windows.WindowsLookAndFeel {
2247     -
2248     - /**
2249     - * An optional client property key for JMenu and JToolBar
2250     - * to set a border style - shadows the header style.
2251     - */
2252     - public static final String BORDER_STYLE_KEY = "jgoodies.windows.borderStyle";
2253     -
2254     -
2255     - public String getID() {
2256     - return "JGoodies Windows";
2257     - }
2258     -
2259     -
2260     - public String getName() {
2261     - return "JGoodies Windows";
2262     - }
2263     -
2264     -
2265     - public String getDescription() {
2266     - return "The JGoodies Windows Look and Feel"
2267     - + " - \u00a9 2001-2007 JGoodies Karsten Lentzsch";
2268     - }
2269     -
2270     -
2271     - // Optional Settings ******************************************************
2272     -
2273     - /**
2274     - * Looks up and retrieves the FontPolicy used by
2275     - * the JGoodies Windows Look&amp;Feel.
2276     - * If a FontPolicy has been set for this look, it'll be returned.
2277     - * Otherwise, this method checks if a FontPolicy or FontSet is defined
2278     - * in the system properties or UIDefaults. If so, it is returned.
2279     - * If no FontPolicy has been set for this look, in the system
2280     - * properties or UIDefaults, the default Windows font policy
2281     - * will be returned.
2282     - *
2283     - * @return the FontPolicy set for this Look&amp;feel - if any,
2284     - * the FontPolicy specified in the system properties or UIDefaults
2285     - * - if any, or the default Windows font policy.
2286     - *
2287     - * @see #setFontPolicy
2288     - * @see Options#WINDOWS_FONT_POLICY_KEY
2289     - * @see FontPolicies
2290     - * @see FontPolicies#customSettingsPolicy(FontPolicy)
2291     - * @see FontPolicies#getDefaultWindowsPolicy()
2292     - */
2293     - public static FontPolicy getFontPolicy() {
2294     - FontPolicy policy =
2295     - (FontPolicy) UIManager.get(Options.WINDOWS_FONT_POLICY_KEY);
2296     - if (policy != null)
2297     - return policy;
2298     -
2299     - FontPolicy defaultPolicy = FontPolicies.getDefaultWindowsPolicy();
2300     - return FontPolicies.customSettingsPolicy(defaultPolicy);
2301     - }
2302     -
2303     -
2304     - /**
2305     - * Sets the FontPolicy to be used with the JGoodies Windows L&amp;F.
2306     - * If the specified policy is <code>null</code>, the default will be reset.
2307     - *
2308     - * @param fontPolicy the FontPolicy to be used with the JGoodies Windows
2309     - * L&amp;F, or <code>null</code> to reset to the default
2310     - *
2311     - * @see #getFontPolicy()
2312     - * @see Options#WINDOWS_FONT_POLICY_KEY
2313     - */
2314     - public static void setFontPolicy(FontPolicy fontPolicy) {
2315     - UIManager.put(Options.WINDOWS_FONT_POLICY_KEY, fontPolicy);
2316     - }
2317     -
2318     -
2319     - /**
2320     - * Looks up and retrieves the MicroLayoutPolicy used by
2321     - * the JGoodies Windows Look&amp;Feel.
2322     - * If a MicroLayoutPolicy has been set for this look, it'll be returned.
2323     - * Otherwise, the default Windows micro layout policy will be returned.
2324     - *
2325     - * @return the MicroLayoutPolicy set for this Look&amp;feel - if any,
2326     - * or the default Windows MicroLayoutPolicy.
2327     - *
2328     - * @see #setMicroLayoutPolicy
2329     - * @see Options#WINDOWS_MICRO_LAYOUT_POLICY_KEY
2330     - * @see MicroLayoutPolicies
2331     - * @see MicroLayoutPolicies#getDefaultWindowsPolicy()
2332     - */
2333     - public static MicroLayoutPolicy getMicroLayoutPolicy() {
2334     - MicroLayoutPolicy policy =
2335     - (MicroLayoutPolicy) UIManager.get(Options.WINDOWS_MICRO_LAYOUT_POLICY_KEY);
2336     - return policy != null
2337     - ? policy
2338     - : MicroLayoutPolicies.getDefaultWindowsPolicy();
2339     - }
2340     -
2341     -
2342     - /**
2343     - * Sets the MicroLayoutPolicy to be used with the JGoodies Windows L&amp;F.
2344     - * If the specified policy is <code>null</code>, the default will be reset.
2345     - *
2346     - * @param microLayoutPolicy the MicroLayoutPolicy to be used with
2347     - * the JGoodies Windows L&amp;F, or <code>null</code> to reset
2348     - * to the default
2349     - *
2350     - * @see #getMicroLayoutPolicy()
2351     - * @see Options#WINDOWS_MICRO_LAYOUT_POLICY_KEY
2352     - */
2353     - public static void setMicroLayoutPolicy(MicroLayout microLayoutPolicy) {
2354     - UIManager.put(Options.WINDOWS_MICRO_LAYOUT_POLICY_KEY, microLayoutPolicy);
2355     - }
2356     -
2357     -
2358     - // Overriding Superclass Behavior ***************************************
2359     -
2360     - /**
2361     - * Invoked during <code>UIManager#setLookAndFeel</code>. In addition
2362     - * to the superclass behavior, we install the ShadowPopupFactory.
2363     - *
2364     - * @see #uninitialize
2365     - */
2366     - public void initialize() {
2367     - super.initialize();
2368     - ShadowPopupFactory.install();
2369     - }
2370     -
2371     -
2372     - /**
2373     - * Invoked during <code>UIManager#setLookAndFeel</code>. In addition
2374     - * to the superclass behavior, we uninstall the ShadowPopupFactory.
2375     - *
2376     - * @see #initialize
2377     - */
2378     - public void uninitialize() {
2379     - super.uninitialize();
2380     - ShadowPopupFactory.uninstall();
2381     - }
2382     -
2383     -
2384     - /**
2385     - * Returns an icon with a disabled appearance. This method is used
2386     - * to generate a disabled icon when one has not been specified.<p>
2387     - *
2388     - * This method will be used only on JDK 5.0 and later.
2389     - *
2390     - * @param component the component that will display the icon, may be null.
2391     - * @param icon the icon to generate disabled icon from.
2392     - * @return disabled icon, or null if a suitable icon can not be generated.
2393     - */
2394     - public Icon getDisabledIcon(JComponent component, Icon icon) {
2395     - Icon disabledIcon = RGBGrayFilter.getDisabledIcon(component, icon);
2396     - return disabledIcon != null
2397     - ? new IconUIResource(disabledIcon)
2398     - : null;
2399     - }
2400     -
2401     -
2402     - /**
2403     - * Initializes the class defaults, that is, overrides some UI delegates
2404     - * with JGoodies Windows implementations.
2405     - */
2406     - protected void initClassDefaults(UIDefaults table) {
2407     - super.initClassDefaults(table);
2408     - final String windowsPrefix = "com.jgoodies.looks.windows.Windows";
2409     - final String commonPrefix = "com.jgoodies.looks.common.ExtBasic";
2410     -
2411     - // Overwrite some of the uiDefaults.
2412     - Object[] uiDefaults = {
2413     - // Modified size
2414     - "ComboBoxUI", windowsPrefix + "ComboBoxUI",
2415     -
2416     - // Modified preferred height: can be even or odd
2417     - "ButtonUI", windowsPrefix + "ButtonUI",
2418     -
2419     - // Can installs an optional etched border
2420     - "ScrollPaneUI", windowsPrefix + "ScrollPaneUI",
2421     -
2422     - // Optional style and optional special borders
2423     - "MenuBarUI", windowsPrefix + "MenuBarUI",
2424     -
2425     - // Provides an option for a no margin border
2426     - "PopupMenuUI", windowsPrefix + "PopupMenuUI",
2427     -
2428     - // Honors the screen resolution and uses a minimum button width
2429     - "OptionPaneUI", windowsPrefix + "OptionPaneUI",
2430     -
2431     - // 1.4.1 has ugly one touch triangles
2432     - "SplitPaneUI", windowsPrefix + "SplitPaneUI",
2433     -
2434     - // Work in progress: Can have a flat presentation
2435     - "TabbedPaneUI", windowsPrefix + "TabbedPaneUI",
2436     -
2437     - // Selects text after focus gained via keyboard
2438     - "TextFieldUI", windowsPrefix + "TextFieldUI",
2439     - "FormattedTextFieldUI", windowsPrefix + "FormattedTextFieldUI",
2440     -
2441     - // Selects text after focus gained via keyboard
2442     - // Renders a dot, not the star ("*") character on Java 1.4 and 5
2443     - "PasswordFieldUI", windowsPrefix + "PasswordFieldUI",
2444     -
2445     -
2446     - // Updates the disabled and inactive background
2447     - "TextAreaUI", windowsPrefix + "TextAreaUI",
2448     -
2449     - // Corrected position of the tree button icon
2450     - "TreeUI", windowsPrefix + "TreeUI",
2451     -
2452     - // Just to use shared UI delegate
2453     - "SeparatorUI", windowsPrefix + "SeparatorUI"};
2454     -
2455     - if (LookUtils.IS_JAVA_1_4_2_OR_LATER) {
2456     - // Modified Border
2457     - uiDefaults = append(uiDefaults,
2458     - "SpinnerUI", windowsPrefix + "SpinnerUI");
2459     - }
2460     -
2461     - // Aligned menu items
2462     - if ( !LookUtils.IS_JAVA_6_OR_LATER
2463     - || !LookUtils.IS_OS_WINDOWS_VISTA
2464     - || !LookUtils.IS_LAF_WINDOWS_XP_ENABLED) {
2465     - uiDefaults = append(uiDefaults,
2466     - "MenuItemUI", windowsPrefix + "MenuItemUI");
2467     - uiDefaults = append(uiDefaults,
2468     - "CheckBoxMenuItemUI", commonPrefix + "CheckBoxMenuItemUI");
2469     - uiDefaults = append(uiDefaults,
2470     - "RadioButtonMenuItemUI", commonPrefix + "RadioButtonMenuItemUI");
2471     - // Has padding above and below the separator lines
2472     - uiDefaults = append(uiDefaults,
2473     - "PopupMenuSeparatorUI", commonPrefix + "PopupMenuSeparatorUI");
2474     - }
2475     -
2476     - if (LookUtils.IS_LAF_WINDOWS_XP_ENABLED) {
2477     - // Aligned menu items
2478     - if (!LookUtils.IS_JAVA_6_OR_LATER || !LookUtils.IS_OS_WINDOWS_VISTA) {
2479     - uiDefaults = append(uiDefaults,
2480     - "MenuUI", windowsPrefix + "XPMenuUI");
2481     - }
2482     -
2483     - // Optional style and optional special borders;
2484     - // rollover borders for compound buttons
2485     - uiDefaults = append(uiDefaults,
2486     - "ToolBarUI", windowsPrefix + "XPToolBarUI");
2487     -
2488     - // Honors XP table header style for custom user renderers.
2489     - uiDefaults = append(uiDefaults,
2490     - "TableHeaderUI", windowsPrefix + "XPTableHeaderUI");
2491     - } else {
2492     - // Aligned menu items
2493     - uiDefaults = append(uiDefaults,
2494     - "MenuUI", commonPrefix + "MenuUI");
2495     -
2496     - // Optional style and optional special borders;
2497     - // rollover borders corrected
2498     - uiDefaults = append(uiDefaults,
2499     - "ToolBarUI", windowsPrefix + "ToolBarUI");
2500     -
2501     - // Black arrows
2502     - uiDefaults = append(uiDefaults,
2503     - "ScrollBarUI", windowsPrefix + "ScrollBarUI");
2504     -
2505     - if (!LookUtils.IS_JAVA_1_4_2_OR_LATER) {
2506     - // Uses unmodified size specified by "ToolBar.separatorSize"
2507     - uiDefaults = append(uiDefaults,
2508     - "ToolBarSeparatorUI", windowsPrefix + "ToolBarSeparatorUI");
2509     - }
2510     - }
2511     - table.putDefaults(uiDefaults);
2512     - }
2513     -
2514     - /**
2515     - * Initializes the component defaults.
2516     - */
2517     - protected void initComponentDefaults(UIDefaults table) {
2518     - super.initComponentDefaults(table);
2519     -
2520     - final boolean isXP = LookUtils.IS_LAF_WINDOWS_XP_ENABLED;
2521     - final boolean isClassic = !isXP;
2522     - final boolean isVista = LookUtils.IS_OS_WINDOWS_VISTA;
2523     -
2524     - initFontDefaults(table);
2525     -
2526     - if (isClassic) {
2527     - initComponentDefaultsClassic(table);
2528     - }
2529     - if (isXP && LookUtils.IS_JAVA_1_4) {
2530     - initComponentDefaultsXP14(table);
2531     - }
2532     -
2533     - MicroLayout microLayout = getMicroLayoutPolicy().getMicroLayout("Windows", table);
2534     - if (!isVista || !LookUtils.IS_JAVA_6_OR_LATER || !LookUtils.IS_LAF_WINDOWS_XP_ENABLED) {
2535     - initMenuItemDefaults(table, microLayout);
2536     - }
2537     -
2538     - Object marginBorder = new BasicBorders.MarginBorder();
2539     - Object checkBoxMargin = microLayout.getCheckBoxMargin();
2540     -
2541     - Object etchedBorder = new UIDefaults.ProxyLazyValue(
2542     - "javax.swing.plaf.BorderUIResource",
2543     - "getEtchedBorderUIResource");
2544     - Object buttonBorder = new SimpleProxyLazyValue(
2545     - "com.jgoodies.looks.windows.WindowsLookAndFeel",
2546     - "getButtonBorder");
2547     -
2548     - Object menuBorder = isXP
2549     - ? WindowsBorders.getXPMenuBorder()
2550     - : WindowsBorders.getMenuBorder();
2551     -
2552     - Object menuBarEmptyBorder = marginBorder;
2553     - Object menuBarSeparatorBorder = WindowsBorders.getSeparatorBorder();
2554     - Object menuBarEtchedBorder = WindowsBorders.getEtchedBorder();
2555     - Object menuBarHeaderBorder = WindowsBorders.getMenuBarHeaderBorder();
2556     -
2557     - Object toolBarEmptyBorder = marginBorder;
2558     - Object toolBarSeparatorBorder = WindowsBorders.getSeparatorBorder();
2559     - Object toolBarEtchedBorder = WindowsBorders.getEtchedBorder();
2560     - Object toolBarHeaderBorder = WindowsBorders.getToolBarHeaderBorder();
2561     -
2562     - Object buttonMargin = microLayout.getButtonMargin();
2563     -
2564     - Object toolBarSeparatorSize = LookUtils.IS_JAVA_1_4_2_OR_LATER
2565     - ? null
2566     - : new DimensionUIResource(6, Options.getDefaultIconSize().height);
2567     -
2568     - Object textInsets = microLayout.getTextInsets();
2569     - Object wrappedTextInsets = microLayout.getWrappedTextInsets();
2570     - Insets comboEditorInsets = microLayout.getComboBoxEditorInsets();
2571     -
2572     - int comboBorderSize = microLayout.getComboBorderSize();
2573     - int comboPopupBorderSize = microLayout.getComboPopupBorderSize();
2574     - int comboRendererGap = comboEditorInsets.left + comboBorderSize - comboPopupBorderSize;
2575     - Object comboRendererBorder = new EmptyBorder(1, comboRendererGap, 1, comboRendererGap);
2576     - Object comboTableEditorInsets = new Insets(0, 0, 0, 0);
2577     -
2578     - Object popupMenuSeparatorMargin = microLayout.getPopupMenuSeparatorMargin();
2579     -
2580     - // Should be active.
2581     - int treeFontSize = table.getFont("Tree.font").getSize();
2582     - Integer rowHeight = new Integer(treeFontSize + 6);
2583     -
2584     - Class superclass = getClass().getSuperclass();
2585     - Color controlColor = table.getColor("control");
2586     - Object disabledTextBackground = table.getColor("TextField.disabledBackground");
2587     - Object inactiveTextBackground = table.getColor("TextField.inactiveBackground");
2588     -
2589     - Object comboBoxDisabledBackground = (isVista && isXP)
2590     - ? table.getColor("ComboBox.background")
2591     - : disabledTextBackground;
2592     -
2593     - Object menuBarBackground = isXP
2594     - ? table.get("control")
2595     - : table.get("menu");
2596     - Object menuSelectionBackground = isXP
2597     - ? table.get("MenuItem.selectionBackground")
2598     - : table.get("Menu.background");
2599     - Object menuSelectionForeground = isXP
2600     - ? table.get("MenuItem.selectionForeground")
2601     - : table.get("Menu.foreground");
2602     -
2603     - Character passwordEchoChar = new Character(isXP ? '\u25CF' : '*');
2604     -
2605     - Object[] defaults = {
2606     - "Button.border", buttonBorder,
2607     - "Button.margin", buttonMargin, // Sun's 14px margin is too wide
2608     -
2609     - // 1.4.2 uses a 2 pixel non-standard border that leads to bad
2610     - // alignment in the typical case that the border is not painted
2611     - "CheckBox.border", marginBorder,
2612     - "CheckBox.margin", checkBoxMargin,
2613     -
2614     - "ComboBox.disabledBackground", comboBoxDisabledBackground,
2615     - "ComboBox.editorBorder", marginBorder,
2616     - "ComboBox.editorColumns", new Integer(5),
2617     - "ComboBox.editorInsets", comboEditorInsets, // Added by JGoodies
2618     - "ComboBox.tableEditorInsets", comboTableEditorInsets,
2619     - "ComboBox.rendererBorder", comboRendererBorder, // Added by JGoodies
2620     -
2621     - "EditorPane.margin", wrappedTextInsets,
2622     -
2623     - // Begin 1.3 und 1.4.0
2624     - "Menu.border", menuBorder, // Fixed in 1.4.1
2625     - "Menu.borderPainted", Boolean.TRUE,
2626     - "Menu.background", menuBarBackground,
2627     - "Menu.selectionForeground", menuSelectionForeground,
2628     - "Menu.selectionBackground", menuSelectionBackground,
2629     - // End 1.3 und 1.4.0
2630     -
2631     - "MenuBar.background", menuBarBackground,
2632     - "MenuBar.border", menuBarSeparatorBorder, // 1.4.1 Separator wrong
2633     - "MenuBar.emptyBorder", menuBarEmptyBorder, // Added by JGoodies
2634     - "MenuBar.separatorBorder", menuBarSeparatorBorder, // Added by JGoodies
2635     - "MenuBar.etchedBorder", menuBarEtchedBorder, // Added by JGoodies
2636     - "MenuBar.headerBorder", menuBarHeaderBorder, // Added by JGoodies
2637     -
2638     - "FormattedTextField.disabledBackground", disabledTextBackground, // for readonly
2639     - "FormattedTextField.inactiveBackground", inactiveTextBackground, // for readonly
2640     - "FormattedTextField.margin", textInsets, // Poor in 1.6
2641     -
2642     - "PasswordField.margin", textInsets, // Poor in 1.6
2643     - "PasswordField.echoChar", passwordEchoChar,
2644     -
2645     - "PopupMenu.border", WindowsBorders.getPopupMenuBorder(),
2646     - "PopupMenu.noMarginBorder", WindowsBorders.getNoMarginPopupMenuBorder(),
2647     - "PopupMenuSeparator.margin", popupMenuSeparatorMargin,
2648     -
2649     - "ScrollPane.etchedBorder", etchedBorder, // Added by JGoodies
2650     -
2651     - "Spinner.defaultEditorInsets", textInsets, // Added by JGoodies
2652     -
2653     - // 1.4.1 uses a 2 pixel non-standard border, that leads to bad
2654     - // alignment in the typical case that the border is not painted
2655     - "RadioButton.border", marginBorder,
2656     - "RadioButton.margin", checkBoxMargin,
2657     -
2658     - "Table.gridColor", controlColor, // 1.4.1 Bug; active
2659     - "TextArea.margin", wrappedTextInsets, // 1.4.1 Bug
2660     - "TextArea.disabledBackground", disabledTextBackground,
2661     - "TextArea.inactiveBackground", inactiveTextBackground,
2662     - "TextField.margin", textInsets, // 1.4.1 Bug
2663     - "ToggleButton.margin", buttonMargin, // Sun's 14px margin is too wide
2664     -
2665     - "ToolBar.emptyBorder", toolBarEmptyBorder, // Added by JGoodies
2666     - "ToolBar.separatorBorder", toolBarSeparatorBorder, // Added by JGoodies
2667     - "ToolBar.etchedBorder", toolBarEtchedBorder, // Added by JGoodies
2668     - "ToolBar.headerBorder", toolBarHeaderBorder, // Added by JGoodies
2669     - "ToolBar.separatorSize", toolBarSeparatorSize,
2670     - "ToolBar.margin", new InsetsUIResource(0, 10, 0, 0),
2671     -
2672     - "Tree.selectionBorderColor", controlColor, // 1.4.1 Bug; active
2673     - "Tree.rowHeight", rowHeight, // 1.4.1 Bug
2674     - };
2675     - if (LookUtils.IS_JAVA_1_4) {
2676     - defaults = append(defaults, new Object[] {
2677     - "InternalFrame.icon", makeIcon(superclass, "icons/JavaCup.gif"),
2678     - "OptionPane.errorIcon", isXP ? makeIcon(getClass(), "icons/xp/Error.png")
2679     - : makeIcon(superclass, "icons/Error.gif"),
2680     - "OptionPane.informationIcon", isXP ? makeIcon(getClass(), "icons/xp/Inform.png")
2681     - : makeIcon(superclass, "icons/Inform.gif"),
2682     - "OptionPane.warningIcon", isXP ? makeIcon(getClass(), "icons/xp/Warn.png")
2683     - : makeIcon(superclass, "icons/Warn.gif"),
2684     - "OptionPane.questionIcon", isXP ? makeIcon(getClass(), "icons/xp/Inform.png")
2685     - : makeIcon(superclass, "icons/Question.gif")
2686     - });
2687     - }
2688     - if (LookUtils.IS_JAVA_1_4 || LookUtils.IS_JAVA_5) {
2689     - defaults = append(defaults, new Object[] {
2690     - "Tree.openIcon", isXP ? makeIcon(getClass(), "icons/xp/TreeOpen.png")
2691     - : makeIcon(getClass(), "icons/TreeOpen.gif"),
2692     - "Tree.closedIcon", isXP ? makeIcon(getClass(), "icons/xp/TreeClosed.png")
2693     - : makeIcon(getClass(), "icons/TreeClosed.gif")
2694     - });
2695     - }
2696     - if (LookUtils.IS_JAVA_6_OR_LATER) {
2697     - defaults = append(defaults, new Object[] {
2698     - "Spinner.border", table.get("TextField.border")
2699     - });
2700     - }
2701     - table.putDefaults(defaults);
2702     - }
2703     -
2704     - /**
2705     - * Initializes component defaults required in classic mode only.
2706     - */
2707     - private void initComponentDefaultsClassic(UIDefaults table) {
2708     - Object checkBoxIcon = new SimpleProxyLazyValue(
2709     - "com.jgoodies.looks.windows.WindowsLookAndFeel",
2710     - "getCheckBoxIcon");
2711     -
2712     - Object radioButtonIcon = new SimpleProxyLazyValue(
2713     - "com.jgoodies.looks.windows.WindowsLookAndFeel",
2714     - "getRadioButtonIcon");
2715     -
2716     - Border winInsetBorder = new BasicBorders.FieldBorder(table
2717     - .getColor("controlShadow"), table
2718     - .getColor("controlDkShadow"),
2719     - table.getColor("controlHighlight"), table
2720     - .getColor("controlLtHighlight"));
2721     -
2722     - Object[] defaults = {
2723     - "CheckBox.checkColor", table.get("controlText"), // kind-of black
2724     - "CheckBox.icon", checkBoxIcon,
2725     - "RadioButton.checkColor", table.get("controlText"), // kind-of black
2726     - "RadioButton.icon", radioButtonIcon,
2727     - "Table.scrollPaneBorder", winInsetBorder, // 1.4.1 Bug
2728     -
2729     - };
2730     - table.putDefaults(defaults);
2731     - }
2732     -
2733     - /**
2734     - * Initializes component defaults required in XP mode on Java 1.4.2 only.
2735     - */
2736     - private void initComponentDefaultsXP14(UIDefaults table) {
2737     - Object[] defaults = {
2738     - "TitledBorder.titleColor", table.getColor("activeCaption")
2739     - };
2740     - table.putDefaults(defaults);
2741     - }
2742     -
2743     - /**
2744     - * Looks up the correct control font and sets it for all controls.
2745     - */
2746     - private void initFontDefaults(UIDefaults table) {
2747     - FontPolicy fontChoicePolicy = getFontPolicy();
2748     - FontSet fontSet = fontChoicePolicy.getFontSet("Windows", table);
2749     - initFontDefaults(table, fontSet);
2750     - }
2751     -
2752     -
2753     - private void initMenuItemDefaults(UIDefaults table, MicroLayout microLayout) {
2754     - Object menuMargin = microLayout.getMenuMargin();
2755     - Object menuItemMargin = microLayout.getMenuItemMargin();
2756     - Icon menuItemCheckIcon = new MinimumSizedIcon();
2757     - Object[] defaults = {
2758     -
2759     - "Menu.margin", menuMargin, // 1.4.1 Bug
2760     -
2761     - "MenuItem.borderPainted", Boolean.TRUE,
2762     - "MenuItem.checkIcon", menuItemCheckIcon, // Aligns menu items
2763     - "MenuItem.margin", menuItemMargin, // 1.4.1 Bug
2764     - "CheckBoxMenuItem.margin", menuItemMargin, // 1.4.1 Bug
2765     - "RadioButtonMenuItem.margin", menuItemMargin, // 1.4.1 Bug
2766     - };
2767     - table.putDefaults(defaults);
2768     - }
2769     -
2770     -
2771     - /**
2772     - * Sets Fonts in the given FontSet as defaults for all known
2773     - * component types in the given UIDefaults table.
2774     - *
2775     - * @param table the UIDefaults table used to set fonts
2776     - * @param fontSet describes the set of Fonts to be installed
2777     - */
2778     - private static void initFontDefaults(UIDefaults table, FontSet fontSet) {
2779     - Font controlFont = fontSet.getControlFont();
2780     - Font menuFont = fontSet.getMenuFont();
2781     - Font messageFont = fontSet.getMessageFont();
2782     - Font toolTipFont = fontSet.getSmallFont();
2783     - Font titleFont = fontSet.getTitleFont();
2784     - Font windowFont = fontSet.getWindowTitleFont();
2785     -
2786     - Object[] defaults = {
2787     - "Button.font", controlFont,
2788     - "CheckBox.font", controlFont,
2789     - "ColorChooser.font", controlFont,
2790     - "ComboBox.font", controlFont,
2791     - "EditorPane.font", controlFont,
2792     - "FormattedTextField.font", controlFont,
2793     - "Label.font", controlFont,
2794     - "List.font", controlFont,
2795     - "Panel.font", controlFont,
2796     - "PasswordField.font", controlFont,
2797     - "ProgressBar.font", controlFont,
2798     - "RadioButton.font", controlFont,
2799     - "ScrollPane.font", controlFont,
2800     - "Spinner.font", controlFont,
2801     - "TabbedPane.font", controlFont,
2802     - "Table.font", controlFont,
2803     - "TableHeader.font", controlFont,
2804     - "TextArea.font", controlFont,
2805     - "TextField.font", controlFont,
2806     - "TextPane.font", controlFont,
2807     - "ToolBar.font", controlFont,
2808     - "ToggleButton.font", controlFont,
2809     - "Tree.font", controlFont,
2810     - "Viewport.font", controlFont,
2811     -
2812     - "InternalFrame.titleFont", windowFont, // controlBold
2813     - "OptionPane.font", messageFont,
2814     - "OptionPane.messageFont", messageFont,
2815     - "OptionPane.buttonFont", messageFont,
2816     - "TitledBorder.font", titleFont,
2817     - "ToolTip.font", toolTipFont,
2818     -
2819     - "CheckBoxMenuItem.font", menuFont,
2820     - "CheckBoxMenuItem.acceleratorFont", menuFont, // 1.3 only ?
2821     - "Menu.font", menuFont,
2822     - "Menu.acceleratorFont", menuFont,
2823     - "MenuBar.font", menuFont,
2824     - "MenuItem.font", menuFont,
2825     - "MenuItem.acceleratorFont", menuFont,
2826     - "PopupMenu.font", menuFont,
2827     - "RadioButtonMenuItem.font", menuFont,
2828     - "RadioButtonMenuItem.acceleratorFont", menuFont, // 1.3 only ?
2829     - };
2830     - table.putDefaults(defaults);
2831     - }
2832     -
2833     -
2834     - // Getters for Proxy Access (Referred classes can stay package visible) ***
2835     -
2836     - public static Border getButtonBorder() {
2837     - return WindowsBorders.getButtonBorder();
2838     - }
2839     -
2840     - public static Icon getCheckBoxIcon() {
2841     - return WindowsIconFactory.getCheckBoxIcon();
2842     - }
2843     -
2844     - public static Icon getRadioButtonIcon() {
2845     - return WindowsIconFactory.getRadioButtonIcon();
2846     - }
2847     -
2848     -
2849     - // Helper Code ************************************************************
2850     -
2851     - /**
2852     - * Appends the key and value to the given source array and returns
2853     - * a copy that has the two new elements at its end.
2854     - *
2855     - * @return an array with the key and value appended
2856     - */
2857     - private static Object[] append(Object[] source, String key, Object value) {
2858     - int length = source.length;
2859     - Object[] destination = new Object[length + 2];
2860     - System.arraycopy(source, 0, destination, 0, length);
2861     - destination[length] = key;
2862     - destination[length + 1] = value;
2863     - return destination;
2864     - }
2865     -
2866     -
2867     - /**
2868     - * Appends the key and value to the given source array and returns
2869     - * a copy that has the two new elements at its end.
2870     - *
2871     - * @return an array with the key and value appended
2872     - */
2873     - private static Object[] append(Object[] source, Object[] keysAndValues) {
2874     - int length = source.length;
2875     - Object[] destination = new Object[length + keysAndValues.length];
2876     - System.arraycopy(source, 0, destination, 0, length);
2877     - for (int i = 0; i < keysAndValues.length; i++) {
2878     - destination[length + i] = keysAndValues[i];
2879     - }
2880     - return destination;
2881     - }
2882     -
2883     - // Helper Class ***********************************************************
2884     -
2885     - /**
2886     - * This class provides an implementation of <code>LazyValue</code> that
2887     - * can be used to delay loading of the Class for the instance to be created.
2888     - * It also avoids creation of an anonymous inner class for the
2889     - * <code>LazyValue</code>
2890     - * subclass. Both of these improve performance at the time that a
2891     - * a Look and Feel is loaded, at the cost of a slight performance
2892     - * reduction the first time <code>createValue</code> is called
2893     - * (since Reflection APIs are used).
2894     - */
2895     - private static class SimpleProxyLazyValue implements UIDefaults.LazyValue {
2896     -
2897     - private final String className;
2898     - private final String methodName;
2899     -
2900     - /**
2901     - * Creates a <code>LazyValue</code> which will construct an instance
2902     - * when asked.
2903     - *
2904     - * @param c a <code>String</code> specifying the classname of the class
2905     - * containing a static method to be called for instance creation
2906     - * @param m a <code>String</code> specifying the static
2907     - * method to be called on class c
2908     - */
2909     - public SimpleProxyLazyValue(String c, String m) {
2910     - className = c;
2911     - methodName = m;
2912     - }
2913     -
2914     - /**
2915     - * Creates the value retrieved from the <code>UIDefaults</code> table.
2916     - * The object is created each time it is accessed.
2917     - *
2918     - * @param table a <code>UIDefaults</code> table
2919     - * @return the created <code>Object</code>
2920     - */
2921     - public Object createValue(UIDefaults table) {
2922     - Object instance = null;
2923     - try {
2924     - Class c;
2925     - // We use a separate ClassLoader
2926     - ClassLoader classLoader = table != null
2927     - ? (ClassLoader) table.get("ClassLoader")
2928     - : Thread.currentThread().getContextClassLoader();
2929     - if (classLoader == null) {
2930     - classLoader = getClass().getClassLoader();
2931     - }
2932     - c = Class.forName(className, true, classLoader);
2933     - Method m = c.getMethod(methodName, null);
2934     - instance = m.invoke(c, null);
2935     - } catch (Throwable t) {
2936     - LookUtils.log("Problem creating " + className + " with method "
2937     - + methodName + t);
2938     - }
2939     - return instance;
2940     - }
2941     - }
2942     -
2943     -}
2944     \ No newline at end of file
2945     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsMenuBarUI.java
2946     +++ /dev/null
2947     @@ -1,126 +0,0 @@
2948     -/*
2949     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
2950     - *
2951     - * Redistribution and use in source and binary forms, with or without
2952     - * modification, are permitted provided that the following conditions are met:
2953     - *
2954     - * o Redistributions of source code must retain the above copyright notice,
2955     - * this list of conditions and the following disclaimer.
2956     - *
2957     - * o Redistributions in binary form must reproduce the above copyright notice,
2958     - * this list of conditions and the following disclaimer in the documentation
2959     - * and/or other materials provided with the distribution.
2960     - *
2961     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
2962     - * its contributors may be used to endorse or promote products derived
2963     - * from this software without specific prior written permission.
2964     - *
2965     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
2966     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
2967     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
2968     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
2969     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
2970     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
2971     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
2972     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
2973     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
2974     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
2975     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2976     - */
2977     -
2978     -package com.jgoodies.looks.windows;
2979     -
2980     -import java.beans.PropertyChangeEvent;
2981     -import java.beans.PropertyChangeListener;
2982     -
2983     -import javax.swing.JComponent;
2984     -import javax.swing.LookAndFeel;
2985     -import javax.swing.plaf.ComponentUI;
2986     -
2987     -import com.jgoodies.looks.BorderStyle;
2988     -import com.jgoodies.looks.HeaderStyle;
2989     -import com.jgoodies.looks.Options;
2990     -
2991     -/**
2992     - * The JGoodies Windows look and feel implemenation of <code>MenuBarUI</code>.<p>
2993     - *
2994     - * Can handle optional <code>Border</code> types as specified by the
2995     - * <code>BorderStyle</code> or <code>HeaderStyle</code> client properties.
2996     - *
2997     - * @author Karsten Lentzsch
2998     - * @version $Revision: 1.3 $
2999     - */
3000     -public final class WindowsMenuBarUI extends com.sun.java.swing.plaf.windows.WindowsMenuBarUI {
3001     -
3002     - private PropertyChangeListener listener;
3003     -
3004     -
3005     - public static ComponentUI createUI(JComponent b) {
3006     - return new WindowsMenuBarUI();
3007     - }
3008     -
3009     -
3010     - // Handling Special Borders *********************************************************
3011     -
3012     - protected void installDefaults() {
3013     - super.installDefaults();
3014     - installSpecialBorder();
3015     - }
3016     -
3017     -
3018     - protected void installListeners() {
3019     - super.installListeners();
3020     - listener = createBorderStyleListener();
3021     - menuBar.addPropertyChangeListener(listener);
3022     - }
3023     -
3024     -
3025     - protected void uninstallListeners() {
3026     - menuBar.removePropertyChangeListener(listener);
3027     - super.uninstallListeners();
3028     - }
3029     -
3030     -
3031     - private PropertyChangeListener createBorderStyleListener() {
3032     - return new PropertyChangeListener() {
3033     -
3034     - public void propertyChange(PropertyChangeEvent e) {
3035     - String prop = e.getPropertyName();
3036     - if (prop.equals(Options.HEADER_STYLE_KEY) ||
3037     - prop.equals(WindowsLookAndFeel.BORDER_STYLE_KEY)) {
3038     - WindowsMenuBarUI.this.installSpecialBorder();
3039     - }
3040     - }
3041     -
3042     - };
3043     - }
3044     -
3045     -
3046     - /**
3047     - * Installs a special border, if either a look-dependent
3048     - * <code>BorderStyle</code> or a look-independent
3049     - * <code>HeaderStyle</code> has been specified.
3050     - * A look specific BorderStyle shadows
3051     - * a HeaderStyle.<p>
3052     - *
3053     - * Specifying a HeaderStyle is recommend.
3054     - */
3055     - private void installSpecialBorder() {
3056     - String suffix;
3057     - BorderStyle borderStyle = BorderStyle.from(menuBar,
3058     - WindowsLookAndFeel.BORDER_STYLE_KEY);
3059     - if (borderStyle == BorderStyle.EMPTY)
3060     - suffix = "emptyBorder";
3061     - else if (borderStyle == BorderStyle.ETCHED)
3062     - suffix = "etchedBorder";
3063     - else if (borderStyle == BorderStyle.SEPARATOR)
3064     - suffix = "separatorBorder";
3065     - else if (HeaderStyle.from(menuBar) == HeaderStyle.BOTH)
3066     - suffix = "headerBorder";
3067     - else
3068     - return;
3069     -
3070     - LookAndFeel.installBorder(menuBar, "MenuBar." + suffix);
3071     - }
3072     -
3073     -}
3074     \ No newline at end of file
3075     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsMenuItemRenderer.java
3076     +++ /dev/null
3077     @@ -1,77 +0,0 @@
3078     -/*
3079     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
3080     - *
3081     - * Redistribution and use in source and binary forms, with or without
3082     - * modification, are permitted provided that the following conditions are met:
3083     - *
3084     - * o Redistributions of source code must retain the above copyright notice,
3085     - * this list of conditions and the following disclaimer.
3086     - *
3087     - * o Redistributions in binary form must reproduce the above copyright notice,
3088     - * this list of conditions and the following disclaimer in the documentation
3089     - * and/or other materials provided with the distribution.
3090     - *
3091     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
3092     - * its contributors may be used to endorse or promote products derived
3093     - * from this software without specific prior written permission.
3094     - *
3095     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
3096     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
3097     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
3098     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
3099     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
3100     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
3101     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
3102     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
3103     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
3104     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
3105     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3106     - */
3107     -
3108     -package com.jgoodies.looks.windows;
3109     -
3110     -import java.awt.Color;
3111     -import java.awt.Font;
3112     -
3113     -import javax.swing.JMenuItem;
3114     -import javax.swing.UIManager;
3115     -
3116     -import com.jgoodies.looks.LookUtils;
3117     -import com.jgoodies.looks.common.MenuItemRenderer;
3118     -
3119     -/**
3120     - * Renders and lays out Windows menu items.
3121     - * It overrides superclass behavior for the mnemonic check
3122     - * and the text shadow feature.
3123     - *
3124     - * @author Karsten Lentzsch
3125     - * @version $Revision: 1.2 $
3126     - */
3127     -final class WindowsMenuItemRenderer extends MenuItemRenderer {
3128     -
3129     - /**
3130     - * Constructs a WindowsMenuItemRenderer for the specified menu item and settings.
3131     - */
3132     - public WindowsMenuItemRenderer(JMenuItem menuItem, boolean iconBorderEnabled,
3133     - Font acceleratorFont,
3134     - Color selectionForeground,
3135     - Color disabledForeground,
3136     - Color acceleratorForeground,
3137     - Color acceleratorSelectionForeground) {
3138     - super(menuItem, iconBorderEnabled, acceleratorFont, selectionForeground, disabledForeground,
3139     - acceleratorForeground, acceleratorSelectionForeground);
3140     - }
3141     -
3142     -
3143     - protected boolean isMnemonicHidden() {
3144     - return WindowsLookAndFeel.isMnemonicHidden();
3145     - }
3146     -
3147     -
3148     - protected boolean disabledTextHasShadow() {
3149     - return (!LookUtils.IS_LAF_WINDOWS_XP_ENABLED)
3150     - || (UIManager.getColor("MenuItem.disabledForeground") == null);
3151     - }
3152     -
3153     -
3154     -}
3155     \ No newline at end of file
3156     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsMenuItemUI.java
3157     +++ /dev/null
3158     @@ -1,80 +0,0 @@
3159     -/*
3160     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
3161     - *
3162     - * Redistribution and use in source and binary forms, with or without
3163     - * modification, are permitted provided that the following conditions are met:
3164     - *
3165     - * o Redistributions of source code must retain the above copyright notice,
3166     - * this list of conditions and the following disclaimer.
3167     - *
3168     - * o Redistributions in binary form must reproduce the above copyright notice,
3169     - * this list of conditions and the following disclaimer in the documentation
3170     - * and/or other materials provided with the distribution.
3171     - *
3172     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
3173     - * its contributors may be used to endorse or promote products derived
3174     - * from this software without specific prior written permission.
3175     - *
3176     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
3177     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
3178     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
3179     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
3180     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
3181     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
3182     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
3183     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
3184     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
3185     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
3186     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3187     - */
3188     -
3189     -package com.jgoodies.looks.windows;
3190     -
3191     -import java.awt.Color;
3192     -import java.awt.Font;
3193     -
3194     -import javax.swing.JComponent;
3195     -import javax.swing.JMenuItem;
3196     -import javax.swing.plaf.ComponentUI;
3197     -
3198     -import com.jgoodies.looks.common.ExtBasicMenuItemUI;
3199     -import com.jgoodies.looks.common.MenuItemRenderer;
3200     -
3201     -/**
3202     - * The JGoodies Windows look&amp;feel implementation of <code>MenuItemUI</code>.<p>
3203     - *
3204     - * It differs from the superclass in that it uses a Windows specific
3205     - * menu item renderer that checks if mnemonics shall be shown or hidden
3206     - * and may paint disabled text with a shadow.
3207     - *
3208     - * @author Karsten Lentzsch
3209     - * @version $Revision: 1.2 $
3210     - */
3211     -public final class WindowsMenuItemUI extends ExtBasicMenuItemUI {
3212     -
3213     -
3214     - public static ComponentUI createUI(JComponent b) {
3215     - return new WindowsMenuItemUI();
3216     - }
3217     -
3218     -
3219     - protected MenuItemRenderer createRenderer(
3220     - JMenuItem menuItem,
3221     - boolean iconBorderEnabled,
3222     - Font acceleratorFont,
3223     - Color selectionForeground,
3224     - Color disabledForeground,
3225     - Color acceleratorForeground,
3226     - Color acceleratorSelectionForeground) {
3227     - return new WindowsMenuItemRenderer(
3228     - menuItem,
3229     - iconBorderEnabled(),
3230     - acceleratorFont,
3231     - selectionForeground,
3232     - disabledForeground,
3233     - acceleratorForeground,
3234     - acceleratorSelectionForeground);
3235     - }
3236     -
3237     -
3238     -}
3239     \ No newline at end of file
3240     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsOptionPaneUI.java
3241     +++ /dev/null
3242     @@ -1,68 +0,0 @@
3243     -/*
3244     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
3245     - *
3246     - * Redistribution and use in source and binary forms, with or without
3247     - * modification, are permitted provided that the following conditions are met:
3248     - *
3249     - * o Redistributions of source code must retain the above copyright notice,
3250     - * this list of conditions and the following disclaimer.
3251     - *
3252     - * o Redistributions in binary form must reproduce the above copyright notice,
3253     - * this list of conditions and the following disclaimer in the documentation
3254     - * and/or other materials provided with the distribution.
3255     - *
3256     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
3257     - * its contributors may be used to endorse or promote products derived
3258     - * from this software without specific prior written permission.
3259     - *
3260     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
3261     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
3262     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
3263     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
3264     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
3265     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
3266     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
3267     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
3268     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
3269     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
3270     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3271     - */
3272     -
3273     -package com.jgoodies.looks.windows;
3274     -
3275     -import java.awt.Container;
3276     -
3277     -import javax.swing.JComponent;
3278     -import javax.swing.JPanel;
3279     -import javax.swing.UIManager;
3280     -import javax.swing.plaf.ComponentUI;
3281     -import javax.swing.plaf.basic.BasicOptionPaneUI;
3282     -
3283     -import com.jgoodies.looks.common.ExtButtonAreaLayout;
3284     -
3285     -/**
3286     - * The JGoodies Windows Look&amp;Feel implementation of
3287     - * <code>OptionPaneUI</code>. Honors the screen resolution and uses a
3288     - * minimum button with that complies better with the Windows UI style guide.
3289     - *
3290     - * @author Karsten Lentzsch
3291     - * @version $Revision: 1.3 $
3292     - */
3293     -public final class WindowsOptionPaneUI extends BasicOptionPaneUI {
3294     -
3295     - public static ComponentUI createUI(JComponent b) {
3296     - return new WindowsOptionPaneUI();
3297     - }
3298     -
3299     - /**
3300     - * Creates and returns a Container containin the buttons. The buttons
3301     - * are created by calling <code>getButtons</code>.
3302     - */
3303     - protected Container createButtonArea() {
3304     - JPanel bottom = new JPanel(new ExtButtonAreaLayout(true, 6));
3305     - bottom.setBorder(UIManager.getBorder("OptionPane.buttonAreaBorder"));
3306     - addButtonComponents(bottom, getButtons(), getInitialValueIndex());
3307     - return bottom;
3308     - }
3309     -
3310     -}
3311     \ No newline at end of file
3312     --- libjgoodies-looks-java.orig/src/core/com/jgoodies/looks/windows/WindowsPasswordFieldUI.java
3313     +++ /dev/null
3314     @@ -1,102 +0,0 @@
3315     -/*
3316     - * Copyright (c) 2001-2007 JGoodies Karsten Lentzsch. All Rights Reserved.
3317     - *
3318     - * Redistribution and use in source and binary forms, with or without
3319     - * modification, are permitted provided that the following conditions are met:
3320     - *
3321     - * o Redistributions of source code must retain the above copyright notice,
3322     - * this list of conditions and the following disclaimer.
3323     - *
3324     - * o Redistributions in binary form must reproduce the above copyright notice,
3325     - * this list of conditions and the following disclaimer in the documentation
3326     - * and/or other materials provided with the distribution.
3327     - *
3328     - * o Neither the name of JGoodies Karsten Lentzsch nor the names of
3329     - * its contributors may be used to endorse or promote products derived
3330     - * from this software without specific prior written permission.
3331     - *
3332     - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
3333     - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
3334     - * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
3335     - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
3336     - * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
3337     - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
3338     - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
3339     - * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
3340     - * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
3341     - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
3342     - * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
3343     - */
3344     -
3345     -package com.jgoodies.looks.windows;
3346     -
3347     -
3348     -import javax.swing.JComponent;
3349     -import javax.swing.JPasswordField;
3350     -import javax.swing.plaf.ComponentUI;
3351     -import javax.swing.text.Caret;
3352     -import javax.swing.text.Element;
3353     -import javax.swing.text.View;
3354     -
3355     -import com.jgoodies.looks.LookUtils;
3356     -import com.jgoodies.looks.common.ExtPasswordView;
3357     -
3358     -/**
3359     - * The JGoodies Windows Look&amp;Feel implementation of a password field UI
3360     - * delegate. It differs from its superclass in that it utilizes a password
3361     - * view that renders a customizable echo char, not a star (&quot;*&quot;).
3362     - *
3363     - * Used for Java 1.4 and Java 5.
3364     - *
3365     - * @author Karsten Lentzsch
3366     - * @version $Revision: 1.3 $
3367     - */
3368     -public final class WindowsPasswordFieldUI extends com.sun.java.swing.plaf.windows.WindowsPasswordFieldUI {
3369     -
3370     - /**
3371     - * Creates a UI for a {@link JPasswordField}.
3372     - *
3373     - * @param c the password field component
3374     - * @return the UI
3375     - */
3376     - public static ComponentUI createUI(JComponent c) {
3377     - return new WindowsPasswordFieldUI();
3378     - }
3379     -
3380     - /*
3381     - * We'd like to just set the dot as echo character.
3382     - * But the JPasswordField (in Java 1.4 and Java 5)
3383     - * installs the UI in a superclass and then sets the echo character.
3384     - * The latter would override our call to #setEchoChar.<