Ignore:
Timestamp:
2023-10-19T21:58:56+02:00 (16 months ago)
Author:
taylor.smock
Message:

Fix error_prone version issue and dependency updates (see #23218)

Plugins with an ivy_settings.xml file were not reading the error_prone version
from the core ivysettings.xml file. This removes redundant ivy_settings.xml files
and includes the core ivysettings.xml file in the remaining ivy_settings.xml
files.

Dependency updates:
apache-commons:

  • zstd-jni: 1.5.2-5 -> 1.5.5-6
  • commons-compress: 1.22 -> 1.24.0
  • commons-io: 2.11.0 -> 2.14.0
  • commons-lang3: 3.12.0 -> 3.13.0

apache-http:

  • httpclient5: 5.1.2 -> 5.2.1
  • Drops legacy httpcore, httpclient, and httpmime dependencies

ejml: 0.41 -> 0.43.1

  • ejml now requires Java 11

flatlaf: 3.2 -> 3.2.2
geotools: 28.2 -> 30.0

  • geotools now requires Java 11
  • 30.0 had some breaking API changes, but provided a migration script

jackson: 2.14.0 -> 2.15.3
jna: 5.12.1 -> 5.13.0
log4j: 2.19.0 -> 2.21.0
lwjgl: 3.3.1 -> 3.3.3
pbf:

  • protobuf-java: 3.20.3 -> 3.24.4
Location:
applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/GeoFabrikWFSClient.java

    r35123 r36176  
    88import javax.swing.ProgressMonitor;
    99
    10 import org.geotools.data.DataStore;
    11 import org.geotools.data.DataStoreFinder;
    12 import org.geotools.data.FeatureSource;
     10import org.geotools.api.data.DataStore;
     11import org.geotools.api.data.DataStoreFinder;
     12import org.geotools.api.data.FeatureSource;
    1313import org.geotools.factory.CommonFactoryFinder;
    1414import org.geotools.feature.FeatureCollection;
    1515import org.geotools.geometry.jts.ReferencedEnvelope;
    1616import org.geotools.referencing.CRS;
    17 import org.opengis.feature.simple.SimpleFeature;
    18 import org.opengis.feature.simple.SimpleFeatureType;
    19 import org.opengis.feature.type.AttributeDescriptor;
    20 import org.opengis.filter.Filter;
    21 import org.opengis.filter.FilterFactory2;
    22 import org.opengis.referencing.FactoryException;
    23 import org.opengis.referencing.NoSuchAuthorityCodeException;
    24 import org.opengis.referencing.crs.CoordinateReferenceSystem;
     17import org.geotools.api.feature.simple.SimpleFeature;
     18import org.geotools.api.feature.simple.SimpleFeatureType;
     19import org.geotools.api.feature.type.AttributeDescriptor;
     20import org.geotools.api.filter.Filter;
     21import org.geotools.api.filter.FilterFactory;
     22import org.geotools.api.referencing.FactoryException;
     23import org.geotools.api.referencing.NoSuchAuthorityCodeException;
     24import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
    2525import org.openstreetmap.josm.data.Bounds;
    2626import org.openstreetmap.josm.data.coor.LatLon;
    … …  
    3030public class GeoFabrikWFSClient {
    3131
    32         //private Bounds bbox;
    33         private DataStore data;
    34         private boolean bInitialized = false;
     32    //private Bounds bbox;
     33    private DataStore data;
     34    private boolean bInitialized;
    3535
    36         public GeoFabrikWFSClient(Bounds bounds) {
    37                 //bbox = bounds;
    38         }
     36    public GeoFabrikWFSClient(Bounds bounds) {
     37        //bbox = bounds;
     38    }
    3939
    40         public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures(
    41                         String typeName, ProgressMonitor progressMonitor)
    42                         throws IOException, NoSuchAuthorityCodeException, FactoryException {
     40    public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures(
     41            String typeName, ProgressMonitor progressMonitor)
     42            throws IOException, NoSuchAuthorityCodeException, FactoryException {
    4343
    44                 initializeDataStore();
     44        initializeDataStore();
    4545
    46                 // Step 3 - discovery; enhance to iterate over all types with bounds
    47                 SimpleFeatureType schema = data.getSchema(typeName);
    48                 progressMonitor.setProgress(30);
    49                
    50                 // Step 4 - target
    51                 FeatureSource<SimpleFeatureType, SimpleFeature> source = data
    52                                 .getFeatureSource(typeName);
    53                 Logging.info("Source Metadata Bounds:" + source.getBounds());
    54                 Logging.info("Source schema: " + source.getSchema());
     46        // Step 3 - discovery; enhance to iterate over all types with bounds
     47        SimpleFeatureType schema = data.getSchema(typeName);
     48        progressMonitor.setProgress(30);
    5549
    56                 progressMonitor.setProgress(40);
    57                
    58                 // Step 5 - query
    59                 List<AttributeDescriptor> listAttrs = schema.getAttributeDescriptors();
    60                 String geomName = listAttrs.get(0).getLocalName();
    61                 CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:4236");
     50        // Step 4 - target
     51        FeatureSource<SimpleFeatureType, SimpleFeature> source = data
     52                .getFeatureSource(typeName);
     53        Logging.info("Source Metadata Bounds:" + source.getBounds());
     54        Logging.info("Source schema: " + source.getSchema());
    6255
    63                 Bounds bounds = MainApplication.getMap().mapView.getLatLonBounds(
    64                         MainApplication.getMap().mapView.getBounds());
     56        progressMonitor.setProgress(40);
    6557
    66                 LatLon minLL = bounds.getMin();
    67                 LatLon maxLL = bounds.getMax();
    68                 double minLat = Math.min(minLL.getY(), maxLL.getY());
    69                 double maxLat = Math.max(minLL.getY(), maxLL.getY());
    70                 double minLon = Math.min(minLL.getX(), maxLL.getX());
    71                 double maxLon = Math.max(minLL.getX(), maxLL.getX());
     58        // Step 5 - query
     59        List<AttributeDescriptor> listAttrs = schema.getAttributeDescriptors();
     60        String geomName = listAttrs.get(0).getLocalName();
     61        CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:4236");
    7262
    73                 ReferencedEnvelope bboxRef = new ReferencedEnvelope(minLon, maxLon,
    74                                 minLat, maxLat, targetCRS);
    75                 Logging.info("Reference Bounds:" + bboxRef);
     63        Bounds bounds = MainApplication.getMap().mapView.getLatLonBounds(
     64                MainApplication.getMap().mapView.getBounds());
    7665
    77                 progressMonitor.setProgress(50);
    78                 //
    79                 // Ask WFS service for typeName data constrained by bboxRef
    80                 //
    81                 FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    82                 Filter filterBB = ff.bbox(ff.property(geomName), bboxRef);
    83                 FeatureCollection<SimpleFeatureType, SimpleFeature> features = source
    84                                 .getFeatures(filterBB);
     66        LatLon minLL = bounds.getMin();
     67        LatLon maxLL = bounds.getMax();
     68        double minLat = Math.min(minLL.getY(), maxLL.getY());
     69        double maxLat = Math.max(minLL.getY(), maxLL.getY());
     70        double minLon = Math.min(minLL.getX(), maxLL.getX());
     71        double maxLon = Math.max(minLL.getX(), maxLL.getX());
    8572
    86                 progressMonitor.setProgress(80);
    87                 return features;
    88         }
     73        ReferencedEnvelope bboxRef = new ReferencedEnvelope(minLon, maxLon,
     74                minLat, maxLat, targetCRS);
     75        Logging.info("Reference Bounds:" + bboxRef);
    8976
    90         public void initializeDataStore() throws IOException {
    91                 if (bInitialized == true)
    92                         return;
     77        progressMonitor.setProgress(50);
     78        //
     79        // Ask WFS service for typeName data constrained by bboxRef
     80        //
     81        FilterFactory ff = CommonFactoryFinder.getFilterFactory();
     82        Filter filterBB = ff.bbox(ff.property(geomName), bboxRef);
     83        FeatureCollection<SimpleFeatureType, SimpleFeature> features = source
     84                .getFeatures(filterBB);
    9385
    94                 String getCapabilities = "http://tools.geofabrik.de/osmi/view/routing_non_eu/wxs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetCapabilities";
    95                 @SuppressWarnings("rawtypes")
    96                 Map<String, Comparable> connectionParameters = new HashMap<>();
    97                 connectionParameters.put("WFSDataStoreFactory:GET_CAPABILITIES_URL",
    98                                 getCapabilities);
    99                 connectionParameters.put("WFSDataStoreFactory:WFS_STRATEGY",
    100                                 "mapserver");
    101                 connectionParameters.put("WFSDataStoreFactory:LENIENT", true);
    102                 connectionParameters.put("WFSDataStoreFactory:TIMEOUT", 20000);
    103                 connectionParameters.put("WFSDataStoreFactory:BUFFER_SIZE", 10000);
    104                 // Step 2 - connection
    105                 data = DataStoreFinder.getDataStore(connectionParameters);
     86        progressMonitor.setProgress(80);
     87        return features;
     88    }
    10689
    107                 bInitialized = true;
    108         }
     90    public void initializeDataStore() throws IOException {
     91        if (bInitialized)
     92            return;
    10993
    110         public String[] getTypeNames() throws IOException {
    111                 return data.getTypeNames();
    112         }
     94        String getCapabilities = "http://tools.geofabrik.de/osmi/view/routing_non_eu/wxs?SERVICE=WFS&VERSION=1.0.0&REQUEST=GetCapabilities";
     95        @SuppressWarnings("rawtypes")
     96        Map<String, Comparable> connectionParameters = new HashMap<>();
     97        connectionParameters.put("WFSDataStoreFactory:GET_CAPABILITIES_URL",
     98                getCapabilities);
     99        connectionParameters.put("WFSDataStoreFactory:WFS_STRATEGY",
     100                "mapserver");
     101        connectionParameters.put("WFSDataStoreFactory:LENIENT", true);
     102        connectionParameters.put("WFSDataStoreFactory:TIMEOUT", 20000);
     103        connectionParameters.put("WFSDataStoreFactory:BUFFER_SIZE", 10000);
     104        // Step 2 - connection
     105        data = DataStoreFinder.getDataStore(connectionParameters);
    113106
    114         public DataStore getData() {
    115                 return data;
    116         }
     107        bInitialized = true;
     108    }
    117109
    118         public void setData(DataStore data) {
    119                 this.data = data;
    120         }
     110    public String[] getTypeNames() throws IOException {
     111        return data.getTypeNames();
     112    }
     113
     114    public DataStore getData() {
     115        return data;
     116    }
     117
     118    public void setData(DataStore data) {
     119        this.data = data;
     120    }
    121121}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/ImportOsmInspectorBugsAction.java

    r35123 r36176  
    1111import javax.swing.ProgressMonitor;
    1212
    13 import org.opengis.referencing.FactoryException;
     13import org.geotools.api.referencing.FactoryException;
    1414import org.openstreetmap.josm.actions.JosmAction;
    1515import org.openstreetmap.josm.data.Bounds;
    … …  
    2222
    2323public class ImportOsmInspectorBugsAction extends JosmAction {
    24         OsmInspectorPlugin plugin;
    25         /**
    26          *
    27         */
    28         private static final long serialVersionUID = -6484182416189079287L;
     24    OsmInspectorPlugin plugin;
     25    /**
     26     *
     27    */
     28    private static final long serialVersionUID = -6484182416189079287L;
    2929
    30         public ImportOsmInspectorBugsAction(OsmInspectorPlugin thePlugin) {
    31                 super(tr("Import Osm Inspector Bugs..."), "importosmibugs",
    32                                 tr("Import Osm Inspector Bugs..."), Shortcut.registerShortcut("importosmibugs",
    33                                                 tr("Edit: {0}", tr("Import Osm Inspector Bugs...")),
    34                                                 KeyEvent.VK_O, Shortcut.ALT_CTRL), true);
    35                 putValue("help", ht("/Action/ImportOsmInspectorBugs"));
    36                 plugin = thePlugin;
    37         }
     30    public ImportOsmInspectorBugsAction(OsmInspectorPlugin thePlugin) {
     31        super(tr("Import Osm Inspector Bugs..."), "importosmibugs",
     32                tr("Import Osm Inspector Bugs..."), Shortcut.registerShortcut("importosmibugs",
     33                        tr("Edit: {0}", tr("Import Osm Inspector Bugs...")),
     34                        KeyEvent.VK_O, Shortcut.ALT_CTRL), true);
     35        putValue("help", ht("/Action/ImportOsmInspectorBugs"));
     36        plugin = thePlugin;
     37    }
    3838
    39         @Override
    40         public void actionPerformed(ActionEvent event) {
    41                 if (isEnabled()) {
    42                     MapView mapView = MainApplication.getMap().mapView;
    43                         ProgressMonitor monitor = new ProgressMonitor(mapView,
    44                                         "Querying WFS Geofabrik", "Dowloading features", 0, 100);
     39    @Override
     40    public void actionPerformed(ActionEvent event) {
     41        if (isEnabled()) {
     42            MapView mapView = MainApplication.getMap().mapView;
     43            ProgressMonitor monitor = new ProgressMonitor(mapView,
     44                    "Querying WFS Geofabrik", "Dowloading features", 0, 100);
    4545
    46                         try {
    47                                 Bounds bounds = mapView.getLatLonBounds(mapView.getBounds());
     46            try {
     47                Bounds bounds = mapView.getLatLonBounds(mapView.getBounds());
    4848
    49                                 Logging.info("OSMI View bounds" + bounds);
     49                Logging.info("OSMI View bounds" + bounds);
    5050
    51                                 monitor.setProgress(10);
     51                monitor.setProgress(10);
    5252
    53                                 OsmInspectorLayer inspector = plugin.getLayer();
    54                                 if (inspector == null) {
    55                                         GeoFabrikWFSClient wfs = new GeoFabrikWFSClient(bounds);
    56                                         wfs.initializeDataStore();
    57                                         inspector = new OsmInspectorLayer(wfs, monitor);
    58                                         MainApplication.getLayerManager().addLayer(inspector);
    59                                         plugin.setLayer(inspector);
    60                                 } else {
    61                                         GeoFabrikWFSClient wfs = new GeoFabrikWFSClient(bounds);
    62                                         wfs.initializeDataStore();
    63                                         inspector.loadFeatures(wfs);
     53                OsmInspectorLayer inspector = plugin.getLayer();
     54                GeoFabrikWFSClient wfs = new GeoFabrikWFSClient(bounds);
     55                wfs.initializeDataStore();
     56                if (inspector == null) {
     57                    inspector = new OsmInspectorLayer(wfs, monitor);
     58                    MainApplication.getLayerManager().addLayer(inspector);
     59                    plugin.setLayer(inspector);
     60                } else {
     61                    inspector.loadFeatures(wfs);
    6462
    65                                 }
    66                         } catch (IOException | IndexOutOfBoundsException | NoSuchElementException | FactoryException | ParseException e) {
    67                                 Logging.error(e);
    68                         } finally {
    69                                 monitor.close();
    70                                 if (plugin.getLayer() != null) {
    71                                         plugin.getLayer().updateView();
    72                                 }
    73                         }
    74                 } else {
    75                     Logging.warn("Osm Inspector Action not enabled");
    76                 }
    77         }
     63                }
     64            } catch (IOException | IndexOutOfBoundsException | NoSuchElementException | FactoryException | ParseException e) {
     65                Logging.error(e);
     66            } finally {
     67                monitor.close();
     68                if (plugin.getLayer() != null) {
     69                    plugin.getLayer().updateView();
     70                }
     71            }
     72        } else {
     73            Logging.warn("Osm Inspector Action not enabled");
     74        }
     75    }
    7876
    7977}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/OSMIFeatureTracker.java

    r30828 r36176  
    22
    33import java.util.HashMap;
    4 import java.util.Iterator;
     4import java.util.Map;
    55
     6import org.geotools.api.feature.simple.SimpleFeature;
     7import org.geotools.api.feature.simple.SimpleFeatureType;
    68import org.geotools.data.memory.MemoryFeatureCollection;
    79import org.geotools.feature.FeatureCollection;
    810import org.geotools.feature.FeatureIterator;
    9 import org.opengis.feature.simple.SimpleFeature;
    10 import org.opengis.feature.simple.SimpleFeatureType;
     11import org.openstreetmap.josm.tools.Logging;
    1112
    1213public class OSMIFeatureTracker {
    1314
    14         private HashMap<Long, SimpleFeature> hashFeatures;
    15         private MemoryFeatureCollection features;
     15    private final Map<Long, SimpleFeature> hashFeatures;
     16    private final MemoryFeatureCollection features;
    1617
    17         public OSMIFeatureTracker(
    18                         FeatureCollection<SimpleFeatureType, SimpleFeature> featuresIn) {
    19                 hashFeatures = new HashMap<>();
    20                 features = new MemoryFeatureCollection(featuresIn.getSchema());
     18    public OSMIFeatureTracker(
     19            FeatureCollection<SimpleFeatureType, SimpleFeature> featuresIn) {
     20        hashFeatures = new HashMap<>();
     21        features = new MemoryFeatureCollection(featuresIn.getSchema());
    2122
    22                 for (Iterator<?> it = features.iterator(); it.hasNext();) {
    23                         SimpleFeature element = (SimpleFeature) it.next();
    24                         try {
    25                                 Long ID = (Long.parseLong((String) element
    26                                                 .getAttribute("problem_id")));
     23        for (SimpleFeature element : features) {
     24            try {
     25                Long id = (Long.parseLong((String) element
     26                        .getAttribute("problem_id")));
    2727
    28                                 if (!hashFeatures.containsKey(ID)) {
    29                                         hashFeatures.put(ID, element);
    30                                         features.add(element);
    31                                 }
    32                         } catch (NumberFormatException e) {
    33                                 continue;
    34                         }
    35                 }
     28                if (!hashFeatures.containsKey(id)) {
     29                    hashFeatures.put(id, element);
     30                    features.add(element);
     31                }
     32            } catch (NumberFormatException e) {
     33                Logging.trace(e);
     34            }
     35        }
    3636
    37                 try (FeatureIterator<SimpleFeature> it = featuresIn.features()) {
    38                     while (it.hasNext()) {
    39                         features.add(it.next());
    40                     }
    41                 }
    42         }
     37        try (FeatureIterator<SimpleFeature> it = featuresIn.features()) {
     38            while (it.hasNext()) {
     39                features.add(it.next());
     40            }
     41        }
     42    }
    4343
    44         public boolean mergeFeatures(
    45                         FeatureCollection<SimpleFeatureType, SimpleFeature> newFeatures) {
    46             try (FeatureIterator<SimpleFeature> it = newFeatures.features()) {
    47                 while (it.hasNext()) {
    48                         SimpleFeature element = (SimpleFeature) it.next();
    49                         try {
    50                                 Long ID = (Long.parseLong((String) element
    51                                                 .getAttribute("problem_id")));
     44    public boolean mergeFeatures(
     45            FeatureCollection<SimpleFeatureType, SimpleFeature> newFeatures) {
     46        try (FeatureIterator<SimpleFeature> it = newFeatures.features()) {
     47            while (it.hasNext()) {
     48                SimpleFeature element = it.next();
     49                try {
     50                    Long id = (Long.parseLong((String) element
     51                            .getAttribute("problem_id")));
    5252   
    53                                 if (!hashFeatures.containsKey(ID)) {
    54                                         hashFeatures.put(ID, element);
    55                                         features.add(element);
    56                                 }
    57                         } catch (NumberFormatException e) {
    58                                 continue;
    59                         }
    60                 }
    61             }
     53                    if (!hashFeatures.containsKey(id)) {
     54                        hashFeatures.put(id, element);
     55                        features.add(element);
     56                    }
     57                } catch (NumberFormatException e) {
     58                    Logging.trace(e);
     59                }
     60            }
     61        }
    6262
    63                 return true;
    64         }
     63        return true;
     64    }
    6565
    66         public HashMap<Long, SimpleFeature> getFeatureHash() {
    67                 return hashFeatures;
    68         }
     66    public Map<Long, SimpleFeature> getFeatureHash() {
     67        return hashFeatures;
     68    }
    6969
    70         public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures() {
    71                 return features;
    72         }
     70    public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures() {
     71        return features;
     72    }
    7373}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/OsmInspectorLayer.java

    r35123 r36176  
    99import java.util.HashMap;
    1010import java.util.HashSet;
    11 import java.util.Iterator;
    1211import java.util.LinkedHashMap;
     12import java.util.List;
    1313import java.util.Map;
    1414import java.util.Map.Entry;
    … …  
    2020import javax.swing.ProgressMonitor;
    2121
     22import org.geotools.api.data.SimpleFeatureSource;
     23import org.geotools.api.feature.Property;
     24import org.geotools.api.feature.simple.SimpleFeature;
     25import org.geotools.api.feature.simple.SimpleFeatureType;
     26import org.geotools.api.feature.type.Name;
     27import org.geotools.api.filter.FilterFactory;
     28import org.geotools.api.filter.identity.FeatureId;
     29import org.geotools.api.filter.spatial.Intersects;
     30import org.geotools.api.referencing.FactoryException;
     31import org.geotools.api.referencing.NoSuchAuthorityCodeException;
     32import org.geotools.api.referencing.crs.CoordinateReferenceSystem;
     33import org.geotools.api.style.FeatureTypeStyle;
     34import org.geotools.api.style.Fill;
     35import org.geotools.api.style.Graphic;
     36import org.geotools.api.style.Mark;
     37import org.geotools.api.style.Rule;
     38import org.geotools.api.style.Stroke;
     39import org.geotools.api.style.Style;
     40import org.geotools.api.style.StyleFactory;
     41import org.geotools.api.style.Symbolizer;
    2242import org.geotools.data.DataUtilities;
    23 import org.geotools.data.simple.SimpleFeatureSource;
    2443import org.geotools.factory.CommonFactoryFinder;
    2544import org.geotools.feature.FeatureCollection;
    … …  
    3049import org.geotools.referencing.CRS;
    3150import org.geotools.renderer.lite.StreamingRenderer;
    32 import org.geotools.styling.FeatureTypeStyle;
    33 import org.geotools.styling.Fill;
    34 import org.geotools.styling.Graphic;
    35 import org.geotools.styling.Mark;
    36 import org.geotools.styling.Rule;
    37 import org.geotools.styling.Stroke;
    38 import org.geotools.styling.Style;
    39 import org.geotools.styling.StyleFactory;
    40 import org.geotools.styling.Symbolizer;
    41 import org.opengis.feature.Property;
    42 import org.opengis.feature.simple.SimpleFeature;
    43 import org.opengis.feature.simple.SimpleFeatureType;
    44 import org.opengis.feature.type.Name;
    45 import org.opengis.filter.FilterFactory2;
    46 import org.opengis.filter.identity.FeatureId;
    47 import org.opengis.filter.spatial.Intersects;
    48 import org.opengis.referencing.FactoryException;
    49 import org.opengis.referencing.NoSuchAuthorityCodeException;
    50 import org.opengis.referencing.crs.CoordinateReferenceSystem;
     51import org.locationtech.jts.geom.Envelope;
     52import org.locationtech.jts.geom.Geometry;
     53import org.locationtech.jts.io.ParseException;
    5154import org.openstreetmap.josm.data.Bounds;
    5255import org.openstreetmap.josm.data.coor.LatLon;
    … …  
    6063import org.openstreetmap.josm.tools.Logging;
    6164
    62 import org.locationtech.jts.geom.Envelope;
    63 import org.locationtech.jts.geom.Geometry;
    64 import org.locationtech.jts.io.ParseException;
    65 
    6665public class OsmInspectorLayer extends Layer {
    6766
    68         private StyleFactory sf = CommonFactoryFinder.getStyleFactory(null);
    69         private FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(null);
    70         private StreamingRenderer renderer;
    71         private CoordinateReferenceSystem crsOSMI;
    72         private GeomType geometryType;
    73         private String geometryAttributeName;
    74 
    75         private SimpleFeatureSource featureSource;
    76         private MapContent content;
    77         private boolean bIsChanged;
    78 
    79         private int layerOffset = 1;
    80 
    81         private ArrayList<GeomType> selectGeomType;
    82         private Color[] featureFills = { new Color(255, 0, 0),
    83                         new Color(0, 0, 255), // duplicate ways
    84                         new Color(204, 204, 0), // minor 5
    85                         new Color(255, 230, 128), // minor 2
    86                         new Color(255, 204, 0), // minor 1
    87                         new Color(255, 102, 102), // major 5
    88                         new Color(255, 148, 77), // major 2
    89                         new Color(255, 0, 0), // major 1
    90                         new Color(255, 255, 64), // selected
    91                         new Color(255, 0, 0), new Color(255, 0, 0) };
    92 
    93         /**
    94          * dialog showing the bug info
    95          */
    96         private OsmInspectorDialog dialog;
    97 
    98         /**
    99          * supported actions
    100          */
    101 
    102         // Container for bugs from Osmi
    103         private ArrayList<OSMIFeatureTracker> arrFeatures;
    104         private LinkedHashMap<BugInfo, Long> osmiBugInfo;
    105 
    106         public Geometry getOsmBugGeometry(int index) {
    107                 BugInfo[] array = new BugInfo[osmiBugInfo.keySet().size()];
    108                 array = osmiBugInfo.keySet().toArray(array);
    109                 return array[index].getGeom();
    110         }
    111 
    112         public Map<BugInfo, Long> getOsmiBugInfo() {
    113                 return osmiBugInfo;
    114         }
    115 
    116         public SimpleFeatureSource getFeatureSource() {
    117                 return featureSource;
    118         }
    119 
    120         public void setFeatureSource(SimpleFeatureSource featureSource) {
    121                 this.featureSource = featureSource;
    122         }
    123 
    124         public boolean isbIsChanged() {
    125                 return bIsChanged;
    126         }
    127 
    128         public void setbIsChanged(boolean bIsChanged) {
    129                 this.bIsChanged = bIsChanged;
    130         }
    131 
    132         public ArrayList<OSMIFeatureTracker> getArrFeatures() {
    133                 return arrFeatures;
    134         }
    135 
    136         public void setArrFeatures(ArrayList<OSMIFeatureTracker> arrFeatures) {
    137                 this.arrFeatures = arrFeatures;
    138         }
    139 
    140         public BugIndex getOsmiIndex() {
    141                 return osmiIndex;
    142         }
    143 
    144         // Pointer to prev and next osmi bugs
    145         private BugIndex osmiIndex;
    146 
    147         /**
    148          *
    149          * The Bug attribute class: hold geom, id and description for that bug
    150          *
    151          * @author snikhil
    152          *
    153          */
    154         public static class BugInfo implements Comparable<BugInfo>{
    155 
    156                 public Geometry getGeom() {
    157                         return geom;
    158                 }
    159 
    160                 public String getDesc() {
    161                         return desc;
    162                 }
    163 
    164                 public String getId() {
    165                         return id;
    166                 }
    167 
    168                 @Override
    169                 public int hashCode() {
    170                         String fid = attributes.get("FID");
    171                         String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
    172                         return hash.hashCode();
    173                 }
    174 
    175                 @Override
    176                 public boolean equals(Object obj) {
    177                         String fid = attributes.get("FID");
    178                         String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
    179                        
    180                        
    181                         if (obj instanceof BugInfo) {
    182                                 BugInfo b = (BugInfo) obj;
    183                                
    184                                 String bfid = b.attributes.get("FID");
    185                                 String bhash =  (bfid == null || bfid.isEmpty()) ? b.attributes.get("problem_id") : bfid;
    186                                 return hash.equals(bhash);
    187                         }
    188                         return false;
    189                 }
    190 
    191                 // private final long bugId; //incremental bugId
    192                 private final long bugId;
    193                 private final Geometry geom;
    194                 private final String desc;
    195                 private final String id;
    196                 private final Name name;
    197                 private final Map<String, String> attributes;
    198 
    199                 public BugInfo(SimpleFeature next, long idx)
    200                                 throws IndexOutOfBoundsException, ParseException {
    201 
    202                         bugId = idx;
    203                         attributes = new HashMap<>();
    204                         Collection<Property> properties = next.getProperties();
    205                         Iterator<Property> it = properties.iterator();
    206                         while (it.hasNext()) {
    207                                 Property p = it.next();
    208                                 attributes.put(p.getName().toString(), p.getValue().toString());
    209                         }
    210                         this.geom = (Geometry) next.getAttribute(0);
    211                         this.desc = (String) next.getAttribute("error_desc");
    212                         this.id = next.getID();
    213                         name = next.getName();
    214                 }
    215 
    216                 @Override
    217                 public String toString() {
    218                         StringBuilder sb = new StringBuilder();
    219                         sb.append("BugId_").append(String.valueOf(bugId)).append("\n");
    220                         return sb.toString();
    221                 }
    222 
    223                 public String getContentString() {
    224                         StringBuilder sb = new StringBuilder();
    225                         sb.append("Layer:").append(name.getLocalPart()).append("\n");
    226                         Iterator<Entry<String, String>> it = attributes.entrySet()
    227                                         .iterator();
    228                         while (it.hasNext()) {
    229                                 Entry<String, String> next = it.next();
    230                                 sb.append(next.getKey()).append(":").append(next.getValue())
    231                                                 .append("\n");
    232                         }
    233                         return sb.toString();
    234                 }
    235 
    236                 public long getBugId() {
    237                         return bugId;
    238                 }
    239 
    240                 @Override
    241                 public int compareTo(BugInfo o) {
    242                         String fid = attributes.get("FID");
    243                         String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
    244                        
    245                         String ofid = o.attributes.get("FID");
    246                         String ohash =  (ofid == null || ofid.isEmpty()) ? o.attributes.get("problem_id") : ofid;
    247                         return hash.compareTo(ohash);
    248                 }
    249         }
    250 
    251         /**
    252          * Helper class that stores the bug next and prev pointers and can navigate
    253          * the entire bug list
    254          *
    255          * @author snikhil
    256          *
    257          */
    258         public static class BugIndex {
    259                 private int nextIndex;
    260                 private int previousIndex;
    261                 private ArrayList<BugInfo> osmBugs;
    262 
    263                 public BugIndex(Map<BugInfo, Long> bugs) {
    264                         osmBugs = new ArrayList<>(bugs.keySet());
    265                         nextIndex = 0;
    266                         previousIndex = -1;
    267                 }
    268 
    269                 public BugIndex(Map<BugInfo, Long> bugs, int n, int p) {
    270                         osmBugs = new ArrayList<>(bugs.keySet());
    271                         nextIndex = n;
    272                         previousIndex = p;
    273                 }
    274 
    275                 public void next() {
    276                         previousIndex = nextIndex;
    277                         nextIndex = ++nextIndex % osmBugs.size();
    278                 }
    279 
    280                 public void prev() {
    281                         nextIndex = previousIndex;
    282                         previousIndex = previousIndex - 1 < 0 ? osmBugs.size() - 1
    283                                         : --previousIndex;
    284                 }
    285 
    286                 public BugInfo getItemPointedByNext() {
    287                         return osmBugs.get(nextIndex);
    288                 }
    289 
    290                 public BugInfo getItemPointedByPrev() {
    291                         return osmBugs.get(nextIndex);
    292                 }
    293 
    294                 public int indexOf(BugInfo b) {
    295                         return osmBugs.indexOf(b);
    296                 }
    297 
    298                 public BugInfo getNext() {
    299                         next();
    300                         return osmBugs.get(nextIndex);
    301                 }
    302 
    303                 public BugInfo getPrev() {
    304                         prev();
    305                         return osmBugs.get(nextIndex);
    306                 }
    307 
    308                 public ArrayList<BugInfo> getBugs() {
    309                         return osmBugs;
    310                 }
    311 
    312                 public void append(LinkedHashMap<BugInfo, Long> osmiBugInfo) {
    313                         Iterator<BugInfo> it = osmiBugInfo.keySet().iterator();
    314                         while(it.hasNext()){
    315                                 BugInfo next = it.next();
    316                                 if(!osmBugs.contains(next)){
    317                                         this.osmBugs.add(next);
    318                                 }
    319                         }
    320                 }
    321         }
    322 
    323         private enum GeomType {
    324                 POINT, LINE, POLYGON
    325         }
    326 
    327         private static final Color SELECTED_COLOUR = Color.ORANGE;
    328         private static final float SELECTED_POINT_SIZE = 15.0f;
    329         private static final float OPACITY = 1.0f;
    330         private static final float LINE_WIDTH = 1.0f;
    331         private static final float POINT_SIZE = 10.0f;
    332 
    333         public OsmInspectorLayer(GeoFabrikWFSClient wfsClient,
    334                         ProgressMonitor monitor) throws NoSuchAuthorityCodeException,
    335                         FactoryException, IOException, IndexOutOfBoundsException,
    336                         ParseException {
    337                 super("OsmInspector");
    338 
    339                 arrFeatures = new ArrayList<>();
    340                 osmiBugInfo = new LinkedHashMap<>();
    341                 selectGeomType = new ArrayList<>();
    342 
    343                 // Step 3 - discovery; enhance to iterate over all types with bounds
    344 
    345                 String typeNames[] = wfsClient.getTypeNames();
    346                 renderer = new StreamingRenderer();
    347                 CRS.decode(ProjectionRegistry.getProjection().toCode());
    348                 crsOSMI = CRS.decode("EPSG:4326");
    349                 content = new MapContent();
    350                 content.getViewport().setCoordinateReferenceSystem(crsOSMI);
    351 
    352                 selectGeomType.add(GeomType.POINT);
    353                 for (int idx = 1; idx < typeNames.length; ++idx) {
    354                         String typeName = typeNames[idx];
    355                         Set<FeatureId> selectedFeatures = new HashSet<>();
    356 
    357                         FeatureCollection<SimpleFeatureType, SimpleFeature> features = wfsClient
    358                                         .getFeatures(typeName, monitor);
    359                         setGeometry(selectGeomType, typeName);
    360 
    361                         Logging.info("Osm Inspector Features size: " + features.size());
    362                         Style style = createDefaultStyle(idx, selectedFeatures);
    363 
    364                         OSMIFeatureTracker tracker = new OSMIFeatureTracker(features);
    365                         arrFeatures.add(tracker);
    366                         FeatureIterator<SimpleFeature> it = tracker.getFeatures().features();
    367 
    368                         while (it.hasNext()) {
    369                                 BugInfo theInfo = new BugInfo(it.next(), osmiBugInfo.size());
    370                                 osmiBugInfo.put(theInfo, theInfo.bugId);
    371                         }
    372 
    373                         content.addLayer(new FeatureLayer(tracker.getFeatures(), style));
    374                 }
    375 
    376                 osmiIndex = new BugIndex(osmiBugInfo);
    377                 content.setTitle("Osm Inspector Errors");
    378                 renderer.setMapContent(content);
    379                 bIsChanged = true;
    380 
    381                 // finally initialize the dialog
    382                 dialog = new OsmInspectorDialog(this);
    383                 this.updateView();
    384         }
    385 
    386         public void loadFeatures(GeoFabrikWFSClient wfsClient)
    387                         throws NoSuchAuthorityCodeException, FactoryException, IOException,
    388                         IndexOutOfBoundsException, NoSuchElementException, ParseException {
    389                 String typeNames[] = wfsClient.getTypeNames();
    390 
    391                 content.layers().clear();
    392                 selectGeomType.clear();
    393                 selectGeomType.add(GeomType.POINT);
    394 
    395                 ProgressMonitor monitor = new ProgressMonitor(MainApplication.getMap().mapView,
    396                                 "Loading features", "", 0, 100);
    397 
    398                 for (int idx = 1; idx < typeNames.length; ++idx) {
    399                         String typeName = typeNames[idx];
    400                         Set<FeatureId> selectedFeatures = new HashSet<>();
    401 
    402                         monitor.setProgress(100 / typeNames.length * idx);
    403                         FeatureCollection<SimpleFeatureType, SimpleFeature> features = wfsClient
    404                                         .getFeatures(typeName, monitor);
    405                         setGeometry(selectGeomType, typeName);
    406 
    407                         Logging.info("Osm Inspector Features size: " + features.size());
    408 
    409                         OSMIFeatureTracker tracker = arrFeatures.get(idx - layerOffset);
    410                         tracker.mergeFeatures(features);
    411 
    412                         FeatureIterator<SimpleFeature> it = tracker.getFeatures().features();
    413 
    414                         while (it.hasNext()) {
    415                                 BugInfo theInfo = new BugInfo(it.next(), osmiBugInfo.size());
    416                                 if (!osmiBugInfo.keySet().contains(theInfo)) {
    417                                         osmiBugInfo.put(theInfo, theInfo.bugId);
    418                                 }
    419                         }
    420 
    421                         Style style = createDefaultStyle(idx, selectedFeatures);
    422                         content.addLayer(new FeatureLayer(tracker.getFeatures(), style));
    423                 }
    424 
    425                 osmiIndex.append(osmiBugInfo);
    426                
    427                
    428                 monitor.setProgress(100);
    429                 monitor.close();
    430                 bIsChanged = true;
    431                 //dialog.updateDialog(this);
    432                 dialog.refreshModel();
    433                 //dialog.updateNextPrevAction(this);
    434                
    435                 this.updateView();
    436         }
    437 
    438         private Style createDefaultStyle(int idx, Set<FeatureId> IDs) {
    439                 Color fillColor = featureFills[idx];
    440 
    441                 Rule selectedRule = createRule(SELECTED_COLOUR, SELECTED_COLOUR, true);
    442                 selectedRule.setFilter(ff.id(IDs));
    443 
    444                 Rule rule = createRule(fillColor, fillColor, false);
    445                 rule.setElseFilter(true);
    446 
    447                 FeatureTypeStyle fts = sf.createFeatureTypeStyle();
    448                 fts.rules().add(selectedRule);
    449                 fts.rules().add(rule);
    450 
    451                 Style style = sf.createStyle();
    452                 style.featureTypeStyles().add(fts);
    453                 return style;
    454         }
    455 
    456         private Rule createRule(Color outlineColor, Color fillColor,
    457                         boolean bSelected) {
    458                 Symbolizer symbolizer = null;
    459                 Fill fill = null;
    460                 Stroke stroke = sf.createStroke(ff.literal(outlineColor),
    461                                 ff.literal(LINE_WIDTH));
    462 
    463                 switch (geometryType) {
    464                 case POLYGON:
    465                         fill = sf.createFill(ff.literal(fillColor), ff.literal(OPACITY));
    466                         symbolizer = sf.createPolygonSymbolizer(stroke, fill,
    467                                         geometryAttributeName);
    468                         break;
    469 
    470                 case LINE:
    471                         symbolizer = sf.createLineSymbolizer(stroke, geometryAttributeName);
    472                         break;
    473 
    474                 case POINT:
    475                         fill = sf.createFill(ff.literal(fillColor), ff.literal(OPACITY));
    476 
    477                         Mark mark = sf.getTriangleMark();
    478                         mark.setFill(fill);
    479                         mark.setStroke(stroke);
    480 
    481                         Graphic graphic = sf.createDefaultGraphic();
    482                         graphic.graphicalSymbols().clear();
    483                         graphic.graphicalSymbols().add(mark);
    484                         graphic.setSize(ff.literal(bSelected ? SELECTED_POINT_SIZE
    485                                         : POINT_SIZE));
    486 
    487                         symbolizer = sf.createPointSymbolizer(graphic,
    488                                         geometryAttributeName);
    489                 }
    490 
    491                 Rule rule = sf.createRule();
    492                 rule.symbolizers().add(symbolizer);
    493                 return rule;
    494         }
    495 
    496         private void setGeometry(ArrayList<GeomType> selectedTypes, String typename) {
    497             Logging.info("Passed type is" + typename);
    498                 if (typename.compareTo("duplicate_ways") == 0) {
    499                         geometryType = GeomType.LINE;
    500                 } else
    501                         geometryType = GeomType.POINT;
    502 
    503                 selectedTypes.add(geometryType);
    504         }
    505 
    506         @Override
    507         public Icon getIcon() {
    508                 return ImageProvider.get("layer/osmdata_small");
    509         }
    510 
    511         @Override
    512         public Object getInfoComponent() {
    513                 return getToolTipText();
    514         }
    515 
    516         @Override
    517         public Action[] getMenuEntries() {
    518                 return new Action[] {};
    519         }
    520 
    521         @Override
    522         public String getToolTipText() {
    523                 return org.openstreetmap.josm.tools.I18n.tr("OsmInspector");
    524         }
    525 
    526         @Override
    527         public boolean isMergable(Layer other) {
    528                 return false;
    529         }
    530 
    531         @Override
    532         public void mergeFrom(Layer from) {
    533                 return;
    534         }
    535 
    536         @Override
    537         public void paint(Graphics2D g, MapView mv, Bounds box) {
    538                 LatLon min = box.getMin();
    539                 LatLon max = box.getMax();
    540 
    541                 Envelope envelope2 = new Envelope(Math.min(min.lat(), max.lat()),
    542                                 Math.max(min.lat(), max.lat()), Math.min(min.lon(), max.lon()),
    543                                 Math.max(min.lon(), max.lon()));
    544 
    545                 ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope2, crsOSMI);
    546 
    547                 renderer.setInteractive(false);
    548                 renderer.paint(g, mv.getBounds(), mapArea);
    549                 bIsChanged = false;
    550         }
    551 
    552         @Override
    553         public void visitBoundingBox(BoundingXYVisitor v) {
    554         }
    555 
    556         public boolean isChanged() {
    557                 return bIsChanged;
    558         }
    559 
    560         public void updateView() {
    561                 this.dialog.revalidate();
    562                 invalidate();
    563         }
    564 
    565         public void selectFeatures(int x, int y) {
    566                 int pixelDelta = 2;
    567                 LatLon clickUL = MainApplication.getMap().mapView.getLatLon(x - pixelDelta, y
    568                                 - pixelDelta);
    569                 LatLon clickLR = MainApplication.getMap().mapView.getLatLon(x + pixelDelta, y
    570                                 + pixelDelta);
    571 
    572                 Envelope envelope = new Envelope(
    573                                 Math.min(clickUL.lon(), clickLR.lon()), Math.max(clickUL.lon(),
    574                                                 clickLR.lon()), Math.min(clickUL.lat(), clickLR.lat()),
    575                                 Math.max(clickUL.lat(), clickLR.lat()));
    576 
    577                 ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope, crsOSMI);
    578 
    579                 Intersects filter = ff.intersects(ff.property("msGeometry"),
    580                                 ff.literal(mapArea));
    581                 //
    582                 // Select features in all layers
    583                 //
    584                 content.layers().clear();
    585 
    586                 // Iterate through features and build a list that intersects the above
    587                 // envelope
    588                 for (int idx = 0; idx < arrFeatures.size(); ++idx) {
    589                         OSMIFeatureTracker tracker = arrFeatures.get(idx);
    590                         FeatureCollection<SimpleFeatureType, SimpleFeature> features = tracker
    591                                         .getFeatures();
    592 
    593                         SimpleFeatureSource tempfs = DataUtilities.source(features);
    594                         FeatureCollection<SimpleFeatureType, SimpleFeature> selectedFeatures;
    595 
    596                         try {
    597                                 selectedFeatures = tempfs.getFeatures(filter);
     67    private final StyleFactory sf = CommonFactoryFinder.getStyleFactory(null);
     68    private final FilterFactory ff = CommonFactoryFinder.getFilterFactory(null);
     69    private final StreamingRenderer renderer;
     70    private final CoordinateReferenceSystem crsOSMI;
     71    private GeomType geometryType;
     72    private String geometryAttributeName;
     73
     74    private SimpleFeatureSource featureSource;
     75    private final MapContent content;
     76    private boolean bIsChanged;
     77
     78    private final int layerOffset = 1;
     79
     80    private final ArrayList<GeomType> selectGeomType;
     81    private final Color[] featureFills = { new Color(255, 0, 0),
     82            new Color(0, 0, 255), // duplicate ways
     83            new Color(204, 204, 0), // minor 5
     84            new Color(255, 230, 128), // minor 2
     85            new Color(255, 204, 0), // minor 1
     86            new Color(255, 102, 102), // major 5
     87            new Color(255, 148, 77), // major 2
     88            new Color(255, 0, 0), // major 1
     89            new Color(255, 255, 64), // selected
     90            new Color(255, 0, 0), new Color(255, 0, 0) };
     91
     92    /**
     93     * dialog showing the bug info
     94     */
     95    private final OsmInspectorDialog dialog;
     96
     97    /**
     98     * supported actions
     99     */
     100
     101    // Container for bugs from Osmi
     102    private List<OSMIFeatureTracker> arrFeatures;
     103    private final LinkedHashMap<BugInfo, Long> osmiBugInfo;
     104
     105    public Geometry getOsmBugGeometry(int index) {
     106        BugInfo[] array = new BugInfo[osmiBugInfo.keySet().size()];
     107        array = osmiBugInfo.keySet().toArray(array);
     108        return array[index].getGeom();
     109    }
     110
     111    public Map<BugInfo, Long> getOsmiBugInfo() {
     112        return osmiBugInfo;
     113    }
     114
     115    public SimpleFeatureSource getFeatureSource() {
     116        return featureSource;
     117    }
     118
     119    public void setFeatureSource(SimpleFeatureSource featureSource) {
     120        this.featureSource = featureSource;
     121    }
     122
     123    public boolean isbIsChanged() {
     124        return bIsChanged;
     125    }
     126
     127    public void setbIsChanged(boolean bIsChanged) {
     128        this.bIsChanged = bIsChanged;
     129    }
     130
     131    public List<OSMIFeatureTracker> getArrFeatures() {
     132        return arrFeatures;
     133    }
     134
     135    public void setArrFeatures(List<OSMIFeatureTracker> arrFeatures) {
     136        this.arrFeatures = arrFeatures;
     137    }
     138
     139    public BugIndex getOsmiIndex() {
     140        return osmiIndex;
     141    }
     142
     143    // Pointer to prev and next osmi bugs
     144    private final BugIndex osmiIndex;
     145
     146    /**
     147     *
     148     * The Bug attribute class: hold geom, id and description for that bug
     149     *
     150     * @author snikhil
     151     *
     152     */
     153    public static class BugInfo implements Comparable<BugInfo>{
     154
     155        public Geometry getGeom() {
     156            return geom;
     157        }
     158
     159        public String getDesc() {
     160            return desc;
     161        }
     162
     163        public String getId() {
     164            return id;
     165        }
     166
     167        @Override
     168        public int hashCode() {
     169            String fid = attributes.get("FID");
     170            String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
     171            return hash.hashCode();
     172        }
     173
     174        @Override
     175        public boolean equals(Object obj) {
     176            String fid = attributes.get("FID");
     177            String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
     178
     179
     180            if (obj instanceof BugInfo) {
     181                BugInfo b = (BugInfo) obj;
     182
     183                String bfid = b.attributes.get("FID");
     184                String bhash =  (bfid == null || bfid.isEmpty()) ? b.attributes.get("problem_id") : bfid;
     185                return hash.equals(bhash);
     186            }
     187            return false;
     188        }
     189
     190        // private final long bugId; //incremental bugId
     191        private final long bugId;
     192        private final Geometry geom;
     193        private final String desc;
     194        private final String id;
     195        private final Name name;
     196        private final Map<String, String> attributes;
     197
     198        public BugInfo(SimpleFeature next, long idx)
     199                throws IndexOutOfBoundsException, ParseException {
     200
     201            bugId = idx;
     202            attributes = new HashMap<>();
     203            Collection<Property> properties = next.getProperties();
     204            for (Property p : properties) {
     205                attributes.put(p.getName().toString(), p.getValue().toString());
     206            }
     207            this.geom = (Geometry) next.getAttribute(0);
     208            this.desc = (String) next.getAttribute("error_desc");
     209            this.id = next.getID();
     210            name = next.getName();
     211        }
     212
     213        @Override
     214        public String toString() {
     215            return "BugId_" + bugId + "\n";
     216        }
     217
     218        public String getContentString() {
     219            StringBuilder sb = new StringBuilder();
     220            sb.append("Layer:").append(name.getLocalPart()).append("\n");
     221            for (Entry<String, String> next : attributes.entrySet()) {
     222                sb.append(next.getKey()).append(":").append(next.getValue())
     223                        .append("\n");
     224            }
     225            return sb.toString();
     226        }
     227
     228        public long getBugId() {
     229            return bugId;
     230        }
     231
     232        @Override
     233        public int compareTo(BugInfo o) {
     234            String fid = attributes.get("FID");
     235            String hash =  (fid == null || fid.isEmpty()) ? attributes.get("problem_id") : fid;
     236
     237            String ofid = o.attributes.get("FID");
     238            String ohash =  (ofid == null || ofid.isEmpty()) ? o.attributes.get("problem_id") : ofid;
     239            return hash.compareTo(ohash);
     240        }
     241    }
     242
     243    /**
     244     * Helper class that stores the bug next and prev pointers and can navigate
     245     * the entire bug list
     246     *
     247     * @author snikhil
     248     *
     249     */
     250    public static class BugIndex {
     251        private int nextIndex;
     252        private int previousIndex;
     253        private final ArrayList<BugInfo> osmBugs;
     254
     255        public BugIndex(Map<BugInfo, Long> bugs) {
     256            osmBugs = new ArrayList<>(bugs.keySet());
     257            nextIndex = 0;
     258            previousIndex = -1;
     259        }
     260
     261        public BugIndex(Map<BugInfo, Long> bugs, int n, int p) {
     262            osmBugs = new ArrayList<>(bugs.keySet());
     263            nextIndex = n;
     264            previousIndex = p;
     265        }
     266
     267        public void next() {
     268            previousIndex = nextIndex;
     269            nextIndex = ++nextIndex % osmBugs.size();
     270        }
     271
     272        public void prev() {
     273            nextIndex = previousIndex;
     274            previousIndex = previousIndex - 1 < 0 ? osmBugs.size() - 1
     275                    : --previousIndex;
     276        }
     277
     278        public BugInfo getItemPointedByNext() {
     279            return osmBugs.get(nextIndex);
     280        }
     281
     282        public BugInfo getItemPointedByPrev() {
     283            return osmBugs.get(nextIndex);
     284        }
     285
     286        public int indexOf(BugInfo b) {
     287            return osmBugs.indexOf(b);
     288        }
     289
     290        public BugInfo getNext() {
     291            next();
     292            return osmBugs.get(nextIndex);
     293        }
     294
     295        public BugInfo getPrev() {
     296            prev();
     297            return osmBugs.get(nextIndex);
     298        }
     299
     300        public List<BugInfo> getBugs() {
     301            return osmBugs;
     302        }
     303
     304        public void append(Map<BugInfo, Long> osmiBugInfo) {
     305            for (BugInfo next : osmiBugInfo.keySet()) {
     306                if (!osmBugs.contains(next)) {
     307                    this.osmBugs.add(next);
     308                }
     309            }
     310        }
     311    }
     312
     313    private enum GeomType {
     314        POINT, LINE, POLYGON
     315    }
     316
     317    private static final Color SELECTED_COLOUR = Color.ORANGE;
     318    private static final float SELECTED_POINT_SIZE = 15.0f;
     319    private static final float OPACITY = 1.0f;
     320    private static final float LINE_WIDTH = 1.0f;
     321    private static final float POINT_SIZE = 10.0f;
     322
     323    public OsmInspectorLayer(GeoFabrikWFSClient wfsClient,
     324            ProgressMonitor monitor) throws NoSuchAuthorityCodeException,
     325            FactoryException, IOException, IndexOutOfBoundsException,
     326            ParseException {
     327        super("OsmInspector");
     328
     329        arrFeatures = new ArrayList<>();
     330        osmiBugInfo = new LinkedHashMap<>();
     331        selectGeomType = new ArrayList<>();
     332
     333        // Step 3 - discovery; enhance to iterate over all types with bounds
     334
     335        String[] typeNames = wfsClient.getTypeNames();
     336        renderer = new StreamingRenderer();
     337        CRS.decode(ProjectionRegistry.getProjection().toCode());
     338        crsOSMI = CRS.decode("EPSG:4326");
     339        content = new MapContent();
     340        content.getViewport().setCoordinateReferenceSystem(crsOSMI);
     341
     342        selectGeomType.add(GeomType.POINT);
     343        for (int idx = 1; idx < typeNames.length; ++idx) {
     344            String typeName = typeNames[idx];
     345            Set<FeatureId> selectedFeatures = new HashSet<>();
     346
     347            FeatureCollection<SimpleFeatureType, SimpleFeature> features = wfsClient
     348                    .getFeatures(typeName, monitor);
     349            setGeometry(selectGeomType, typeName);
     350
     351            Logging.info("Osm Inspector Features size: " + features.size());
     352            Style style = createDefaultStyle(idx, selectedFeatures);
     353
     354            OSMIFeatureTracker tracker = new OSMIFeatureTracker(features);
     355            arrFeatures.add(tracker);
     356            FeatureIterator<SimpleFeature> it = tracker.getFeatures().features();
     357
     358            while (it.hasNext()) {
     359                BugInfo theInfo = new BugInfo(it.next(), osmiBugInfo.size());
     360                osmiBugInfo.put(theInfo, theInfo.bugId);
     361            }
     362
     363            content.addLayer(new FeatureLayer(tracker.getFeatures(), style));
     364        }
     365
     366        osmiIndex = new BugIndex(osmiBugInfo);
     367        content.setTitle("Osm Inspector Errors");
     368        renderer.setMapContent(content);
     369        bIsChanged = true;
     370
     371        // finally initialize the dialog
     372        dialog = new OsmInspectorDialog(this);
     373        this.updateView();
     374    }
     375
     376    public void loadFeatures(GeoFabrikWFSClient wfsClient)
     377            throws NoSuchAuthorityCodeException, FactoryException, IOException,
     378            IndexOutOfBoundsException, NoSuchElementException, ParseException {
     379        String[] typeNames = wfsClient.getTypeNames();
     380
     381        content.layers().clear();
     382        selectGeomType.clear();
     383        selectGeomType.add(GeomType.POINT);
     384
     385        ProgressMonitor monitor = new ProgressMonitor(MainApplication.getMap().mapView,
     386                "Loading features", "", 0, 100);
     387
     388        for (int idx = 1; idx < typeNames.length; ++idx) {
     389            String typeName = typeNames[idx];
     390            Set<FeatureId> selectedFeatures = new HashSet<>();
     391
     392            monitor.setProgress(100 / typeNames.length * idx);
     393            FeatureCollection<SimpleFeatureType, SimpleFeature> features = wfsClient
     394                    .getFeatures(typeName, monitor);
     395            setGeometry(selectGeomType, typeName);
     396
     397            Logging.info("Osm Inspector Features size: " + features.size());
     398
     399            OSMIFeatureTracker tracker = arrFeatures.get(idx - layerOffset);
     400            tracker.mergeFeatures(features);
     401
     402            FeatureIterator<SimpleFeature> it = tracker.getFeatures().features();
     403
     404            while (it.hasNext()) {
     405                BugInfo theInfo = new BugInfo(it.next(), osmiBugInfo.size());
     406                if (!osmiBugInfo.containsKey(theInfo)) {
     407                    osmiBugInfo.put(theInfo, theInfo.bugId);
     408                }
     409            }
     410
     411            Style style = createDefaultStyle(idx, selectedFeatures);
     412            content.addLayer(new FeatureLayer(tracker.getFeatures(), style));
     413        }
     414
     415        osmiIndex.append(osmiBugInfo);
     416
     417
     418        monitor.setProgress(100);
     419        monitor.close();
     420        bIsChanged = true;
     421        //dialog.updateDialog(this);
     422        dialog.refreshModel();
     423        //dialog.updateNextPrevAction(this);
     424
     425        this.updateView();
     426    }
     427
     428    private Style createDefaultStyle(int idx, Set<FeatureId> IDs) {
     429        Color fillColor = featureFills[idx];
     430
     431        Rule selectedRule = createRule(SELECTED_COLOUR, SELECTED_COLOUR, true);
     432        selectedRule.setFilter(ff.id(IDs));
     433
     434        Rule rule = createRule(fillColor, fillColor, false);
     435        rule.setElseFilter(true);
     436
     437        FeatureTypeStyle fts = sf.createFeatureTypeStyle();
     438        fts.rules().add(selectedRule);
     439        fts.rules().add(rule);
     440
     441        Style style = sf.createStyle();
     442        style.featureTypeStyles().add(fts);
     443        return style;
     444    }
     445
     446    private Rule createRule(Color outlineColor, Color fillColor,
     447            boolean bSelected) {
     448        Symbolizer symbolizer = null;
     449        Fill fill = null;
     450        Stroke stroke = sf.createStroke(ff.literal(outlineColor),
     451                ff.literal(LINE_WIDTH));
     452
     453        switch (geometryType) {
     454        case POLYGON:
     455            fill = sf.createFill(ff.literal(fillColor), ff.literal(OPACITY));
     456            symbolizer = sf.createPolygonSymbolizer(stroke, fill,
     457                    geometryAttributeName);
     458            break;
     459
     460        case LINE:
     461            symbolizer = sf.createLineSymbolizer(stroke, geometryAttributeName);
     462            break;
     463
     464        case POINT:
     465            fill = sf.createFill(ff.literal(fillColor), ff.literal(OPACITY));
     466
     467            Mark mark = sf.getTriangleMark();
     468            mark.setFill(fill);
     469            mark.setStroke(stroke);
     470
     471            Graphic graphic = sf.createDefaultGraphic();
     472            graphic.graphicalSymbols().clear();
     473            graphic.graphicalSymbols().add(mark);
     474            graphic.setSize(ff.literal(bSelected ? SELECTED_POINT_SIZE
     475                    : POINT_SIZE));
     476
     477            symbolizer = sf.createPointSymbolizer(graphic,
     478                    geometryAttributeName);
     479        }
     480
     481        Rule rule = sf.createRule();
     482        rule.symbolizers().add(symbolizer);
     483        return rule;
     484    }
     485
     486    private void setGeometry(ArrayList<GeomType> selectedTypes, String typename) {
     487        Logging.info("Passed type is" + typename);
     488        if (typename.compareTo("duplicate_ways") == 0) {
     489            geometryType = GeomType.LINE;
     490        } else
     491            geometryType = GeomType.POINT;
     492
     493        selectedTypes.add(geometryType);
     494    }
     495
     496    @Override
     497    public Icon getIcon() {
     498        return ImageProvider.get("layer/osmdata_small");
     499    }
     500
     501    @Override
     502    public Object getInfoComponent() {
     503        return getToolTipText();
     504    }
     505
     506    @Override
     507    public Action[] getMenuEntries() {
     508        return new Action[] {};
     509    }
     510
     511    @Override
     512    public String getToolTipText() {
     513        return org.openstreetmap.josm.tools.I18n.tr("OsmInspector");
     514    }
     515
     516    @Override
     517    public boolean isMergable(Layer other) {
     518        return false;
     519    }
     520
     521    @Override
     522    public void mergeFrom(Layer from) {
     523        return;
     524    }
     525
     526    @Override
     527    public void paint(Graphics2D g, MapView mv, Bounds box) {
     528        LatLon min = box.getMin();
     529        LatLon max = box.getMax();
     530
     531        Envelope envelope2 = new Envelope(Math.min(min.lat(), max.lat()),
     532                Math.max(min.lat(), max.lat()), Math.min(min.lon(), max.lon()),
     533                Math.max(min.lon(), max.lon()));
     534
     535        ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope2, crsOSMI);
     536
     537        renderer.setInteractive(false);
     538        renderer.paint(g, mv.getBounds(), mapArea);
     539        bIsChanged = false;
     540    }
     541
     542    @Override
     543    public void visitBoundingBox(BoundingXYVisitor v) {
     544    }
     545
     546    public boolean isChanged() {
     547        return bIsChanged;
     548    }
     549
     550    public void updateView() {
     551        this.dialog.revalidate();
     552        invalidate();
     553    }
     554
     555    public void selectFeatures(int x, int y) {
     556        int pixelDelta = 2;
     557        LatLon clickUL = MainApplication.getMap().mapView.getLatLon(x - pixelDelta, y
     558                - pixelDelta);
     559        LatLon clickLR = MainApplication.getMap().mapView.getLatLon(x + pixelDelta, y
     560                + pixelDelta);
     561
     562        Envelope envelope = new Envelope(
     563                Math.min(clickUL.lon(), clickLR.lon()), Math.max(clickUL.lon(),
     564                        clickLR.lon()), Math.min(clickUL.lat(), clickLR.lat()),
     565                Math.max(clickUL.lat(), clickLR.lat()));
     566
     567        ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope, crsOSMI);
     568
     569        Intersects filter = ff.intersects(ff.property("msGeometry"),
     570                ff.literal(mapArea));
     571        //
     572        // Select features in all layers
     573        //
     574        content.layers().clear();
     575
     576        // Iterate through features and build a list that intersects the above
     577        // envelope
     578        for (int idx = 0; idx < arrFeatures.size(); ++idx) {
     579            OSMIFeatureTracker tracker = arrFeatures.get(idx);
     580            FeatureCollection<SimpleFeatureType, SimpleFeature> features = tracker
     581                    .getFeatures();
     582
     583            SimpleFeatureSource tempfs = DataUtilities.source(features);
     584            FeatureCollection<SimpleFeatureType, SimpleFeature> selectedFeatures;
     585
     586            try {
     587                selectedFeatures = tempfs.getFeatures(filter);
    598588                Set<FeatureId> IDs = new HashSet<>();
    599589
    600                                 try (FeatureIterator<SimpleFeature> iter = selectedFeatures.features()) {
     590                try (FeatureIterator<SimpleFeature> iter = selectedFeatures.features()) {
    601591   
    602                                 Logging.info("Selected features " + selectedFeatures.size());
     592                    Logging.info("Selected features " + selectedFeatures.size());
    603593   
    604                                 while (iter.hasNext()) {
    605                                         SimpleFeature feature = iter.next();
    606                                         IDs.add(feature.getIdentifier());
    607                                 }
    608                                 }
    609 
    610                                 geometryType = selectGeomType.get(idx + layerOffset);
    611                                 Style style = createDefaultStyle(idx + layerOffset, IDs);
    612                                 content.addLayer(new FeatureLayer(features, style));
    613                         } catch (IOException e) {
    614                                 Logging.error(e);
    615                         }
    616                 }
    617 
    618                 bIsChanged = true;
    619         }
    620 
    621         public void selectFeatures(LatLon center) {
    622                 Point point = MainApplication.getMap().mapView.getPoint(center);
    623                 selectFeatures(point.x, point.y);
    624         }
    625 
    626         public void setOsmiIndex(int firstIndex) {
    627                 osmiIndex.nextIndex = firstIndex;
    628                 osmiIndex.previousIndex = firstIndex - 1 >= 0 ? firstIndex - 1
    629                                 : osmiBugInfo.size() - 1;
    630         }
    631 
     594                    while (iter.hasNext()) {
     595                        SimpleFeature feature = iter.next();
     596                        IDs.add(feature.getIdentifier());
     597                    }
     598                }
     599
     600                geometryType = selectGeomType.get(idx + layerOffset);
     601                Style style = createDefaultStyle(idx + layerOffset, IDs);
     602                content.addLayer(new FeatureLayer(features, style));
     603            } catch (IOException e) {
     604                Logging.error(e);
     605            }
     606        }
     607
     608        bIsChanged = true;
     609    }
     610
     611    public void selectFeatures(LatLon center) {
     612        Point point = MainApplication.getMap().mapView.getPoint(center);
     613        selectFeatures(point.x, point.y);
     614    }
     615
     616    public void setOsmiIndex(int firstIndex) {
     617        osmiIndex.nextIndex = firstIndex;
     618        osmiIndex.previousIndex = firstIndex - 1 >= 0 ? firstIndex - 1
     619                : osmiBugInfo.size() - 1;
     620    }
    632621}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/OsmInspectorPlugin.java

    r34538 r36176  
    2626MouseListener, PreferenceChangedListener, DownloadSelection{
    2727
    28         /** The JOSM user identity manager, it is used for obtaining the user name */
     28    /** The JOSM user identity manager, it is used for obtaining the user name */
    2929    private final UserIdentityManager userIdentityManager;
    3030   
    … …  
    3535    private OsmInspectorLayer inspectorLayer;
    3636   
    37         public OsmInspectorPlugin(PluginInformation info) {
    38                 super(info);
    39                 userIdentityManager = UserIdentityManager.getInstance();
    40                 initializePlugin();
    41         }
    42        
    43         /**
     37    public OsmInspectorPlugin(PluginInformation info) {
     38        super(info);
     39        userIdentityManager = UserIdentityManager.getInstance();
     40        initializePlugin();
     41    }
     42
     43    /**
    4444     * Initialize the <code>OsmInspectorPlugin</code> object. Creates the
    4545     * <code>OsmInspectorGUI</code> and initializes the following variables with
    … …  
    5959        inspectorLayer = null;
    6060    }
    61         @Override
    62         public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame) {
    63                 MainApplication.getToolbar().register( new ImportOsmInspectorBugsAction( this ) );
    64                 if (newFrame == null) {
     61    @Override
     62    public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame) {
     63        MainApplication.getToolbar().register( new ImportOsmInspectorBugsAction( this ) );
     64        if (newFrame == null) {
    6565            /* if new MapFrame is null, remove listener */
    6666            NavigatableComponent.removeZoomChangeListener(this);
    … …  
    8181            }
    8282        }
    83         }
     83    }
    8484
    85         @Override
    86         public void zoomChanged() {
    87                
    88         }
     85    @Override
     86    public void zoomChanged() {
    8987
    90         @Override
    91         //
    92         //  Delegate feature selection to layer
    93         //
    94         public void mouseClicked(MouseEvent e) {
    95             if (inspectorLayer != null) {
    96                 inspectorLayer.selectFeatures(e.getX(), e.getY());
    97             }
    98         }
     88    }
    9989
    100         @Override
    101         public void mouseEntered(MouseEvent e) {
    102                
    103         }
     90    @Override
     91    //
     92    //  Delegate feature selection to layer
     93    //
     94    public void mouseClicked(MouseEvent e) {
     95        if (inspectorLayer != null) {
     96            inspectorLayer.selectFeatures(e.getX(), e.getY());
     97        }
     98    }
    10499
    105         @Override
    106         public void mouseExited(MouseEvent e) {
    107                
    108         }
     100    @Override
     101    public void mouseEntered(MouseEvent e) {
    109102
    110         @Override
    111         public void mousePressed(MouseEvent e) {
    112                
    113         }
     103    }
    114104
    115         @Override
    116         public void mouseReleased(MouseEvent e) {
    117                
    118         }
     105    @Override
     106    public void mouseExited(MouseEvent e) {
    119107
    120         @Override
    121         public void preferenceChanged(PreferenceChangeEvent e) {
    122                
    123         }
     108    }
    124109
    125         public OsmInspectorLayer getLayer()
    126         {
    127                 return inspectorLayer;
    128         }
     110    @Override
     111    public void mousePressed(MouseEvent e) {
    129112
    130         public void setLayer( OsmInspectorLayer theLayer )
    131         {
    132                 inspectorLayer = theLayer;
    133         }
     113    }
    134114
    135         @Override
    136         public void addGui(DownloadDialog gui) {
    137                 // TODO Auto-generated method stub
    138         }
     115    @Override
     116    public void mouseReleased(MouseEvent e) {
    139117
    140         @Override
    141         public void setDownloadArea(Bounds bounds) {
    142                 // TODO Auto-generated method stub
    143         }
     118    }
     119
     120    @Override
     121    public void preferenceChanged(PreferenceChangeEvent e) {
     122
     123    }
     124
     125    public OsmInspectorLayer getLayer()
     126    {
     127        return inspectorLayer;
     128    }
     129
     130    public void setLayer( OsmInspectorLayer theLayer )
     131    {
     132        inspectorLayer = theLayer;
     133    }
     134
     135    @Override
     136    public void addGui(DownloadDialog gui) {
     137        // TODO Auto-generated method stub
     138    }
     139
     140    @Override
     141    public void setDownloadArea(Bounds bounds) {
     142        // TODO Auto-generated method stub
     143    }
    144144}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/gui/OsmInspectorBugInfoDialog.java

    r33793 r36176  
    44
    55import java.awt.event.KeyEvent;
    6 import java.util.Arrays;
     6import java.util.Collections;
    77
    88import javax.swing.JTextPane;
    99
    1010import org.openstreetmap.josm.gui.MainApplication;
    11 import org.openstreetmap.josm.gui.SideButton;
    1211import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
    1312import org.openstreetmap.josm.plugins.osminspector.OsmInspectorLayer;
    … …  
    1716public class OsmInspectorBugInfoDialog extends ToggleDialog {
    1817
    19         private JTextPane bugTextArea;
     18    private JTextPane bugTextArea;
    2019
    21         /**
    22          * Builds the content panel for this dialog
    23          */
    24         protected void buildContentPanel() {
    25                 MainApplication.getMap().addToggleDialog(this, true);
    26                
    27                 bugTextArea = new JTextPane();
    28                 createLayout(bugTextArea, true, Arrays.asList(new SideButton[] {}));
    29                 bugTextArea.setText("This is a demo");
    30                 this.add(bugTextArea);
    31         }
     20    /**
     21     * Builds the content panel for this dialog
     22     */
     23    protected void buildContentPanel() {
     24        MainApplication.getMap().addToggleDialog(this, true);
    3225
    33         public OsmInspectorBugInfoDialog(OsmInspectorLayer layer) {
     26        bugTextArea = new JTextPane();
     27        createLayout(bugTextArea, true, Collections.emptyList());
     28        bugTextArea.setText("This is a demo");
     29        this.add(bugTextArea);
     30    }
    3431
    35                 super(tr("OsmBugInfo"), "select",
    36                                 tr("Open a OSM Inspector selection list window."), Shortcut.registerShortcut("subwindow:select",
    37                                                                 tr("Toggle: {0}", tr("Current Selected Bug Info")),
    38                                                                 KeyEvent.VK_D, Shortcut.ALT_SHIFT), 150, // default
    39                                                                                                                                                         // height
    40                                 true // default is "show dialog"
    41                 );
    42                 buildContentPanel();
    43         }
     32    public OsmInspectorBugInfoDialog(OsmInspectorLayer layer) {
    4433
    45         public void updateDialog(OsmInspectorLayer l) {
    46         }
    47        
    48         public void setBugDescription(BugInfo i){
    49             bugTextArea.setText(i.getContentString());
    50         }
    51        
    52         @Override
    53         public void hideNotify() {
    54                 if (dialogsPanel != null) {
    55                         super.hideNotify();
    56                 }
    57         }
     34        super(tr("OsmBugInfo"), "select",
     35                tr("Open a OSM Inspector selection list window."), Shortcut.registerShortcut("subwindow:select",
     36                                tr("Toggle: {0}", tr("Current Selected Bug Info")),
     37                                KeyEvent.VK_D, Shortcut.ALT_SHIFT), 150, // default
     38                                                                            // height
     39                true // default is "show dialog"
     40        );
     41        buildContentPanel();
     42    }
     43
     44    public void updateDialog(OsmInspectorLayer l) {
     45    }
     46
     47    public void setBugDescription(BugInfo i){
     48        bugTextArea.setText(i.getContentString());
     49    }
     50
     51    @Override
     52    public void hideNotify() {
     53        if (dialogsPanel != null) {
     54            super.hideNotify();
     55        }
     56    }
    5857}

  • applications/editors/josm/plugins/OsmInspectorPlugin/src/org/openstreetmap/josm/plugins/osminspector/gui/OsmInspectorDialog.java

    r35123 r36176  
    44
    55import java.awt.event.ActionEvent;
    6 import java.awt.event.ActionListener;
    76import java.awt.event.KeyEvent;
    87import java.util.Arrays;
    … …  
    1413import javax.swing.ListSelectionModel;
    1514import javax.swing.ScrollPaneConstants;
    16 import javax.swing.event.ListSelectionEvent;
    17 import javax.swing.event.ListSelectionListener;
    18 
     15
     16import org.locationtech.jts.geom.Geometry;
     17import org.locationtech.jts.geom.Point;
    1918import org.openstreetmap.josm.data.coor.LatLon;
    2019import org.openstreetmap.josm.gui.MainApplication;
    … …  
    3231import org.openstreetmap.josm.tools.Shortcut;
    3332
    34 import org.locationtech.jts.geom.Geometry;
    35 import org.locationtech.jts.geom.Point;
    36 
    3733public class OsmInspectorDialog extends ToggleDialog implements LayerChangeListener, ActiveLayerChangeListener {
    3834
    39         private OsmInspectorLayer layer;
    40         private JList<String> bugsList;
    41         private OsmInspectorNextAction actNext;
    42         private OsmInspectorPrevAction actPrev;
    43         private DefaultListModel<String> model;
    44 
    45         private OsmInspectorBugInfoDialog bugInfoDialog;
    46        
    47         public void updateNextPrevAction(OsmInspectorLayer l) {
    48                 this.actNext.inspectlayer = l;
    49                 this.actPrev.inspectlayer = l;
    50         }
    51        
    52         /**
    53          * Builds the content panel for this dialog
    54          */
    55         protected void buildContentPanel() {
    56                 MainApplication.getMap().addToggleDialog(this, true);
    57 
    58                 model = new DefaultListModel<>();
    59                 refreshModel();
    60                 bugsList = new JList<>(model);
    61                 bugsList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    62                 bugsList.setLayoutOrientation(JList.VERTICAL_WRAP);
    63                
    64                 bugsList.setVisibleRowCount(-1);
    65                 JScrollPane scroll = new JScrollPane(bugsList,
    66                                 ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
    67                                 ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
    68                
    69                 bugsList.addListSelectionListener(new ListSelectionListener() {
    70                        
    71                         @Override
    72                         public void valueChanged(ListSelectionEvent e) {
    73                                 layer.setOsmiIndex(e.getFirstIndex());
    74                                 BugInfo next = layer.getOsmiIndex().getItemPointedByNext();
    75                                 layer.setOsmiIndex((e.getFirstIndex() + 1) % layer.getOsmiBugInfo().size());
    76                                 Geometry geom = next.getGeom();
    77                                 Point centroid = geom.getCentroid();
    78                                 LatLon center = new LatLon(centroid.getY(), centroid.getX());
    79                                 MainApplication.getMap().mapView.zoomTo(center);
    80                                 layer.selectFeatures(center);
    81                                 bugInfoDialog.setBugDescription(next);
    82                         }
    83                 });
    84                
    85                 // refreshBugList();
    86                 // the next action
    87                 final SideButton nextButton = new SideButton(
    88                                 actNext = new OsmInspectorNextAction(layer));
    89                 nextButton.createArrow(new ActionListener() {
    90                     @Override
    91                         public void actionPerformed(ActionEvent e) {
    92                                 int index = bugsList.getSelectedIndex();
    93                                 Geometry geom = layer.getOsmBugGeometry(index);
    94                                 Point centroid = geom.getCentroid();
    95                                 LatLon center = new LatLon(centroid.getY(), centroid.getX());
    96                                 MainApplication.getMap().mapView.zoomTo(center);
    97                                 layer.selectFeatures(center);
    98                         }
    99                 });
    100 
    101                 // the previous button
    102                 final SideButton prevButton = new SideButton(
    103                                 actPrev = new OsmInspectorPrevAction(layer));
    104                 prevButton.createArrow(new ActionListener() {
    105             @Override
    106                         public void actionPerformed(ActionEvent e) {
    107                         }
    108                 });
    109 
    110                 createLayout(scroll, true,
    111                                 Arrays.asList(new SideButton[] { nextButton, prevButton }));
    112                 this.add(scroll);
    113 
    114                 Shortcut sprev = Shortcut.registerShortcut("osmi:prev", tr("Prev OSMI bug"),
    115                                 KeyEvent.VK_J, Shortcut.CTRL_SHIFT);
    116                 MainApplication.registerActionShortcut(actPrev, sprev);
    117 
    118                 Shortcut snext = Shortcut.registerShortcut("osmi:next", tr("Next OSMI bug"),
    119                                 KeyEvent.VK_K, Shortcut.CTRL_SHIFT);
    120                 MainApplication.registerActionShortcut(actNext, snext);
    121         }
    122 
    123         public void refreshModel() {
    124                 model.clear();
    125                 for (Object b : layer.getOsmiBugInfo().keySet()) {
    126                         if (b instanceof BugInfo) {
    127                                 model.addElement(b.toString());
    128                         }
    129                 }
    130         }
    131 
    132         public OsmInspectorDialog(OsmInspectorLayer layer) {
    133 
    134                 super(tr("OSM Inspector Bugs"), "selectionlist",
    135                                 tr("Open a OSM Inspector selection list window."), Shortcut.registerShortcut("subwindow:osminspector",
    136                                                                 tr("Toggle: {0}", tr("OSM Inspector Bugs")),
    137                                                                 KeyEvent.VK_W, Shortcut.ALT_SHIFT), 150, // default height
    138                                 true // default is "show dialog"
    139                 );
    140                 this.layer = layer;
    141                 buildContentPanel();
    142                 bugInfoDialog = new OsmInspectorBugInfoDialog(layer);
    143                 bugInfoDialog.setTitle(tr("Selected Bug Info"));
    144         }
    145 
    146         public void updateDialog(OsmInspectorLayer l) {
    147                 this.layer = l;
    148                 bugInfoDialog.updateDialog(l);
    149                 refreshModel();
    150                 refreshBugList();
    151         }
    152        
    153         @Override
    154         public void showNotify() {
    155                 super.showNotify();
    156         }
    157 
    158         @Override
    159         public void hideNotify() {
    160                 if (dialogsPanel != null) {
    161                         super.hideNotify();
    162                 }
    163         }
    164 
    165         public class OsmInspectorNextAction extends AbstractAction {
    166 
    167                 private OsmInspectorLayer inspectlayer;
    168 
    169                 public OsmInspectorNextAction(Layer inspector) {
    170                         super("next");
    171                         inspectlayer = (OsmInspectorLayer) inspector;
    172                 }
    173 
    174                 @Override
    175                 public void actionPerformed(ActionEvent e) {
    176                         inspectlayer.getOsmiIndex().next();
    177                         BugInfo next = inspectlayer.getOsmiIndex().getItemPointedByNext();
    178                         Geometry geom = next.getGeom();
    179                         Point centroid = geom.getCentroid();
    180                         LatLon center = new LatLon(centroid.getY(), centroid.getX());
    181                         MainApplication.getMap().mapView.zoomTo(center);
    182                         inspectlayer.selectFeatures(center);
    183                         bugInfoDialog.setBugDescription(next);
    184                         updateSelection(next);
    185                 }
    186         }
    187 
    188         private void updateSelection(BugInfo prev) {
    189                 int idx = layer.getOsmiIndex().indexOf(prev);
    190                 if (idx >= 0) {
    191                         bugsList.setSelectedIndex(idx);
    192                 }
    193         }
    194 
    195         private class OsmInspectorPrevAction extends AbstractAction {
    196 
    197                 private OsmInspectorLayer inspectlayer;
    198 
    199                 public OsmInspectorPrevAction(Layer inspector) {
    200                         super("prev");
    201                         inspectlayer = (OsmInspectorLayer) inspector;
    202                 }
    203 
    204                 @Override
    205                 public void actionPerformed(ActionEvent e) {
    206                         inspectlayer.getOsmiIndex().prev();
    207                         BugInfo prev = inspectlayer.getOsmiIndex().getItemPointedByPrev();
    208                         Geometry geom = prev.getGeom();
    209                         Point centroid = geom.getCentroid();
    210                         LatLon center = new LatLon(centroid.getY(), centroid.getX());
    211                         MainApplication.getMap().mapView.zoomTo(center);
    212                         inspectlayer.selectFeatures(center);
    213                         bugInfoDialog.setBugDescription(prev);
    214                         updateSelection(prev);
    215                 }
    216         }
    217 
    218         @Override
    219         public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
    220             Layer newLayer = MainApplication.getLayerManager().getActiveLayer();
    221                 if (newLayer instanceof OsmInspectorLayer) {
    222                         this.layer = (OsmInspectorLayer) newLayer;
    223                         refreshModel();
    224                         refreshBugList();
    225                 }
    226         }
    227 
    228         private void refreshBugList() {
    229                 bugsList.clearSelection();
    230                 bugsList = new JList<>(model);
    231         }
    232 
    233         @Override
    234         public void layerAdded(LayerAddEvent e) {
    235                 if (layer != null) {
    236                         refreshModel();
    237                         refreshBugList();
    238                 }
    239         }
    240 
    241         @Override
    242         public void layerRemoving(LayerRemoveEvent e) {
    243                 if (layer != null) {
    244                         bugsList.clearSelection();
    245                         model.clear();
    246                 }
    247         }
     35    private OsmInspectorLayer layer;
     36    private JList<String> bugsList;
     37    private OsmInspectorNextAction actNext;
     38    private OsmInspectorPrevAction actPrev;
     39    private DefaultListModel<String> model;
     40
     41    private final OsmInspectorBugInfoDialog bugInfoDialog;
     42
     43    public void updateNextPrevAction(OsmInspectorLayer l) {
     44        this.actNext.inspectlayer = l;
     45        this.actPrev.inspectlayer = l;
     46    }
     47
     48    /**
     49     * Builds the content panel for this dialog
     50     */
     51    protected void buildContentPanel() {
     52        MainApplication.getMap().addToggleDialog(this, true);
     53
     54        model = new DefaultListModel<>();
     55        refreshModel();
     56        bugsList = new JList<>(model);
     57        bugsList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
     58        bugsList.setLayoutOrientation(JList.VERTICAL_WRAP);
     59
     60        bugsList.setVisibleRowCount(-1);
     61        JScrollPane scroll = new JScrollPane(bugsList,
     62                ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS,
     63                ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
     64
     65        bugsList.addListSelectionListener(e -> {
     66            layer.setOsmiIndex(e.getFirstIndex());
     67            BugInfo next = layer.getOsmiIndex().getItemPointedByNext();
     68            layer.setOsmiIndex((e.getFirstIndex() + 1) % layer.getOsmiBugInfo().size());
     69            Geometry geom = next.getGeom();
     70            Point centroid = geom.getCentroid();
     71            LatLon center = new LatLon(centroid.getY(), centroid.getX());
     72            MainApplication.getMap().mapView.zoomTo(center);
     73            layer.selectFeatures(center);
     74            bugInfoDialog.setBugDescription(next);
     75        });
     76
     77        // refreshBugList();
     78        // the next action
     79        final SideButton nextButton = new SideButton(
     80                actNext = new OsmInspectorNextAction(layer));
     81        nextButton.createArrow(e -> {
     82            int index = bugsList.getSelectedIndex();
     83            Geometry geom = layer.getOsmBugGeometry(index);
     84            Point centroid = geom.getCentroid();
     85            LatLon center = new LatLon(centroid.getY(), centroid.getX());
     86            MainApplication.getMap().mapView.zoomTo(center);
     87            layer.selectFeatures(center);
     88        });
     89
     90        // the previous button
     91                actPrev = new OsmInspectorPrevAction(layer);
     92        final SideButton prevButton = new SideButton(actPrev);
     93        prevButton.createArrow(e -> { });
     94
     95        createLayout(scroll, true,
     96                Arrays.asList(nextButton, prevButton));
     97        this.add(scroll);
     98
     99        Shortcut sprev = Shortcut.registerShortcut("osmi:prev", tr("Prev OSMI bug"),
     100                KeyEvent.VK_J, Shortcut.CTRL_SHIFT);
     101        MainApplication.registerActionShortcut(actPrev, sprev);
     102
     103        Shortcut snext = Shortcut.registerShortcut("osmi:next", tr("Next OSMI bug"),
     104                KeyEvent.VK_K, Shortcut.CTRL_SHIFT);
     105        MainApplication.registerActionShortcut(actNext, snext);
     106    }
     107
     108    public void refreshModel() {
     109        model.clear();
     110        for (Object b : layer.getOsmiBugInfo().keySet()) {
     111            if (b instanceof BugInfo) {
     112                model.addElement(b.toString());
     113            }
     114        }
     115    }
     116
     117    public OsmInspectorDialog(OsmInspectorLayer layer) {
     118
     119        super(tr("OSM Inspector Bugs"), "selectionlist",
     120                tr("Open a OSM Inspector selection list window."), Shortcut.registerShortcut("subwindow:osminspector",
     121                                tr("Toggle: {0}", tr("OSM Inspector Bugs")),
     122                                KeyEvent.VK_W, Shortcut.ALT_SHIFT), 150, // default height
     123                true // default is "show dialog"
     124        );
     125        this.layer = layer;
     126        buildContentPanel();
     127        bugInfoDialog = new OsmInspectorBugInfoDialog(layer);
     128        bugInfoDialog.setTitle(tr("Selected Bug Info"));
     129    }
     130
     131    public void updateDialog(OsmInspectorLayer l) {
     132        this.layer = l;
     133        bugInfoDialog.updateDialog(l);
     134        refreshModel();
     135        refreshBugList();
     136    }
     137
     138    @Override
     139    public void showNotify() {
     140        super.showNotify();
     141    }
     142
     143    @Override
     144    public void hideNotify() {
     145        if (dialogsPanel != null) {
     146            super.hideNotify();
     147        }
     148    }
     149
     150    public class OsmInspectorNextAction extends AbstractAction {
     151
     152        private OsmInspectorLayer inspectlayer;
     153
     154        public OsmInspectorNextAction(Layer inspector) {
     155            super("next");
     156            inspectlayer = (OsmInspectorLayer) inspector;
     157        }
     158
     159        @Override
     160        public void actionPerformed(ActionEvent e) {
     161            inspectlayer.getOsmiIndex().next();
     162            BugInfo next = inspectlayer.getOsmiIndex().getItemPointedByNext();
     163            Geometry geom = next.getGeom();
     164            Point centroid = geom.getCentroid();
     165            LatLon center = new LatLon(centroid.getY(), centroid.getX());
     166            MainApplication.getMap().mapView.zoomTo(center);
     167            inspectlayer.selectFeatures(center);
     168            bugInfoDialog.setBugDescription(next);
     169            updateSelection(next);
     170        }
     171    }
     172
     173    private void updateSelection(BugInfo prev) {
     174        int idx = layer.getOsmiIndex().indexOf(prev);
     175        if (idx >= 0) {
     176            bugsList.setSelectedIndex(idx);
     177        }
     178    }
     179
     180    private class OsmInspectorPrevAction extends AbstractAction {
     181
     182        private OsmInspectorLayer inspectlayer;
     183
     184        public OsmInspectorPrevAction(Layer inspector) {
     185            super("prev");
     186            inspectlayer = (OsmInspectorLayer) inspector;
     187        }
     188
     189        @Override
     190        public void actionPerformed(ActionEvent e) {
     191            inspectlayer.getOsmiIndex().prev();
     192            BugInfo prev = inspectlayer.getOsmiIndex().getItemPointedByPrev();
     193            Geometry geom = prev.getGeom();
     194            Point centroid = geom.getCentroid();
     195            LatLon center = new LatLon(centroid.getY(), centroid.getX());
     196            MainApplication.getMap().mapView.zoomTo(center);
     197            inspectlayer.selectFeatures(center);
     198            bugInfoDialog.setBugDescription(prev);
     199            updateSelection(prev);
     200        }
     201    }
     202
     203    @Override
     204    public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
     205        Layer newLayer = MainApplication.getLayerManager().getActiveLayer();
     206        if (newLayer instanceof OsmInspectorLayer) {
     207            this.layer = (OsmInspectorLayer) newLayer;
     208            refreshModel();
     209            refreshBugList();
     210        }
     211    }
     212
     213    private void refreshBugList() {
     214        bugsList.clearSelection();
     215        bugsList = new JList<>(model);
     216    }
     217
     218    @Override
     219    public void layerAdded(LayerAddEvent e) {
     220        if (layer != null) {
     221            refreshModel();
     222            refreshBugList();
     223        }
     224    }
     225
     226    @Override
     227    public void layerRemoving(LayerRemoveEvent e) {
     228        if (layer != null) {
     229            bugsList.clearSelection();
     230            model.clear();
     231        }
     232    }
    248233
    249234    @Override
Note: See TracChangeset for help on using the changeset viewer.