Changeset 3095 in josm for trunk/src/org/openstreetmap/josm/gui/MultiSplitLayout.java

Timestamp:

08.03.2010 09:24:03 (2 years ago)

Author:

jttt

Message:

Changes in multipolygon handling (see #4661), cosmetics

File:

• trunk/src/org/openstreetmap/josm/gui/MultiSplitLayout.java (modified) (26 diffs)

trunk/src/org/openstreetmap/josm/gui/MultiSplitLayout.java

@@ -42 +42 @@
 import java.util.ListIterator;
 import java.util.Map;
+
 import javax.swing.UIManager;
 
@@ -141 +142 @@
      */
     public void setModel(Node model) {
-        if ((model == null) || (model instanceof Divider)) {
+        if ((model == null) || (model instanceof Divider))
             throw new IllegalArgumentException("invalid model");
-        }
         Node oldModel = model;
         this.model = model;
@@ -168 +168 @@
      */
     public void setDividerSize(int dividerSize) {
-        if (dividerSize < 0) {
+        if (dividerSize < 0)
             throw new IllegalArgumentException("invalid dividerSize");
-        }
         int oldDividerSize = this.dividerSize;
         this.dividerSize = dividerSize;
@@ -212 +211 @@
      */
     public void addLayoutComponent(String name, Component child) {
-        if (name == null) {
+        if (name == null)
             throw new IllegalArgumentException("name not specified");
-        }
         childMap.put(name, child);
     }
@@ -253 +251 @@
 
     private Dimension preferredNodeSize(Node root) {
-        if (root instanceof Leaf) {
+        if (root instanceof Leaf)
             return preferredComponentSize(root);
-        }
         else if (root instanceof Divider) {
             int dividerSize = getDividerSize();
@@ -363 +360 @@
         Rectangle splitBounds = split.getBounds();
         ListIterator<Node> splitChildren = split.getChildren().listIterator();
-        Node lastWeightedChild = split.lastWeightedChild();
 
         if (split.isRowLayout()) {
@@ -385 +381 @@
                 (totalWeightedWidth - minWeightedWidth) > extraWidth;
 
-            while(splitChildren.hasNext()) {
-                Node splitChild = splitChildren.next();
-                Rectangle splitChildBounds = splitChild.getBounds();
-                double minSplitChildWidth = minimumNodeSize(splitChild).getWidth();
-                double splitChildWeight = (onlyShrinkWeightedComponents)
+                while(splitChildren.hasNext()) {
+                    Node splitChild = splitChildren.next();
+                    Rectangle splitChildBounds = splitChild.getBounds();
+                    double minSplitChildWidth = minimumNodeSize(splitChild).getWidth();
+                    double splitChildWeight = (onlyShrinkWeightedComponents)
                     ? splitChild.getWeight()
-                    : (splitChildBounds.getWidth() / (double)totalWidth);
-
-                if (!splitChildren.hasNext()) {
-                    double newWidth =  Math.max(minSplitChildWidth, bounds.getMaxX() - x);
-                    Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, newWidth);
-                    layout2(splitChild, newSplitChildBounds);
-                }
-                else if ((availableWidth > 0.0) && (splitChildWeight > 0.0)) {
-                    double allocatedWidth = Math.rint(splitChildWeight * extraWidth);
-                    double oldWidth = splitChildBounds.getWidth();
-                    double newWidth = Math.max(minSplitChildWidth, oldWidth - allocatedWidth);
-                    Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, newWidth);
-                    layout2(splitChild, newSplitChildBounds);
-                    availableWidth -= (oldWidth - splitChild.getBounds().getWidth());
-                }
-                else {
-                    double existingWidth = splitChildBounds.getWidth();
-                    Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, existingWidth);
-                    layout2(splitChild, newSplitChildBounds);
-                }
-                x = splitChild.getBounds().getMaxX();
-            }
+                            : (splitChildBounds.getWidth() / totalWidth);
+
+                    if (!splitChildren.hasNext()) {
+                        double newWidth =  Math.max(minSplitChildWidth, bounds.getMaxX() - x);
+                        Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, newWidth);
+                        layout2(splitChild, newSplitChildBounds);
+                    }
+                    else if ((availableWidth > 0.0) && (splitChildWeight > 0.0)) {
+                        double allocatedWidth = Math.rint(splitChildWeight * extraWidth);
+                        double oldWidth = splitChildBounds.getWidth();
+                        double newWidth = Math.max(minSplitChildWidth, oldWidth - allocatedWidth);
+                        Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, newWidth);
+                        layout2(splitChild, newSplitChildBounds);
+                        availableWidth -= (oldWidth - splitChild.getBounds().getWidth());
+                    }
+                    else {
+                        double existingWidth = splitChildBounds.getWidth();
+                        Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, existingWidth);
+                        layout2(splitChild, newSplitChildBounds);
+                    }
+                    x = splitChild.getBounds().getMaxX();
+                }
         }
 
