Ticket #4876: style-v3.patch

src/org/openstreetmap/josm/gui/mappaint/SimpleNodeElemStyle.java

@@ -1 +1 @@
 // License: GPL. For details, see LICENSE file.
 package org.openstreetmap.josm.gui.mappaint;
 
+import java.awt.Color;
 import org.openstreetmap.josm.data.osm.Node;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.visitor.paint.MapPaintSettings;
@@ -15 +16 @@
         maxScale = 1500;
     }
 
+    private static final int max(int a, int b) {
+        return (a >= b) ? a : b;
+    }
+
+    private static final int max(int a, int b, int c) {
+        return max(max(a,b), c);
+    }
+
+    private static final int max(int a, int b, int c, int d) {
+        return max(max(a,b), max(c,d));
+    }
+
     @Override
     public void paintPrimitive(OsmPrimitive primitive, MapPaintSettings settings, MapPainter painter,
             boolean selected) {
         Node n = (Node)primitive;
         String name = painter.isShowNames()?painter.getNodeName(n):null;
+
+
         if (n.isHighlighted()) {
             painter.drawNode(n, settings.getHighlightColor(), settings.getSelectedNodeSize(), settings.isFillSelectedNode(), name);
-        } else if (selected) {
-            painter.drawNode(n, settings.getSelectedColor(), settings.getSelectedNodeSize(), settings.isFillSelectedNode(), name);
         } else {
-            painter.drawNode(
-                n,
-                (painter.isInactive() || n.isDisabled()) ? settings.getInactiveColor() : settings.getNodeColor(),
-                n.isJunctionNode() ? settings.getJunctionNodeSize() : settings.getUnselectedNodeSize(),
-                n.isTagged() ? settings.isFillTaggedNode() : settings.isFillUnselectedNode(),
-                name);
+
+            Color color;
+            int size;
+            boolean fill;
+
+            if (painter.isInactive() || n.isDisabled()) {
+                color = settings.getInactiveColor();
+            } else if (selected) {
+                color = settings.getSelectedColor();
+            } else if (n.isJunctionNode()) {
+                if (n.isTagged()) {
+                    color = settings.getTaggedJunctionColor();
+                } else {
+                    color = settings.getJunctionColor();
+                }
+            } else {
+                if (n.isTagged()) {
+                    color = settings.getTaggedColor();
+                } else {
+                    color = settings.getNodeColor();
+                }
+            }
+
+            size = max((selected ? settings.getSelectedNodeSize() : 0),
+                       (n.isTagged() ? settings.getTaggedNodeSize() : 0),
+                       (n.isJunctionNode() ? settings.getJunctionNodeSize() : 0),
+                       settings.getUnselectedNodeSize());
+
+            fill = (selected && settings.isFillSelectedNode()) ||
+                   (n.isTagged() && settings.isFillTaggedNode()) ||
+                   (n.isJunctionNode() && settings.isFillJunctionNode()) ||
+                    settings.isFillUnselectedNode();
+
+            painter.drawNode(n, color, size, fill, name);
         }
     }
 

src/org/openstreetmap/josm/data/osm/visitor/paint/SimplePaintVisitor.java

@@ -61 +61 @@
     protected Color backgroundColor;
     protected Color highlightColor;
     protected Color taggedColor;
+    protected Color junctionColor;
+    protected Color taggedJunctionColor;
     protected boolean showDirectionArrow;
     protected boolean showRelevantDirectionsOnly;
     protected boolean showHeadArrowOnly;
@@ -68 +70 @@
     protected boolean fillSelectedNode;
     protected boolean fillUnselectedNode;
     protected boolean fillTaggedNode;
+    protected boolean fillJunctionNode;
     protected int selectedNodeSize;
     protected int selectedNodeRadius;
     protected int unselectedNodeSize;
     protected int unselectedNodeRadius;
     protected int junctionNodeSize;
     protected int junctionNodeRadius;
