Ignore:
Timestamp:
2009-04-06T12:46:43+02:00 (16 years ago)
Author:
juangui
Message:

Added support for multiple routing layers.

Location:
applications/editors/josm/plugins/routing/src/com/innovant/josm
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/jrt/core/RoutingGraph.java

    r14287 r14404  
    3838import org.jgrapht.graph.AsUndirectedGraph;
    3939import org.jgrapht.graph.DirectedWeightedMultigraph;
    40 import org.openstreetmap.josm.Main;
     40import org.openstreetmap.josm.data.osm.DataSet;
    4141import org.openstreetmap.josm.data.osm.Node;
    4242import org.openstreetmap.josm.data.osm.Way;
     
    7474        private RouteType routeType;
    7575
     76    /**
     77     * Associated Osm DataSet
     78     */
     79        private DataSet data;
     80
    7681        /**
    7782         * Logger.
     
    101106         * Default Constructor.
    102107         */
    103         public RoutingGraph() {
     108        public RoutingGraph(DataSet data) {
    104109                this.graphState = false;
    105110                this.graph = null;
     111                this.data = data;
    106112                routeType=RouteType.SHORTEST;
    107113                routingProfile=new RoutingProfile("default");
     
    118124        public void createGraph() {
    119125
    120                 logger.debug("Init Create Graph");
     126                logger.debug("Creating Graph...");
    121127                graph = new DirectedWeightedMultigraph<Node, OsmEdge>(OsmEdge.class);
    122128
    123129                // iterate all ways and segments for all nodes:
    124                 for (Way way : Main.ds.ways) {
     130                for (Way way : data.ways) {
    125131                        if (way != null && !way.deleted && this.isvalidWay(way)) {
    126132                                Node from = null;
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/RoutingLayer.java

    r14287 r14404  
    3737import java.util.ArrayList;
    3838import java.util.Collection;
     39import java.util.LinkedList;
    3940import java.util.List;
     41import java.util.TreeMap;
    4042
    4143import javax.swing.Icon;
     
    4749import org.openstreetmap.josm.actions.RenameLayerAction;
    4850import org.openstreetmap.josm.data.osm.Node;
     51import org.openstreetmap.josm.data.osm.Way;
     52import org.openstreetmap.josm.data.osm.WaySegment;
    4953import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
    5054import org.openstreetmap.josm.gui.MapView;
     55import org.openstreetmap.josm.gui.NavigatableComponent;
    5156import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
    5257import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
    5358import org.openstreetmap.josm.gui.layer.Layer;
     59import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    5460import org.openstreetmap.josm.tools.ColorHelper;
    5561import org.openstreetmap.josm.tools.ImageProvider;
     
    8288
    8389    /**
    84      * Icon Start Middle End
     90     * Start, Middle and End icons
    8591     */
    8692    private Icon startIcon,middleIcon,endIcon;
    8793
    8894    /**
    89      * Flag that manager activation layer
    90      */
    91     private boolean layerAdded = false;
     95     * Associated OSM layer
     96     */
     97    private OsmDataLayer dataLayer;
     98
     99//    /**
     100//     * Flag that manager activation layer
     101//     */
     102//    private boolean layerAdded = false;
    92103
    93104    /**
     
    95106     * @param name Layer name.
    96107     */
    97         public RoutingLayer(String name) {
     108        public RoutingLayer(String name, OsmDataLayer dataLayer) {
    98109                super(name);
    99                 logger.debug("Init Routing Layer");
     110                logger.debug("Creating Routing Layer...");
    100111        if(startIcon == null) startIcon = ImageProvider.get("routing", "startflag");
    101112        if(middleIcon == null) middleIcon = ImageProvider.get("routing", "middleflag");
    102113        if(endIcon == null) endIcon = ImageProvider.get("routing", "endflag");
    103         this.routingModel = new RoutingModel();
    104         logger.debug("End init Routing Layer");
     114        this.dataLayer = dataLayer;
     115        this.routingModel = new RoutingModel(dataLayer.data);
     116        logger.debug("Routing Layer created.");
    105117        }
    106118
     
    114126
    115127        /**
    116          * Check if layer is load.
    117          * @return <code>true</code> Layer load.
    118          *         <code>false</code> Layer don't load.
    119          */
    120         public boolean isLayerAdded() {
    121                 return layerAdded;
     128         * Gets associated data layer
     129         * @return OsmDataLayer associated to the RoutingLayer
     130         */
     131        public OsmDataLayer getDataLayer() {
     132                return dataLayer;
    122133        }
    123134
    124135        /**
    125          * Setter layer active.
    126          */
    127         public void setLayerAdded() {
    128                 layerAdded = true;
    129         }
     136         * Gets nearest node belonging to a highway tagged way
     137         * @param p Point on the screen
     138         * @return The nearest highway node, in the range of the snap distance
     139         */
     140    public final Node getNearestHighwayNode(Point p) {
     141        Node nearest = null;
     142        double minDist = 0;
     143        for (Way w : dataLayer.data.ways) {
     144            if (w.deleted || w.incomplete || w.get("highway")==null) continue;
     145            for (Node n : w.nodes) {
     146                if (n.deleted || n.incomplete) continue;
     147
     148                Point P = Main.map.mapView.getPoint(n.eastNorth);
     149                double dist = p.distanceSq(P);
     150                if (dist < NavigatableComponent.snapDistance) {
     151                        if ((nearest == null) || (dist < minDist)) {
     152                                nearest = n;
     153                                minDist = dist;
     154                        }
     155                }
     156            }
     157        }
     158        return nearest;
     159    }
     160
     161//      /**
     162//       * Check if layer is load.
     163//       * @return <code>true</code> Layer load.
     164//       *         <code>false</code> Layer don't load.
     165//       */
     166//      public boolean isLayerAdded() {
     167//              return layerAdded;
     168//      }
     169//
     170//      /**
     171//       * Setter layer active.
     172//       */
     173//      public void setLayerAdded() {
     174//              layerAdded = true;
     175//      }
    130176
    131177        /*
     
    283329    public void destroy() {
    284330                routingModel.reset();
    285                 layerAdded = false;
     331//              layerAdded = false;
    286332        }
    287333
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/RoutingModel.java

    r14287 r14404  
    3232
    3333import org.apache.log4j.Logger;
     34import org.openstreetmap.josm.data.osm.DataSet;
    3435import org.openstreetmap.josm.data.osm.Node;
    3536
     
    7071     * Default Constructor.
    7172     */
    72         public RoutingModel() {
     73        public RoutingModel(DataSet data) {
    7374        nodes = new ArrayList<Node>();
    74         routingGraph = new RoutingGraph();
     75        routingGraph = new RoutingGraph(data);
    7576        }
    7677
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/RoutingPlugin.java

    r14395 r14404  
    3333
    3434import static org.openstreetmap.josm.tools.I18n.tr;
     35
     36import java.lang.reflect.Array;
     37import java.util.ArrayList;
    3538
    3639import org.apache.log4j.Logger;
     
    4043import org.openstreetmap.josm.gui.MapFrame;
    4144import org.openstreetmap.josm.gui.layer.Layer;
     45import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    4246import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    4347import org.openstreetmap.josm.gui.preferences.PreferenceSetting;
     
    6569        static Logger logger = Logger.getLogger(RoutingPlugin.class);
    6670
    67         /**
    68          * Displays the layer menu when right clicking on the layer name, and manages
    69          * how to paint the layer.
    70          */
    71     private RoutingLayer routingLayer;
     71    /**
     72     * The list of routing layers
     73     */
     74    private ArrayList<RoutingLayer> layers;
    7275
    7376    /**
     
    136139                // Create side dialog
    137140                routingDialog = new RoutingDialog();
    138         // Add routing layer
    139         routingLayer = new RoutingLayer(tr("Navigation"));
     141                // Initialize layers list
     142                layers = new ArrayList<RoutingLayer>();
    140143        // Add menu
    141144        menu = new RoutingMenu(tr("Routing"));
     
    155158
    156159        /**
    157          * Get the routing layer
    158          * @return The instance of the routing layer
    159          */
    160         public RoutingLayer getRoutingLayer() {
    161                 return routingLayer;
    162         }
    163 
    164         /**
    165160         * Get the routing side dialog
    166161         * @return The instance of the routing side dialog
     
    168163        public RoutingDialog getRoutingDialog() {
    169164                return routingDialog;
     165        }
     166
     167        public void addLayer() {
     168                OsmDataLayer osmLayer = Main.main.editLayer();
     169                RoutingLayer layer = new RoutingLayer(tr("Routing") + " [" + osmLayer.name + "]", osmLayer);
     170                layers.add(layer);
     171                Main.main.addLayer(layer);
    170172        }
    171173
     
    181183                removeRouteNodeAction = new RemoveRouteNodeAction(newFrame);
    182184                moveRouteNodeAction = new MoveRouteNodeAction(newFrame);
    183                 // Create plugin buttons and add them to the tool bar
     185                // Create plugin buttons and add them to the toolbar
    184186                addRouteNodeButton = new IconToggleButton(addRouteNodeAction);
    185187                removeRouteNodeButton = new IconToggleButton(removeRouteNodeAction);
     
    205207     * @see org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener#activeLayerChange(org.openstreetmap.josm.gui.layer.Layer, org.openstreetmap.josm.gui.layer.Layer)
    206208     */
    207         public void activeLayerChange(Layer oldLayer, Layer newLayer) {}
     209        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     210                routingDialog.refresh();
     211        }
    208212
    209213        /*
     
    214218                // Add button(s) to the tool bar when the routing layer is added
    215219                if (newLayer instanceof RoutingLayer) {
    216                         newLayer.name=tr("Routing")+" ["+Main.map.mapView.getActiveLayer().name+"]";
    217220                        addRouteNodeButton.setVisible(true);
    218221                        removeRouteNodeButton.setVisible(true);
    219222                        moveRouteNodeButton.setVisible(true);
    220223                        menu.enableRestOfItems();
     224                        // Set layer on top and select layer, also refresh toggleDialog to reflect selection
     225                        Main.map.mapView.moveLayer(newLayer, 0);
     226//                      Main.map.mapView.setActiveLayer(newLayer);
     227//                      Main.map.toggleDialogs.repaint();
    221228                        logger.debug("Added routing layer.");
    222229                }
     
    228235         */
    229236        public void layerRemoved(Layer oldLayer) {
    230                 // Remove button(s) from the tool bar when the routing layer is removed
    231                 if (oldLayer instanceof RoutingLayer) {
     237                if ((oldLayer instanceof RoutingLayer) & (layers.size()==1)) {
     238                        // Remove button(s) from the tool bar when the last routing layer is removed
    232239                        addRouteNodeButton.setVisible(false);
    233240                        removeRouteNodeButton.setVisible(false);
    234241                        moveRouteNodeButton.setVisible(false);
    235242                        menu.disableRestOfItems();
     243                        layers.remove(oldLayer);
    236244                logger.debug("Removed routing layer.");
     245                } else if (oldLayer instanceof OsmDataLayer) {
     246                        // Remove all associated routing layers
     247                        // Convert to Array to prevent ConcurrentModificationException when removing layers from ArrayList
     248                        // FIXME: can't remove associated routing layers without triggering exceptions in some cases
     249                        RoutingLayer[] layersArray = layers.toArray(new RoutingLayer[0]);
     250                        for (int i=0;i<layersArray.length;i++) {
     251                                if (layersArray[i].getDataLayer().equals(oldLayer)) {
     252                                        // Move layer to the top
     253                                        Main.map.mapView.moveLayer(layersArray[i], 0);
     254                                        try {
     255                                                // Remove layer
     256                                                Main.map.mapView.removeLayer(layersArray[i]);
     257                                        } catch (IllegalArgumentException e) {
     258                                        }
     259                                }
     260                        }
    237261                }
     262                // Reload RoutingDialog table model
     263                routingDialog.refresh();
    238264        }
    239265
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/actions/AddRouteNodeAction.java

    r14287 r14404  
    3131
    3232import java.awt.event.MouseEvent;
    33 import java.util.List;
    3433
    3534import org.apache.log4j.Logger;
     
    3736import org.openstreetmap.josm.actions.mapmode.MapMode;
    3837import org.openstreetmap.josm.data.osm.Node;
    39 import org.openstreetmap.josm.data.osm.WaySegment;
    4038import org.openstreetmap.josm.gui.MapFrame;
    4139import org.openstreetmap.josm.tools.ImageProvider;
    4240
    4341import com.innovant.josm.plugin.routing.RoutingLayer;
    44 import com.innovant.josm.plugin.routing.RoutingModel;
    4542import com.innovant.josm.plugin.routing.RoutingPlugin;
    4643import com.innovant.josm.plugin.routing.gui.RoutingDialog;
     
    6259         */
    6360        static Logger logger = Logger.getLogger(AddRouteNodeAction.class);
    64     /**
    65      * Routing Model.
    66      */
    67         private RoutingModel routingModel;
    68         /**
    69          * Routing Layer.
    70          */
    71     private RoutingLayer routingLayer;
    7261        /**
    7362         * Routing Dialog.
     
    8473                                tr("Click to add route nodes."),
    8574                                mapFrame, ImageProvider.getCursor("crosshair", null));
    86         this.routingLayer = RoutingPlugin.getInstance().getRoutingLayer();
    87         this.routingModel = routingLayer.getRoutingModel();
    8875        this.routingDialog = RoutingPlugin.getInstance().getRoutingDialog();
    8976        }
     
    10491                // Search for nearest highway node
    10592                Node node = null;
    106                 List<WaySegment> wsl = Main.map.mapView.getNearestWaySegments(e.getPoint());
    107                 for (WaySegment ws:wsl) {
    108                         if (ws.way.get("highway")!=null) {
    109                                 // If waysegment belongs to a highway compare the distance from
    110                                 // both waysegment nodes to the point clicked and keep the nearest one
    111                                 Node node0 = ws.way.nodes.get(ws.lowerIndex);
    112                                 Node node1 = ws.way.nodes.get(ws.lowerIndex + 1);
    113                                 double d0 = Main.map.mapView.getPoint(node0.eastNorth).distanceSq(e.getPoint());
    114                                 double d1 = Main.map.mapView.getPoint(node1.eastNorth).distanceSq(e.getPoint());
    115                                 if (d0<d1)
    116                                         node = node0;
    117                                 else
    118                                         node = node1;
    119                                 break;
    120                         }
     93                if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     94                        RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     95                        node = layer.getNearestHighwayNode(e.getPoint());
     96                if(node == null) {
     97                        logger.debug("no selected node");
     98                    return;
     99                }
     100                logger.debug("selected node " + node);
     101                layer.getRoutingModel().addNode(node);
     102                routingDialog.addNode(node);
    121103                }
    122             logger.debug("selected node " + node);
    123             if(node == null) {
    124                 logger.debug("no selected node");
    125                 return;
    126             }
    127             routingModel.addNode(node);
    128             routingDialog.addNode(node.id+" ["+node.coor.toDisplayString()+"]");
    129104        }
    130105        Main.map.repaint();
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/actions/MoveRouteNodeAction.java

    r14287 r14404  
    3838import org.openstreetmap.josm.actions.mapmode.MapMode;
    3939import org.openstreetmap.josm.data.osm.Node;
    40 import org.openstreetmap.josm.data.osm.WaySegment;
    4140import org.openstreetmap.josm.gui.MapFrame;
    4241import org.openstreetmap.josm.tools.ImageProvider;
     
    7170
    7271        /**
    73      * Routing Model.
    74      */
    75         private RoutingModel routingModel;
    76 
    77         /**
    78          * Routing Layer.
    79          */
    80     private RoutingLayer routingLayer;
    81 
    82         /**
    8372         * Routing Dialog.
    8473         */
     
    9988                                tr("Click and drag to move route nodes."),
    10089                                mapFrame, ImageProvider.getCursor("normal", "move"));
    101         this.routingLayer = RoutingPlugin.getInstance().getRoutingLayer();
    102         this.routingModel = routingLayer.getRoutingModel();
    10390        this.routingDialog = RoutingPlugin.getInstance().getRoutingDialog();
    10491        }
     
    117104        // If left button is pressed
    118105        if (e.getButton() == MouseEvent.BUTTON1) {
    119                 // Search for the nearest node in the list
    120                 List<Node> nl = routingModel.getSelectedNodes();
    121                 index = -1;
    122                 double dmax = DRAG_SQR_RADIUS; // maximum distance, in pixels
    123                 for (int i=0;i<nl.size();i++) {
    124                         Node node = nl.get(i);
    125                         double d = Main.map.mapView.getPoint(node.eastNorth).distanceSq(e.getPoint());
    126                         if (d < dmax) {
    127                                 dmax = d;
    128                                 index = i;
    129                         }
     106                if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     107                        RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     108                        RoutingModel routingModel = layer.getRoutingModel();
     109                // Search for the nearest node in the list
     110                List<Node> nl = routingModel.getSelectedNodes();
     111                index = -1;
     112                double dmax = DRAG_SQR_RADIUS; // maximum distance, in pixels
     113                for (int i=0;i<nl.size();i++) {
     114                        Node node = nl.get(i);
     115                        double d = Main.map.mapView.getPoint(node.eastNorth).distanceSq(e.getPoint());
     116                        if (d < dmax) {
     117                                dmax = d;
     118                                index = i;
     119                        }
     120                }
     121                if (index>=0)
     122                    logger.debug("Moved from node " + nl.get(index));
    130123                }
    131                 if (index>=0)
    132                 logger.debug("Moved from node " + nl.get(index));
    133124        }
    134125    }
     
    145136
    146137    private void searchAndReplaceNode(Point point) {
    147         // Search for nearest highway node
    148         Node node = null;
    149         List<WaySegment> wsl = Main.map.mapView.getNearestWaySegments(point);
    150         for (WaySegment ws:wsl) {
    151                 if (ws.way.get("highway")!=null) {
    152                         // If waysegment belongs to a highway compare the distance from
    153                         // both waysegment nodes to the point clicked and keep the nearest one
    154                         Node node0 = ws.way.nodes.get(ws.lowerIndex);
    155                         Node node1 = ws.way.nodes.get(ws.lowerIndex + 1);
    156                         double d0 = Main.map.mapView.getPoint(node0.eastNorth).distanceSq(point);
    157                         double d1 = Main.map.mapView.getPoint(node1.eastNorth).distanceSq(point);
    158                         if (d0<d1)
    159                                 node = node0;
    160                         else
    161                                 node = node1;
    162                         break;
    163                 }
     138        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     139                RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     140                RoutingModel routingModel = layer.getRoutingModel();
     141                // Search for nearest highway node
     142                Node node = null;
     143                node = layer.getNearestHighwayNode(point);
     144            if (node == null) {
     145                logger.debug("Didn't found a close node to move to.");
     146                return;
     147            }
     148            logger.debug("Moved to node " + node);
     149            routingModel.removeNode(index);
     150                routingDialog.removeNode(index);
     151            routingModel.insertNode(index, node);
     152                routingDialog.insertNode(index, node);
     153            Main.map.repaint();
    164154        }
    165         if (node == null) {
    166                 logger.debug("Didn't found a close node to move to.");
    167             return;
    168         }
    169         logger.debug("Moved to node " + node);
    170         routingModel.removeNode(index);
    171                 routingDialog.removeNode(index);
    172         routingModel.insertNode(index, node);
    173                 routingDialog.insertNode(index,node.id+" ["+node.coor.toDisplayString()+"]");
    174         Main.map.repaint();
    175155    }
    176156}
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/actions/RemoveRouteNodeAction.java

    r14287 r14404  
    6767         */
    6868        static Logger logger = Logger.getLogger(RoutingLayer.class);
    69     /**
    70      * Routing Model.
    71      */
    72         private RoutingModel routingModel;
    73         /**
    74          * Routing Layer.
    75          */
    76     private RoutingLayer routingLayer;
    7769        /**
    7870         * Routing Dialog.
     
    8577                                tr("Remove route nodes"),
    8678                                mapFrame, ImageProvider.getCursor("normal", "delete"));
    87         this.routingLayer = RoutingPlugin.getInstance().getRoutingLayer();
    88         this.routingModel = routingLayer.getRoutingModel();
    8979        this.routingDialog = RoutingPlugin.getInstance().getRoutingDialog();
    9080        }
     
    10393        // If left button is clicked
    10494        if (e.getButton() == MouseEvent.BUTTON1) {
    105                 // Search for the nearest node in the list
    106                 List<Node> nl = routingModel.getSelectedNodes();
    107                 int index = -1;
    108                 double dmax = REMOVE_SQR_RADIUS; // maximum distance, in pixels
    109                 for (int i=0;i<nl.size();i++) {
    110                         Node node = nl.get(i);
    111                         double d = Main.map.mapView.getPoint(node.eastNorth).distanceSq(e.getPoint());
    112                         if (d < dmax) {
    113                                 dmax = d;
    114                                 index = i;
    115                         }
     95                if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     96                        RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     97                        RoutingModel routingModel = layer.getRoutingModel();
     98                // Search for the nearest node in the list
     99                List<Node> nl = routingModel.getSelectedNodes();
     100                int index = -1;
     101                double dmax = REMOVE_SQR_RADIUS; // maximum distance, in pixels
     102                for (int i=0;i<nl.size();i++) {
     103                        Node node = nl.get(i);
     104                        double d = Main.map.mapView.getPoint(node.eastNorth).distanceSq(e.getPoint());
     105                        if (d < dmax) {
     106                                dmax = d;
     107                                index = i;
     108                        }
     109                }
     110                // If found a close node, remove it and recalculate route
     111                if (index >= 0) {
     112                        // Remove node
     113                        logger.debug("Removing node " + nl.get(index));
     114                    routingModel.removeNode(index);
     115                        routingDialog.removeNode(index);
     116                    Main.map.repaint();
     117                } else {
     118                        logger.debug("Can't find a node to remove.");
     119                }
    116120                }
    117                 // If found a close node, remove it and recalculate route
    118             if (index >= 0) {
    119                 // Remove node
    120                 logger.debug("Removing node " + nl.get(index));
    121                 routingModel.removeNode(index);
    122                         routingDialog.removeNode(index);
    123                 Main.map.repaint();
    124             } else {
    125                 logger.debug("Can't find a node to remove.");
    126             }
    127121        }
    128122    }
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/gui/RoutingDialog.java

    r14287 r14404  
    4141import javax.swing.border.EtchedBorder;
    4242
     43import org.openstreetmap.josm.Main;
     44import org.openstreetmap.josm.data.osm.Node;
    4345import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
    4446import org.openstreetmap.josm.tools.Shortcut;
     47
     48import com.innovant.josm.plugin.routing.RoutingLayer;
     49import com.innovant.josm.plugin.routing.RoutingModel;
    4550
    4651
     
    119124         * @param obj
    120125         */
    121         public void addNode(Object txt) {
    122                 model.addElement(txt);
     126        public void addNode(Node n) {
     127                model.addElement(n.id+" ["+n.coor.toDisplayString()+"]");
    123128        }
    124129
     
    128133         * @param obj
    129134         */
    130         public void insertNode(int index, Object txt) {
    131                 model.insertElementAt(txt, index);
     135        public void insertNode(int index, Node n) {
     136                model.insertElementAt(n.id+" ["+n.coor.toDisplayString()+"]", index);
    132137        }
    133138
     
    139144        }
    140145
     146        public void refresh() {
     147                clearNodes();
     148        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     149                RoutingLayer routingLayer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     150                RoutingModel routingModel = routingLayer.getRoutingModel();
     151                for (Node n : routingModel.getSelectedNodes()) {
     152                        addNode(n);
     153                }
     154        }
     155        }
    141156}
  • applications/editors/josm/plugins/routing/src/com/innovant/josm/plugin/routing/gui/RoutingMenu.java

    r14395 r14404  
    7070        public RoutingMenu(final String name) {
    7171                super(name);
    72                 final RoutingLayer routingLayer = RoutingPlugin.getInstance().getRoutingLayer();
    73                 final RoutingModel routingModel = routingLayer.getRoutingModel();
    7472
    7573                JMenuItem mi;
    7674                JMenu m;
    7775
    78                 startMI = new JMenuItem(tr("Start routing"));
     76                startMI = new JMenuItem(tr("Add routing layer"));
    7977                startMI.addActionListener(new ActionListener() {
    8078                        public void actionPerformed(ActionEvent e) {
    81                                 if(!routingLayer.isLayerAdded()) {
    82                                         routingLayer.setLayerAdded();
    83                                         Main.main.addLayer(routingLayer);
    84                                 }
     79                                RoutingPlugin.getInstance().addLayer();
    8580                        }
    8681                });
     
    9691                rshorter.addItemListener(new ItemListener() {
    9792                        public void itemStateChanged(ItemEvent e) {
    98                                 if (e.getStateChange()==ItemEvent.SELECTED) {
    99                                         routingModel.routingGraph.setTypeRoute(RouteType.SHORTEST);
    100                                 } else {
    101                                         routingModel.routingGraph.setTypeRoute(RouteType.FASTEST);
    102                                 }
    103                                 routingModel.routingGraph.resetGraph();
    104                                 routingModel.routingGraph.createGraph();
    105                                 //TODO: Change this way
    106                                 //FIXME: do not change node but recalculate routing.
    107                                 routingModel.setNodesChanged();
    108                                 Main.map.repaint();
     93                        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     94                                RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     95                                RoutingModel routingModel = layer.getRoutingModel();
     96                                        if (e.getStateChange()==ItemEvent.SELECTED) {
     97                                                routingModel.routingGraph.setTypeRoute(RouteType.SHORTEST);
     98                                        } else {
     99                                                routingModel.routingGraph.setTypeRoute(RouteType.FASTEST);
     100                                        }
     101                                        routingModel.routingGraph.resetGraph();
     102                                        routingModel.routingGraph.createGraph();
     103                                        //TODO: Change this way
     104                                        //FIXME: do not change node but recalculate routing.
     105                                        routingModel.setNodesChanged();
     106                                        Main.map.repaint();
     107                        }
    109108                        }
    110109
     
    122121                cbmi.addItemListener(new ItemListener() {
    123122                        public void itemStateChanged(ItemEvent e) {
    124                                 if (e.getStateChange()==ItemEvent.SELECTED)
    125                                         routingModel.routingGraph.getRoutingProfile().setOnewayUse(false);
    126                                 else
    127                                         routingModel.routingGraph.getRoutingProfile().setOnewayUse(true);
    128                                 routingModel.setNodesChanged();
    129                                 Main.map.repaint();
     123                        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     124                                RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     125                                RoutingModel routingModel = layer.getRoutingModel();
     126                                        if (e.getStateChange()==ItemEvent.SELECTED)
     127                                                routingModel.routingGraph.getRoutingProfile().setOnewayUse(false);
     128                                        else
     129                                                routingModel.routingGraph.getRoutingProfile().setOnewayUse(true);
     130                                        routingModel.setNodesChanged();
     131                                        Main.map.repaint();
     132                        }
    130133                        }
    131134                });
     
    137140                reverseMI.addActionListener(new ActionListener() {
    138141                        public void actionPerformed(ActionEvent e) {
    139                                 routingModel.reverseNodes();
    140                                 Main.map.repaint();
     142                        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     143                                RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     144                                RoutingModel routingModel = layer.getRoutingModel();
     145                                        routingModel.reverseNodes();
     146                                        Main.map.repaint();
     147                        }
    141148                        }
    142149                });
     
    146153                clearMI.addActionListener(new ActionListener() {
    147154                        public void actionPerformed(ActionEvent e) {
    148                                 // Reset routing nodes and paths
    149                                 routingModel.reset();
    150                                 RoutingPlugin.getInstance().getRoutingDialog().clearNodes();
    151                                 Main.map.repaint();
     155                        if (Main.map.mapView.getActiveLayer() instanceof RoutingLayer) {
     156                                RoutingLayer layer = (RoutingLayer)Main.map.mapView.getActiveLayer();
     157                                RoutingModel routingModel = layer.getRoutingModel();
     158                                        // Reset routing nodes and paths
     159                                        routingModel.reset();
     160                                        RoutingPlugin.getInstance().getRoutingDialog().clearNodes();
     161                                        Main.map.repaint();
     162                        }
    152163                        }
    153164                });
Note: See TracChangeset for help on using the changeset viewer.