@@ -435 +431 @@
                 (totalWeightedHeight - minWeightedHeight) > extraHeight;
 
-            while(splitChildren.hasNext()) {
-                Node splitChild = splitChildren.next();
-                Rectangle splitChildBounds = splitChild.getBounds();
-                double minSplitChildHeight = minimumNodeSize(splitChild).getHeight();
-                double splitChildWeight = (onlyShrinkWeightedComponents)
+                while(splitChildren.hasNext()) {
+                    Node splitChild = splitChildren.next();
+                    Rectangle splitChildBounds = splitChild.getBounds();
+                    double minSplitChildHeight = minimumNodeSize(splitChild).getHeight();
+                    double splitChildWeight = (onlyShrinkWeightedComponents)
                     ? splitChild.getWeight()
-                    : (splitChildBounds.getHeight() / (double)totalHeight);
-
-                if (!splitChildren.hasNext()) {
-                    double oldHeight = splitChildBounds.getHeight();
-                    double newHeight =  Math.max(minSplitChildHeight, bounds.getMaxY() - y);
-                    Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, newHeight);
-                    layout2(splitChild, newSplitChildBounds);
-                    availableHeight -= (oldHeight - splitChild.getBounds().getHeight());
-                }
-                else if ((availableHeight > 0.0) && (splitChildWeight > 0.0)) {
-                    double allocatedHeight = Math.rint(splitChildWeight * extraHeight);
-                    double oldHeight = splitChildBounds.getHeight();
-                    double newHeight = Math.max(minSplitChildHeight, oldHeight - allocatedHeight);
-                    Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, newHeight);
-                    layout2(splitChild, newSplitChildBounds);
-                    availableHeight -= (oldHeight - splitChild.getBounds().getHeight());
-                }
-                else {
-                    double existingHeight = splitChildBounds.getHeight();
-                    Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, existingHeight);
-                    layout2(splitChild, newSplitChildBounds);
-                }
-                y = splitChild.getBounds().getMaxY();
-            }
+                            : (splitChildBounds.getHeight() / totalHeight);
+
+                    if (!splitChildren.hasNext()) {
+                        double oldHeight = splitChildBounds.getHeight();
+                        double newHeight =  Math.max(minSplitChildHeight, bounds.getMaxY() - y);
+                        Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, newHeight);
+                        layout2(splitChild, newSplitChildBounds);
+                        availableHeight -= (oldHeight - splitChild.getBounds().getHeight());
+                    }
+                    else if ((availableHeight > 0.0) && (splitChildWeight > 0.0)) {
+                        double allocatedHeight = Math.rint(splitChildWeight * extraHeight);
+                        double oldHeight = splitChildBounds.getHeight();
+                        double newHeight = Math.max(minSplitChildHeight, oldHeight - allocatedHeight);
+                        Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, newHeight);
+                        layout2(splitChild, newSplitChildBounds);
+                        availableHeight -= (oldHeight - splitChild.getBounds().getHeight());
+                    }
+                    else {
+                        double existingHeight = splitChildBounds.getHeight();
+                        Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, existingHeight);
+                        layout2(splitChild, newSplitChildBounds);
+                    }
+                    y = splitChild.getBounds().getMaxY();
+                }
         }
 