+    protected int taggedNodeSize;
+    protected int taggedNodeRadius;
     protected int defaultSegmentWidth;
     protected int virtualNodeSize;
     protected int virtualNodeSpace;
@@ -97 +102 @@
         backgroundColor = PaintColors.BACKGROUND.get();
         highlightColor = PaintColors.HIGHLIGHT.get();
         taggedColor = PaintColors.TAGGED.get();
+        junctionColor = PaintColors.JUNCTION.get();
+
+        if (taggedColor != nodeColor) {
+            taggedJunctionColor = taggedColor;
+        } else {
+            taggedJunctionColor = junctionColor;
+        }
     }
 
     protected void getSettings(boolean virtual) {
@@ -111 +123 @@
         unselectedNodeRadius = unselectedNodeSize / 2;
         junctionNodeSize = settings.getJunctionNodeSize();
         junctionNodeRadius = junctionNodeSize / 2;
+        taggedNodeSize = settings.getTaggedNodeSize();
+        taggedNodeRadius = taggedNodeSize / 2;
         defaultSegmentWidth = settings.getDefaultSegmentWidth();
         fillSelectedNode = settings.isFillSelectedNode();
         fillUnselectedNode = settings.isFillUnselectedNode();
+        fillJunctionNode = settings.isFillJunctionNode();
         fillTaggedNode = settings.isFillTaggedNode();
         virtualNodeSize = virtual ? Main.pref.getInteger("mappaint.node.virtual-size", 8) / 2 : 0;
         virtualNodeSpace = Main.pref.getInteger("mappaint.node.virtual-space", 70);
@@ -223 +238 @@
         //}
     }
 
