Index: src/main/java/common/javax/swing/plaf/multi/MultiTableUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiTableUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiTableUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.TableUI; + +/** + * All the methods described in public api + */ +public class MultiTableUI extends TableUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiTableUI mui = new MultiTableUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiMenuBarUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiMenuBarUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiMenuBarUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.MenuBarUI; + +/** + * All the methods described in public api + */ +public class MultiMenuBarUI extends MenuBarUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiMenuBarUI mui = new MultiMenuBarUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiTreeUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiTreeUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiTreeUI.java (revision 0) @@ -0,0 +1,245 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Rectangle; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JTree; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.TreeUI; +import javax.swing.tree.TreePath; + +/** + * All the methods described in public api + */ +public class MultiTreeUI extends TreeUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiTreeUI mui = new MultiTreeUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public Rectangle getPathBounds(JTree tree, TreePath path) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getPathBounds(tree, path); + } + return ((TreeUI) uis.firstElement()).getPathBounds(tree, path); + } + + @Override + public TreePath getPathForRow(JTree tree, int row) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getPathForRow(tree, row); + } + return ((TreeUI) uis.firstElement()).getPathForRow(tree, row); + } + + @Override + public int getRowForPath(JTree tree, TreePath path) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getRowForPath(tree, path); + } + return ((TreeUI) uis.firstElement()).getRowForPath(tree, path); + } + + @Override + public int getRowCount(JTree tree) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getRowCount(tree); + } + return ((TreeUI) uis.firstElement()).getRowCount(tree); + } + + @Override + public TreePath getClosestPathForLocation(JTree tree, int x, int y) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getClosestPathForLocation(tree, x, y); + } + return ((TreeUI) uis.firstElement()).getClosestPathForLocation(tree, x, + y); + } + + @Override + public boolean isEditing(JTree tree) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).isEditing(tree); + } + return ((TreeUI) uis.firstElement()).isEditing(tree); + } + + @Override + public boolean stopEditing(JTree path) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).stopEditing(path); + } + return ((TreeUI) uis.firstElement()).stopEditing(path); + } + + @Override + public void cancelEditing(JTree tree) { + for (Object ui : uis) { + ((TreeUI) ui).cancelEditing(tree); + } + } + + @Override + public void startEditingAtPath(JTree tree, TreePath path) { + for (Object ui : uis) { + ((TreeUI) ui).startEditingAtPath(tree, path); + } + } + + @Override + public TreePath getEditingPath(JTree tree) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TreeUI) uisIterator.next()).getEditingPath(tree); + } + return ((TreeUI) uis.firstElement()).getEditingPath(tree); + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiSeparatorUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiSeparatorUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiSeparatorUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.SeparatorUI; + +/** + * All the methods described in public api + */ +public class MultiSeparatorUI extends SeparatorUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiSeparatorUI mui = new MultiSeparatorUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiColorChooserUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiColorChooserUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiColorChooserUI.java (revision 0) @@ -0,0 +1,132 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ColorChooserUI; +import javax.swing.plaf.ComponentUI; + +/** + * All the methods described in public api + * */ +public class MultiColorChooserUI extends ColorChooserUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiColorChooserUI mui = new MultiColorChooserUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + +} Index: src/main/java/common/javax/swing/plaf/multi/MultiToolBarUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiToolBarUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiToolBarUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ToolBarUI; + +/** + * All the methods described in public api + */ +public class MultiToolBarUI extends ToolBarUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiToolBarUI mui = new MultiToolBarUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiScrollPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiScrollPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiScrollPaneUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ScrollPaneUI; + +/** + * All the methods described in public api + */ +public class MultiScrollPaneUI extends ScrollPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiScrollPaneUI mui = new MultiScrollPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiComboBoxUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiComboBoxUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiComboBoxUI.java (revision 0) @@ -0,0 +1,164 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComboBox; +import javax.swing.JComponent; +import javax.swing.plaf.ComboBoxUI; +import javax.swing.plaf.ComponentUI; + +/** + * All the methods described in public api + */ +public class MultiComboBoxUI extends ComboBoxUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiComboBoxUI mui = new MultiComboBoxUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public void setPopupVisible(JComboBox c, boolean isVisible) { + for (Object ui : uis) { + ((ComboBoxUI) ui).setPopupVisible(c, isVisible); + } + } + + @Override + public boolean isPopupVisible(JComboBox c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComboBoxUI) uisIterator.next()).isPopupVisible(c); + } + return ((ComboBoxUI) uis.firstElement()).isPopupVisible(c); + } + + @Override + public boolean isFocusTraversable(JComboBox c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComboBoxUI) uisIterator.next()).isFocusTraversable(c); + } + return ((ComboBoxUI) uis.firstElement()).isFocusTraversable(c); + } + +} Index: src/main/java/common/javax/swing/plaf/multi/MultiListUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiListUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiListUI.java (revision 0) @@ -0,0 +1,171 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Point; +import java.awt.Rectangle; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JList; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ListUI; + +/** + * All the methods described in public api + */ +public class MultiListUI extends ListUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiListUI mui = new MultiListUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public int locationToIndex(JList list, Point location) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ListUI) uisIterator.next()).locationToIndex(list, location); + } + return ((ListUI) uis.firstElement()).locationToIndex(list, location); + } + + @Override + public Point indexToLocation(JList list, int index) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ListUI) uisIterator.next()).indexToLocation(list, index); + } + return ((ListUI) uis.firstElement()).indexToLocation(list, index); + } + + @Override + public Rectangle getCellBounds(JList list, int index1, int index2) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ListUI) uisIterator.next()).getCellBounds(list, index1, index2); + } + return ((ListUI) uis.firstElement()) + .getCellBounds(list, index1, index2); + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiSpinnerUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiSpinnerUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiSpinnerUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.SpinnerUI; + +/** + * All the methods described in public api + */ +public class MultiSpinnerUI extends SpinnerUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiSpinnerUI mui = new MultiSpinnerUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiViewportUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiViewportUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiViewportUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ViewportUI; + +/** + * All the methods described in public api + */ +public class MultiViewportUI extends ViewportUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiViewportUI mui = new MultiViewportUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiLabelUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiLabelUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiLabelUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.LabelUI; + +/** + * All the methods described in public api + */ +public class MultiLabelUI extends LabelUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiLabelUI mui = new MultiLabelUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiDesktopIconUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiDesktopIconUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiDesktopIconUI.java (revision 0) @@ -0,0 +1,132 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.DesktopIconUI; + +/** + * All the methods described in public api + * */ +public class MultiDesktopIconUI extends DesktopIconUI{ + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiDesktopIconUI mui = new MultiDesktopIconUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + +} Index: src/main/java/common/javax/swing/plaf/multi/MultiScrollBarUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiScrollBarUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiScrollBarUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ScrollBarUI; + +/** + * All the methods described in public api + */ +public class MultiScrollBarUI extends ScrollBarUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiScrollBarUI mui = new MultiScrollBarUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiMenuItemUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiMenuItemUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiMenuItemUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.MenuItemUI; + +/** + * All the methods described in public api + */ +public class MultiMenuItemUI extends MenuItemUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiMenuItemUI mui = new MultiMenuItemUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiTextUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiTextUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiTextUI.java (revision 0) @@ -0,0 +1,253 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Point; +import java.awt.Rectangle; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.TextUI; +import javax.swing.text.BadLocationException; +import javax.swing.text.EditorKit; +import javax.swing.text.JTextComponent; +import javax.swing.text.View; +import javax.swing.text.Position.Bias; + +/** + * All the methods described in public api + */ +public class MultiTextUI extends TextUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiTextUI mui = new MultiTextUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public Rectangle modelToView(JTextComponent a0, int a1) + throws BadLocationException { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).modelToView(a0, a1); + } + return ((TextUI) uis.firstElement()).modelToView(a0, a1); + } + + @Override + public Rectangle modelToView(JTextComponent a0, int a1, Bias a2) + throws BadLocationException { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).modelToView(a0, a1, a2); + } + return ((TextUI) uis.firstElement()).modelToView(a0, a1, a2); + } + + @Override + public int viewToModel(JTextComponent a0, Point a1) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).viewToModel(a0, a1); + } + return ((TextUI) uis.firstElement()).viewToModel(a0, a1); + } + + @Override + public int viewToModel(JTextComponent a0, Point a1, Bias[] a2) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).viewToModel(a0, a1, a2); + } + return ((TextUI) uis.firstElement()).viewToModel(a0, a1, a2); + } + + @Override + public int getNextVisualPositionFrom(JTextComponent a0, int a1, Bias a2, + int a3, Bias[] a4) throws BadLocationException { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).getNextVisualPositionFrom(a0, a1, a2, + a3, a4); + } + return ((TextUI) uis.firstElement()).getNextVisualPositionFrom(a0, a1, + a2, a3, a4); + } + + @Override + public void damageRange(JTextComponent a0, int a1, int a2) { + for (Object ui : uis) { + ((TextUI) ui).damageRange(a0, a1, a2); + } + } + + @Override + public void damageRange(JTextComponent a0, int a1, int a2, Bias a3, Bias a4) { + for (Object ui : uis) { + ((TextUI) ui).damageRange(a0, a1, a2, a3, a4); + } + } + + @Override + public EditorKit getEditorKit(JTextComponent a0) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).getEditorKit(a0); + } + return ((TextUI) uis.firstElement()).getEditorKit(a0); + } + + @Override + public View getRootView(JTextComponent a0) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).getRootView(a0); + } + return ((TextUI) uis.firstElement()).getRootView(a0); + } + + @Override + public String getToolTipText(JTextComponent a0, Point a1) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TextUI) uisIterator.next()).getToolTipText(a0, a1); + } + return ((TextUI) uis.firstElement()).getToolTipText(a0, a1); + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiInternalFrameUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiInternalFrameUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiInternalFrameUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.InternalFrameUI; + +/** + * All the methods described in public api + * */ +public class MultiInternalFrameUI extends InternalFrameUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiInternalFrameUI mui = new MultiInternalFrameUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiRootPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiRootPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiRootPaneUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.RootPaneUI; + +/** + * All the methods described in public api + */ +public class MultiRootPaneUI extends RootPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiRootPaneUI mui = new MultiRootPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiPopupMenuUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiPopupMenuUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiPopupMenuUI.java (revision 0) @@ -0,0 +1,158 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.event.MouseEvent; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JPopupMenu; +import javax.swing.Popup; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.PopupMenuUI; + +/** + * All the methods described in public api + */ +public class MultiPopupMenuUI extends PopupMenuUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiPopupMenuUI mui = new MultiPopupMenuUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public Popup getPopup(JPopupMenu popup, int x, int y) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((PopupMenuUI) uisIterator.next()).getPopup(popup, x, y); + } + return ((PopupMenuUI) uis.firstElement()).getPopup(popup, x, y); + } + + @Override + public boolean isPopupTrigger(MouseEvent event) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((PopupMenuUI) uisIterator.next()).isPopupTrigger(event); + } + return ((PopupMenuUI) uis.firstElement()).isPopupTrigger(event); + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiProgressBarUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiProgressBarUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiProgressBarUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ProgressBarUI; + +/** + * All the methods described in public api + */ +public class MultiProgressBarUI extends ProgressBarUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiProgressBarUI mui = new MultiProgressBarUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiToolTipUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiToolTipUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiToolTipUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.ToolTipUI; + +/** + * All the methods described in public api + */ +public class MultiToolTipUI extends ToolTipUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiToolTipUI mui = new MultiToolTipUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiPanelUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiPanelUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiPanelUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.PanelUI; + +/** + * All the methods described in public api + */ +public class MultiPanelUI extends PanelUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiPanelUI mui = new MultiPanelUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiSplitPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiSplitPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiSplitPaneUI.java (revision 0) @@ -0,0 +1,189 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JSplitPane; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.SplitPaneUI; + +/** + * All the methods described in public api + */ +public class MultiSplitPaneUI extends SplitPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiSplitPaneUI mui = new MultiSplitPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public void resetToPreferredSizes(JSplitPane jc) { + for (Object ui : uis) { + ((SplitPaneUI) ui).resetToPreferredSizes(jc); + } + } + + @Override + public void setDividerLocation(JSplitPane jc, int location) { + for (Object ui : uis) { + ((SplitPaneUI) ui).setDividerLocation(jc, location); + } + } + + @Override + public int getDividerLocation(JSplitPane jc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((SplitPaneUI) uisIterator.next()).getDividerLocation(jc); + } + return ((SplitPaneUI) uis.firstElement()).getDividerLocation(jc); + } + + @Override + public int getMinimumDividerLocation(JSplitPane jc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((SplitPaneUI) uisIterator.next()).getMinimumDividerLocation(jc); + } + return ((SplitPaneUI) uis.firstElement()).getMinimumDividerLocation(jc); + } + + @Override + public int getMaximumDividerLocation(JSplitPane jc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((SplitPaneUI) uisIterator.next()).getMaximumDividerLocation(jc); + } + return ((SplitPaneUI) uis.firstElement()).getMaximumDividerLocation(jc); + } + + @Override + public void finishedPaintingChildren(JSplitPane jc, Graphics g) { + for (Object ui : uis) { + ((SplitPaneUI) ui).finishedPaintingChildren(jc, g); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiTableHeaderUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiTableHeaderUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiTableHeaderUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.TableHeaderUI; + +/** + * All the methods described in public api + */ +public class MultiTableHeaderUI extends TableHeaderUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiTableHeaderUI mui = new MultiTableHeaderUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiFileChooserUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiFileChooserUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiFileChooserUI.java (revision 0) @@ -0,0 +1,199 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.io.File; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JFileChooser; +import javax.swing.filechooser.FileFilter; +import javax.swing.filechooser.FileView; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.FileChooserUI; + +/** + * All the methods described in public api + */ +public class MultiFileChooserUI extends FileChooserUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiFileChooserUI mui = new MultiFileChooserUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public FileFilter getAcceptAllFileFilter(JFileChooser fc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((FileChooserUI) uisIterator.next()).getAcceptAllFileFilter(fc); + } + return ((FileChooserUI) uis.firstElement()).getAcceptAllFileFilter(fc); + } + + @Override + public FileView getFileView(JFileChooser fc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((FileChooserUI) uisIterator.next()).getFileView(fc); + } + return ((FileChooserUI) uis.firstElement()).getFileView(fc); + } + + @Override + public String getApproveButtonText(JFileChooser fc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((FileChooserUI) uisIterator.next()).getApproveButtonText(fc); + } + return ((FileChooserUI) uis.firstElement()).getApproveButtonText(fc); + } + + @Override + public String getDialogTitle(JFileChooser fc) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((FileChooserUI) uisIterator.next()).getDialogTitle(fc); + } + return ((FileChooserUI) uis.firstElement()).getDialogTitle(fc); + } + + @Override + public void rescanCurrentDirectory(JFileChooser fc) { + for (Object ui : uis) { + ((FileChooserUI) ui).rescanCurrentDirectory(fc); + } + + } + + @Override + public void ensureFileIsVisible(JFileChooser fc, File f) { + for (Object ui : uis) { + ((FileChooserUI) ui).ensureFileIsVisible(fc, f); + } + } + +} Index: src/main/java/common/javax/swing/plaf/multi/MultiButtonUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiButtonUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiButtonUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ButtonUI; +import javax.swing.plaf.ComponentUI; + +/** + * All the methods described in public api + * */ +public class MultiButtonUI extends ButtonUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiButtonUI mui = new MultiButtonUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiOptionPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiOptionPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiOptionPaneUI.java (revision 0) @@ -0,0 +1,152 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JOptionPane; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.OptionPaneUI; + +/** + * All the methods described in public api + */ +public class MultiOptionPaneUI extends OptionPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiOptionPaneUI mui = new MultiOptionPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public void selectInitialValue(JOptionPane op) { + for (Object ui : uis) { + ((OptionPaneUI) ui).selectInitialValue(op); + } + + } + + @Override + public boolean containsCustomComponents(JOptionPane op) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((OptionPaneUI) uisIterator.next()).containsCustomComponents(op); + } + return ((OptionPaneUI) uis.firstElement()).containsCustomComponents(op); + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiDesktopPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiDesktopPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiDesktopPaneUI.java (revision 0) @@ -0,0 +1,132 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.DesktopPaneUI; + +/** + * All the methods described in public api + */ +public class MultiDesktopPaneUI extends DesktopPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiDesktopPaneUI mui = new MultiDesktopPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + +} Index: src/main/java/common/javax/swing/plaf/multi/MultiSliderUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiSliderUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiSliderUI.java (revision 0) @@ -0,0 +1,131 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.SliderUI; + +/** + * All the methods described in public api + */ +public class MultiSliderUI extends SliderUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiSliderUI mui = new MultiSliderUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiLookAndFeel.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiLookAndFeel.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiLookAndFeel.java (revision 0) @@ -0,0 +1,118 @@ +package javax.swing.plaf.multi; + +import java.util.Vector; + +import javax.swing.JComponent; +import javax.swing.LookAndFeel; +import javax.swing.UIDefaults; +import javax.swing.UIManager; +import javax.swing.plaf.ComponentUI; + +import org.apache.harmony.x.swing.internal.nls.Messages; + +public class MultiLookAndFeel extends LookAndFeel { + + private static final String prefix = "javax.swing.plaf.multi.Multi"; //$NON-NLS-1$ + + @SuppressWarnings("nls") + private static final UIDefaults classDefaults=new UIDefaults(new Object[] { + "ButtonUI", prefix + "ButtonUI", + "ColorChooserUI", prefix + "ColorChooserUI", + "ComboBoxUI", prefix + "ComboBoxUI", + "DesktopIconUI", prefix + "DesktopIconUI", + "DesktopPaneUI", prefix + "DesktopPaneUI", + "FileChooserUI", prefix + "FileChooserUI", + "InternalFrameUI", prefix + "InternalFrameUI", + "LabelUI", prefix + "LabelUI", + "ListUI", prefix + "ListUI", + "MenuBarUI", prefix + "MenuBarUI", + "MenuItemUI", prefix + "MenuItemUI", + "OptionPaneUI", prefix + "OptionPaneUI", + "PanelUI", prefix + "PanelUI", + "PopupMenuUI", prefix + "PopupMenuUI", + "ProgressBarUI", prefix + "ProgressBarUI", + "RootPaneUI", prefix + "RootPaneUI", + "ScrollBarUI", prefix + "ScrollBarUI", + "ScrollPaneUI", prefix + "ScrollPaneUI", + "SeparatorUI", prefix + "SeparatorUI", + "SliderUI", prefix + "SliderUI", + "SpinnerUI", prefix + "SpinnerUI", + "SplitPaneUI", prefix + "SplitPaneUI", + "TabbedPaneUI", prefix + "TabbedPaneUI", + "TableHeaderUI", prefix + "TableHeaderUI", + "TableUI", prefix + "TableUI", + "TextUI", prefix + "TextUI", + "ToolBarUI", prefix + "ToolBarUI", + "ToolTipUI", prefix + "ToolTipUI", + "TreeUI", prefix + "TreeUI", + "ViewportUI", prefix + "ViewportUI", + }); + + @Override + public String getName() { + return "Multiplexing Look and Feel"; //$NON-NLS-1$ + } + + @Override + public String getID() { + return "Multiplex"; //$NON-NLS-1$ + } + + @Override + public String getDescription() { + return Messages.getString("swing.B5"); //$NON-NLS-1$ + } + + @Override + public boolean isNativeLookAndFeel() { + return false; + } + + @Override + public boolean isSupportedLookAndFeel() { + return true; + } + + @SuppressWarnings("unchecked") + public static ComponentUI createUIs(ComponentUI mui, Vector uis, + JComponent target) { + + LookAndFeel[] auxLafs = UIManager.getAuxiliaryLookAndFeels(); + ComponentUI primaryUI = UIManager.getLookAndFeel().getDefaults().getUI( + target); + ComponentUI auxiliaryUI; + + if (auxLafs != null) { + for (LookAndFeel l : auxLafs) { + auxiliaryUI = l.getDefaults().getUI(target); + if (auxiliaryUI != null) { + uis.add(auxiliaryUI); + } + } + } + if (uis.isEmpty()) { + return UIManager.getLookAndFeel().getDefaults().getUI(target); + } + uis.add(0, primaryUI); + return mui; + } + + @SuppressWarnings("nls") + @Override + public UIDefaults getDefaults() { + return classDefaults; + } + + @SuppressWarnings("unchecked") + protected static ComponentUI[] uisToArray(Vector uis) { + if (uis == null) { + return new ComponentUI[] {}; + } + if (uis.isEmpty()) { + return null; + } + + return (ComponentUI[]) uis.toArray(new ComponentUI[0]); + + } +} Index: src/main/java/common/javax/swing/plaf/multi/MultiTabbedPaneUI.java =================================================================== --- src/main/java/common/javax/swing/plaf/multi/MultiTabbedPaneUI.java (revision 0) +++ src/main/java/common/javax/swing/plaf/multi/MultiTabbedPaneUI.java (revision 0) @@ -0,0 +1,169 @@ +package javax.swing.plaf.multi; + +import java.awt.Dimension; +import java.awt.Graphics; +import java.awt.Rectangle; +import java.util.Iterator; +import java.util.Vector; + +import javax.accessibility.Accessible; +import javax.swing.JComponent; +import javax.swing.JTabbedPane; +import javax.swing.plaf.ComponentUI; +import javax.swing.plaf.TabbedPaneUI; + +/** + * All the methods described in public api + */ +public class MultiTabbedPaneUI extends TabbedPaneUI { + + protected Vector uis = new Vector(); + + /** Irerator used in methods that returns a value */ + private Iterator uisIterator; + + public static ComponentUI createUI(JComponent a) { + MultiTabbedPaneUI mui = new MultiTabbedPaneUI(); + return MultiLookAndFeel.createUIs(mui, mui.uis, a); + } + + @Override + public boolean contains(JComponent a, int b, int c) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).contains(a, b, c); + } + return ((ComponentUI) uis.firstElement()).contains(a, b, c); + } + + @Override + public Accessible getAccessibleChild(JComponent a, int b) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChild(a, b); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChild(a, b); + } + + @Override + public int getAccessibleChildrenCount(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getAccessibleChildrenCount(a); + } + return ((ComponentUI) uis.firstElement()).getAccessibleChildrenCount(a); + } + + @Override + public Dimension getMaximumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMaximumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMaximumSize(a); + } + + @Override + public Dimension getMinimumSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getMinimumSize(a); + } + return ((ComponentUI) uis.firstElement()).getMinimumSize(a); + } + + @Override + public Dimension getPreferredSize(JComponent a) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((ComponentUI) uisIterator.next()).getPreferredSize(a); + } + return ((ComponentUI) uis.firstElement()).getPreferredSize(a); + } + + public ComponentUI[] getUIs() { + return MultiLookAndFeel.uisToArray(uis); + } + + @Override + public void installUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).installUI(a); + } + } + + @Override + public void paint(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).paint(a, b); + } + } + + @Override + public void uninstallUI(JComponent a) { + for (Object ui : uis) { + ((ComponentUI) ui).uninstallUI(a); + } + } + + @Override + public void update(Graphics a, JComponent b) { + for (Object ui : uis) { + ((ComponentUI) ui).update(a, b); + } + } + + @Override + public int tabForCoordinate(JTabbedPane pane, int x, int y) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TabbedPaneUI) uisIterator.next()).tabForCoordinate(pane, x, y); + } + return ((TabbedPaneUI) uis.firstElement()).tabForCoordinate(pane, x, y); + } + + @Override + public Rectangle getTabBounds(JTabbedPane pane, int index) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TabbedPaneUI) uisIterator.next()).getTabBounds(pane, index); + } + return ((TabbedPaneUI) uis.firstElement()).getTabBounds(pane, index); + } + + @Override + public int getTabRunCount(JTabbedPane pane) { + uisIterator = uis.iterator(); + if (uisIterator.hasNext()) { + uisIterator.next(); + } + while (uisIterator.hasNext()) { + ((TabbedPaneUI) uisIterator.next()).getTabRunCount(pane); + } + return ((TabbedPaneUI) uis.firstElement()).getTabRunCount(pane); + } +}