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

Diff of /libjgoodies-looks-java/trunk/debian/patches/02_windows.dpatch

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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