+    private static final int max(int a, int b) {
+        return (a >= b) ? a : b;
+    }
+    private static final int max(int a, int b, int c) {
+        return max(max(a, b), c);
+    }
+    private static final int max(int a, int b, int c, int d) {
+        return max(max(a, b), max(c, d));
+    }
+
     /**
      * Draw a small rectangle.
      * White if selected (as always) or red otherwise.
@@ -234 +259 @@
 
         if (n.isHighlighted()) {
             drawNode(n, highlightColor, selectedNodeSize, unselectedNodeRadius, fillSelectedNode);
-        } else if (ds.isSelected(n)) {
-            drawNode(n, selectedColor, selectedNodeSize, selectedNodeRadius, fillSelectedNode);
         } else {
-            boolean junction = n.isJunctionNode();
-            drawNode(
-                n,
-                (inactive || n.isDisabled()) ? inactiveColor : 
-                    (n.isTagged() ? taggedColor : nodeColor),
-                junction ? junctionNodeSize : unselectedNodeSize,
-                junction ? junctionNodeRadius : unselectedNodeRadius,
-                n.isTagged() ? fillTaggedNode : fillUnselectedNode);
+            Color color;
+            int size;
+            int radius;
+            boolean fill;
+
+            if (inactive || n.isDisabled()) {
+                color = inactiveColor;
+            } else if (ds.isSelected(n)) {
+                color = selectedColor;
+            } else if (n.isJunctionNode()) {
+                if (n.isTagged()) {
+                    color = taggedJunctionColor;
+                } else {
+                    color = junctionColor;
+                }
+            } else {
+                if (n.isTagged()) {
+                    color = taggedColor;
+                } else {
+                    color = nodeColor;
+                }
+            }
+
+            size = max((ds.isSelected(n) ? selectedNodeSize : 0),
+                       (n.isTagged() ? taggedNodeSize : 0),
+                       (n.isJunctionNode() ? junctionNodeSize : 0),
+                       unselectedNodeSize);
+
+            radius = max((ds.isSelected(n) ? selectedNodeRadius : 0),
+                         (n.isTagged() ? taggedNodeRadius : 0),
+                         (n.isJunctionNode() ? junctionNodeRadius : 0),
+                         unselectedNodeRadius);
+
+            fill = (ds.isSelected(n) && fillSelectedNode) ||
+                   (n.isTagged() && fillTaggedNode) ||
+                   (n.isJunctionNode() && fillJunctionNode) ||
+                    fillUnselectedNode;
+
+            drawNode(n, color, size, radius, fill);
         }
     }
 

src/org/openstreetmap/josm/data/osm/visitor/paint/MapPaintSettings.java

@@ -23 +23 @@
     private int selectedNodeSize;
     private int junctionNodeSize;
     private int unselectedNodeSize;
+    private int taggedNodeSize;
     private boolean fillSelectedNode;
     private boolean fillUnselectedNode;
     private boolean fillTaggedNode;
+    private boolean fillJunctionNode;
     private Color selectedColor;
     private Color highlightColor;
     private Color inactiveColor;
     private Color nodeColor;
     private Color taggedColor;
+    private Color junctionColor;
+    private Color taggedJunctionColor;
 
     private MapPaintSettings() {
         load();
@@ -48 +52 @@
         inactiveColor = PaintColors.INACTIVE.get();
         nodeColor = PaintColors.NODE.get();
         taggedColor = PaintColors.TAGGED.get();
+        junctionColor = PaintColors.JUNCTION.get();
+        if (taggedColor != nodeColor) {
+            taggedJunctionColor = taggedColor;
+        } else {
+            taggedJunctionColor = junctionColor;
+        }
 
+
         showOrderNumber = Main.pref.getBoolean("draw.segment.order_number", false);
         showHeadArrowOnly = Main.pref.getBoolean("draw.segment.head_only", false);
 
@@ -59 +70 @@
         selectedNodeSize = Main.pref.getInteger("mappaint.node.selected-size", 5);
         unselectedNodeSize = Main.pref.getInteger("mappaint.node.unselected-size", 3);
         junctionNodeSize = Main.pref.getInteger("mappaint.node.junction-size", 5);
+        taggedNodeSize = Main.pref.getInteger("mappaint.node.tagged-size", 5);
         fillSelectedNode = Main.pref.getBoolean("mappaint.node.fill-selected", true);
         fillUnselectedNode = Main.pref.getBoolean("mappaint.node.fill-unselected", false);
         fillTaggedNode = Main.pref.getBoolean("mappaint.node.fill-tagged", true);
+        fillJunctionNode = Main.pref.getBoolean("mappaint.node.fill-junction", false);
     }
 
     public void preferenceChanged(PreferenceChangeEvent e) {
@@ -104 +117 @@
         return taggedColor;
     }
 
+    public Color getJunctionColor() {
+        return junctionColor;
+    }
+
+    public Color getTaggedJunctionColor() {
+        return taggedJunctionColor;
+    }
+
     public boolean isShowOrderNumber() {
         return showOrderNumber;
     }
@@ -140 +161 @@
         return unselectedNodeSize;
     }
 
+    public int getTaggedNodeSize() {
+        return taggedNodeSize;
+    }
+
     public boolean isFillSelectedNode() {
         return fillSelectedNode;
     }
@@ -148 +173 @@
         return fillUnselectedNode;
     }
 
+    public boolean isFillJunctionNode() {
+        return fillJunctionNode;
+    }
+
     public boolean isFillTaggedNode() {
         return fillTaggedNode;
     }

src/org/openstreetmap/josm/data/osm/visitor/paint/PaintColors.java

@@ -13 +13 @@
     INACTIVE(marktr("inactive"), Color.darkGray),
     SELECTED(marktr("selected"), Color.red),
     NODE(marktr("node"), Color.yellow),
+    JUNCTION(marktr("junction"), Color.yellow),
     TAGGED(marktr("tagged"), new Color(204, 255, 255)), // turquoise
     DEFAULT_WAY(marktr("way"),  new Color(0,0,128)), // dark blue
     RELATION(marktr("relation"), new Color(0,128,128)), // teal