@@ -508 +504 @@
                 else if ((availableWidth > 0.0) && (splitChildWeight > 0.0)) {
                     double allocatedWidth = (splitChild.equals(lastWeightedChild))
-                        ? availableWidth
-                        : Math.rint(splitChildWeight * extraWidth);
+                    ? availableWidth
+                            : Math.rint(splitChildWeight * extraWidth);
                     double newWidth = splitChildBounds.getWidth() + allocatedWidth;
                     Rectangle newSplitChildBounds = boundsWithXandWidth(bounds, x, newWidth);
@@ -550 +546 @@
                 else if ((availableHeight > 0.0) && (splitChildWeight > 0.0)) {
                     double allocatedHeight = (splitChild.equals(lastWeightedChild))
-                        ? availableHeight
-                        : Math.rint(splitChildWeight * extraHeight);
+                    ? availableHeight
+                            : Math.rint(splitChildWeight * extraHeight);
                     double newHeight = splitChildBounds.getHeight() + allocatedHeight;
                     Rectangle newSplitChildBounds = boundsWithYandHeight(bounds, y, newHeight);
@@ -570 +566 @@
      * as needed.
      */
-   private void layout2(Node root, Rectangle bounds) {
+    private void layout2(Node root, Rectangle bounds) {
         if (root instanceof Leaf) {
             Component child = childForNode(root);
@@ -584 +580 @@
             Split split = (Split)root;
             boolean grow = split.isRowLayout()
-                ? (split.getBounds().width <= bounds.width)
-                : (split.getBounds().height <= bounds.height);
+            ? (split.getBounds().width <= bounds.width)
+                    : (split.getBounds().height <= bounds.height);
             if (grow) {
                 layoutGrow(split, bounds);
@@ -635 +631 @@
                         (splitChildren.hasNext()) ? (Divider)(splitChildren.next()) : null;
 
-                    double childWidth = 0.0;
-                    if (getFloatingDividers()) {
-                        childWidth = preferredNodeSize(splitChild).getWidth();
-                    }
-                    else {
-                        if (dividerChild != null) {
-                            childWidth = dividerChild.getBounds().getX() - x;
+                        double childWidth = 0.0;
+                        if (getFloatingDividers()) {
+                            childWidth = preferredNodeSize(splitChild).getWidth();
                         }
                         else {
-                            childWidth = split.getBounds().getMaxX() - x;
+                            if (dividerChild != null) {
+                                childWidth = dividerChild.getBounds().getX() - x;
+                            }
+                            else {
+                                childWidth = split.getBounds().getMaxX() - x;
+                            }
                         }
-                    }
-                    childBounds = boundsWithXandWidth(bounds, x, childWidth);
-                    layout1(splitChild, childBounds);
-
-                    if (getFloatingDividers() && (dividerChild != null)) {
-                        double dividerX = childBounds.getMaxX();
-                        Rectangle dividerBounds = boundsWithXandWidth(bounds, dividerX, dividerSize);
-                        dividerChild.setBounds(dividerBounds);
-                    }
-                    if (dividerChild != null) {
-                        x = dividerChild.getBounds().getMaxX();
-                    }
+                        childBounds = boundsWithXandWidth(bounds, x, childWidth);
+                        layout1(splitChild, childBounds);
+
+                        if (getFloatingDividers() && (dividerChild != null)) {
+                            double dividerX = childBounds.getMaxX();
+                            Rectangle dividerBounds = boundsWithXandWidth(bounds, dividerX, dividerSize);
+                            dividerChild.setBounds(dividerBounds);
+                        }
+                        if (dividerChild != null) {
+                            x = dividerChild.getBounds().getMaxX();
+                        }
                 }
             }
@@ -673 +669 @@
                         (splitChildren.hasNext()) ? (Divider)(splitChildren.next()) : null;
 
-                    double childHeight = 0.0;
-                    if (getFloatingDividers()) {
-                        childHeight = preferredNodeSize(splitChild).getHeight();
-                    }
-                    else {
-                        if (dividerChild != null) {
-                            childHeight = dividerChild.getBounds().getY() - y;
+                        double childHeight = 0.0;
+                        if (getFloatingDividers()) {
+                            childHeight = preferredNodeSize(splitChild).getHeight();
                         }
                         else {
-                            childHeight = split.getBounds().getMaxY() - y;
+                            if (dividerChild != null) {
+                                childHeight = dividerChild.getBounds().getY() - y;
+                            }
+                            else {
+                                childHeight = split.getBounds().getMaxY() - y;
+                            }
                         }
-                    }
-                    childBounds = boundsWithYandHeight(bounds, y, childHeight);
-                    layout1(splitChild, childBounds);
-
-                    if (getFloatingDividers() && (dividerChild != null)) {
-                        double dividerY = childBounds.getMaxY();
-                        Rectangle dividerBounds = boundsWithYandHeight(bounds, dividerY, dividerSize);
-                        dividerChild.setBounds(dividerBounds);
-                    }
-                    if (dividerChild != null) {
-                        y = dividerChild.getBounds().getMaxY();
-                    }
+                        childBounds = boundsWithYandHeight(bounds, y, childHeight);
+                        layout1(splitChild, childBounds);
+
+                        if (getFloatingDividers() && (dividerChild != null)) {
+                            double dividerY = childBounds.getMaxY();
+                            Rectangle dividerBounds = boundsWithYandHeight(bounds, dividerY, dividerSize);
+                            dividerChild.setBounds(dividerBounds);
+                        }
+                        if (dividerChild != null) {
+                            y = dividerChild.getBounds().getMaxY();
+                        }
                 }
             }
@@ -781 +777 @@
             Split split = (Split)root;
             for(Node child : split.getChildren()) {
-                if (child.getBounds().contains(x, y)) {
+                if (child.getBounds().contains(x, y))
                     return dividerAt(child, x, y);
-                }
             }
         }
@@ -804 +799 @@
         Rectangle r1 = node.getBounds();
         return
-            (r1.x <= (r2.x + r2.width)) && ((r1.x + r1.width) >= r2.x) &&
-            (r1.y <= (r2.y + r2.height)) && ((r1.y + r1.height) >= r2.y);
+        (r1.x <= (r2.x + r2.width)) && ((r1.x + r1.width) >= r2.x) &&
+        (r1.y <= (r2.y + r2.height)) && ((r1.y + r1.height) >= r2.y);
     }
 
@@ -822 +817 @@
             }
             return dividers;
-        }
-        else {
+        } else
             return Collections.emptyList();
-        }
     }
 
@@ -837 +830 @@
      */
     public List<Divider> dividersThatOverlap(Rectangle r) {
-        if (r == null) {
+        if (r == null)
             throw new IllegalArgumentException("null Rectangle");
-        }
         return dividersThatOverlap(getModel(), r);
     }
@@ -890 +882 @@
          */
         public void setBounds(Rectangle bounds) {
-            if (bounds == null) {
+            if (bounds == null)
                 throw new IllegalArgumentException("null bounds");
-            }
             this.bounds = new Rectangle(bounds);
         }
@@ -921 +912 @@
          */
         public void setWeight(double weight) {
-            if ((weight < 0.0)|| (weight > 1.0)) {
+            if ((weight < 0.0)|| (weight > 1.0))
                 throw new IllegalArgumentException("invalid weight");
-            }
             this.weight = weight;
         }
@@ -929 +919 @@
         private Node siblingAtOffset(int offset) {
             Split parent = getParent();
-            if (parent == null) { return null; }
+            if (parent == null)
+                return null;
             List<Node> siblings = parent.getChildren();
             int index = siblings.indexOf(this);
-            if (index == -1) { return null; }
+            if (index == -1)
+                return null;
             index += offset;
             return ((index > -1) && (index < siblings.size())) ? siblings.get(index) : null;
@@ -1020 +1012 @@
          */
         public void setChildren(List<Node> children) {
-            if (children == null) {
+            if (children == null)
                 throw new IllegalArgumentException("children must be a non-null List");
-            }
             for(Node child : this.children) {
                 child.setParent(null);
@@ -1051 +1042 @@
         }
 
+        @Override
         public String toString() {
             int nChildren = getChildren().size();
@@ -1081 +1073 @@
          */
         public Leaf(String name) {
-            if (name == null) {
+            if (name == null)
                 throw new IllegalArgumentException("name is null");
-            }
             this.name = name;
         }
@@ -1102 +1093 @@
          */
         public void setName(String name) {
-            if (name == null) {
+            if (name == null)
                 throw new IllegalArgumentException("name is null");
-            }
             this.name = name;
         }
 
+        @Override
         public String toString() {
             StringBuffer sb = new StringBuffer("MultiSplitLayout.Leaf");
@@ -1142 +1133 @@
          * @throws UnsupportedOperationException
          */
+        @Override
         public void setWeight(double weight) {
             throw new UnsupportedOperationException();
         }
 
+        @Override
         public String toString() {
             return "MultiSplitLayout.Divider " + getBounds().toString();