Index: /applications/editors/josm/plugins/FixAddresses/build.xml =================================================================== --- /applications/editors/josm/plugins/FixAddresses/build.xml (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/build.xml (revision 24018) @@ -91,5 +91,6 @@ - + + Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressFinderThread.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressFinderThread.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressFinderThread.java (revision 24018) @@ -150,4 +150,6 @@ progressMonitor.setTicksCount(addressesToGuess.size()); + + List shadowCopy = new ArrayList(addressesToGuess); for (AddressNode aNode : shadowCopy) { @@ -155,5 +157,12 @@ curAddressNode = aNode; - if (aNode.hasStreetName()) { + // setup guessing handlers for address tags + GuessedValueHandler[] guessers = new GuessedValueHandler[]{ + new GuessStreetValueHandler(TagUtils.ADDR_STREET_TAG, aNode), + new GuessedValueHandler(TagUtils.ADDR_POSTCODE_TAG, aNode, 500.0), + new GuessedValueHandler(TagUtils.ADDR_CITY_TAG, aNode, 2000.0) + }; + + if (!aNode.needsGuess()) { // nothing to do progressMonitor.worked(1); continue; @@ -170,6 +179,9 @@ break; } - osmPrimitive.visit(this); - + + // guess values + for (int i = 0; i < guessers.length; i++) { + osmPrimitive.visit(guessers[i]); + } } @@ -189,3 +201,37 @@ } } + + private class GuessStreetValueHandler extends GuessedValueHandler { + + public GuessStreetValueHandler(String tag, AddressNode aNode) { + super(tag, aNode); + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.plugins.fixAddresses.GuessedValueHandler#visit(org.openstreetmap.josm.data.osm.Node) + */ + @Override + public void visit(Node n) { + // do nothing + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.plugins.fixAddresses.GuessedValueHandler#visit(org.openstreetmap.josm.data.osm.Way) + */ + @Override + public void visit(Way w) { + if (TagUtils.hasHighwayTag(w)) { + AddressNode aNode = getAddressNode(); + double dist = OsmUtils.getMinimumDistanceToWay(aNode.getCoor(), w); + if (dist < minDist && dist < getMaxDistance()) { + minDist = dist; + currentValue = TagUtils.getNameValue(w); + + System.out.println(String.format("New guess (way) for tag %s (%4.2f m): %s (%s)", + getTag(), minDist, currentValue, aNode.toString())); + aNode.setGuessedValue(getTag(), currentValue); + } + } + } + } } Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressNode.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressNode.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/AddressNode.java (revision 24018) @@ -14,4 +14,6 @@ package org.openstreetmap.josm.plugins.fixAddresses; +import java.util.HashMap; + import org.openstreetmap.josm.data.osm.OsmPrimitive; @@ -19,5 +21,5 @@ public static final String MISSING_TAG = "?"; - private String guessedStreetName; + private HashMap guessedValues = new HashMap(); public AddressNode(OsmPrimitive osmObject) { @@ -48,28 +50,40 @@ */ public String getStreetName() { + return getTagValueWithGuess(TagUtils.ADDR_STREET_TAG); + } + + /** + * Gets the tag value with guess. If the object does not have the given tag, this mehtod looks for + * an appropriate guess. If both, real value and guess, are missing, a question mark is returned. + * + * @param tag the tag + * @return the tag value with guess + */ + private String getTagValueWithGuess(String tag) { + if (StringUtils.isNullOrEmpty(tag)) return MISSING_TAG; if (osmObject == null) return MISSING_TAG; - /* - if (!TagUtils.hasAddrStreetTag(osmObject)) { - // check, if referrers have a street - for (OsmPrimitive osm : osmObject.getReferrers()) { - if (TagUtils.hasAddrStreetTag(osm)) { - String refStreetName = TagUtils.getAddrStreetValue(osm); - - if (!StringUtils.isNullOrEmpty(refStreetName)) { - return refStreetName; - } - } - } - return MISSING_TAG; // nothing found - }*/ - if (!TagUtils.hasAddrStreetTag(osmObject)) { - return MISSING_TAG; - } else { - String sName = TagUtils.getAddrStreetValue(osmObject); - if (!StringUtils.isNullOrEmpty(sName)) { - return sName; + + if (!osmObject.hasKey(tag)) { + // object does not have this tag -> check for guess + if (hasGuessedValue(tag)) { + return "*" + getGuessedValue(tag); } else { + // give up return MISSING_TAG; } + } else { // get existing tag value + String val = osmObject.get(tag); + if (StringUtils.isNullOrEmpty(val)) { + // empty value -> check for guess + if (hasGuessedValue(tag)) { + return "*" + getGuessedValue(tag); + } else { + // tag is empty and no guess available -> give up + return MISSING_TAG; + } + } else { + // ok, return existing tag value + return val; + } } } @@ -88,5 +102,5 @@ */ public String getGuessedStreetName() { - return guessedStreetName; + return getGuessedValue(TagUtils.ADDR_STREET_TAG); } @@ -95,12 +109,62 @@ */ public void setGuessedStreetName(String guessedStreetName) { - this.guessedStreetName = guessedStreetName; - //fireEntityChanged(this); - } - + setGuessedValue(TagUtils.ADDR_STREET_TAG, guessedStreetName); + } + + /** + * Checks for a guessed street name. + * + * @return true, if this instance has a guessed street name. + */ public boolean hasGuessedStreetName() { - return !StringUtils.isNullOrEmpty(guessedStreetName); - } - + return hasGuessedValue(TagUtils.ADDR_STREET_TAG); + } + + /** + * @return the guessedPostCode + */ + public String getGuessedPostCode() { + return getGuessedValue(TagUtils.ADDR_POSTCODE_TAG); + } + + /** + * @param guessedPostCode the guessedPostCode to set + */ + public void setGuessedPostCode(String guessedPostCode) { + setGuessedValue(TagUtils.ADDR_POSTCODE_TAG, guessedPostCode); + } + + /** + * Checks for a guessed post code. + * + * @return true, if this instance has a guessed post code. + */ + public boolean hasGuessedPostCode() { + return hasGuessedValue(TagUtils.ADDR_POSTCODE_TAG); + } + + /** + * @return the guessedCity + */ + public String getGuessedCity() { + return getGuessedValue(TagUtils.ADDR_CITY_TAG); + } + + /** + * @param guessedCity the guessedCity to set + */ + public void setGuessedCity(String guessedCity) { + setGuessedValue(TagUtils.ADDR_CITY_TAG, guessedCity); + } + + /** + * Checks for a guessed city name. + * + * @return true, if this instance has a guessed city name. + */ + public boolean hasGuessedCity() { + return hasGuessedValue(TagUtils.ADDR_CITY_TAG); + } + /** * Returns true, if this instance has guesses regarding address tags. @@ -108,5 +172,5 @@ */ public boolean hasGuesses() { - return hasGuessedStreetName(); // to be extended later + return guessedValues.size() > 0; } @@ -115,5 +179,10 @@ */ public void applyAllGuesses() { - if (hasGuessedStreetName()) applyGuessedStreet(); + for (String tag : guessedValues.keySet()) { + String val = guessedValues.get(tag); + if (!StringUtils.isNullOrEmpty(val)) { + setOSMTag(tag, val); + } + } } @@ -123,8 +192,14 @@ */ public String getPostCode() { - if (!TagUtils.hasAddrPostcodeTag(osmObject)) { - return MISSING_TAG; - } - return TagUtils.getAddrPostcodeValue(osmObject); + return getTagValueWithGuess(TagUtils.ADDR_POSTCODE_TAG); + } + + /** + * Checks for post code tag. + * + * @return true, if successful + */ + public boolean hasPostCode() { + return TagUtils.hasAddrPostcodeTag(osmObject); } @@ -145,8 +220,14 @@ */ public String getCity() { - if (!TagUtils.hasAddrCityTag(osmObject)) { - return MISSING_TAG; - } - return TagUtils.getAddrCityValue(osmObject); + return getTagValueWithGuess(TagUtils.ADDR_CITY_TAG); + } + + /** + * Checks for city tag. + * + * @return true, if successful + */ + public boolean hasCity() { + return TagUtils.hasAddrCityTag(osmObject); } @@ -245,11 +326,51 @@ /** - * Applies the guessed street name to the addr:street tag value. - */ - public void applyGuessedStreet() { - if (hasGuessedStreetName()) { - setOSMTag(TagUtils.ADDR_STREET_TAG, guessedStreetName); - guessedStreetName = null; - } + * Gets the guessed value for the given tag. + * @param tag The tag to get the guessed value for. + * @return + */ + public String getGuessedValue(String tag) { + if (!hasGuessedValue(tag)) { + return null; + } + return guessedValues.get(tag); + } + + /** + * Check if this instance needs guessed values. This is the case, if the underlying OSM node + * has either no street name, post code or city. + * + * @return true, if successful + */ + public boolean needsGuess() { + return !hasStreetName() || !hasCity() || !hasPostCode(); + } + + /** + * Clears all guessed values. + */ + public void clearAllGuesses() { + guessedValues.clear(); + } + + /** + * Checks if given tag has a guessed value (tag exists and has a non-empty value). + * + * @param tag the tag + * @return true, if tag has a guessed value. + */ + private boolean hasGuessedValue(String tag) { + return guessedValues.containsKey(tag) && + !StringUtils.isNullOrEmpty(guessedValues.get(tag)); + } + + /** + * Sets the guessed value with the given tag. + * + * @param tag the tag to set the guess for + * @param value the value of the guessed tag. + */ + public void setGuessedValue(String tag, String value) { + guessedValues.put(tag, value); } Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/GuessedValueHandler.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/GuessedValueHandler.java (revision 24018) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/GuessedValueHandler.java (revision 24018) @@ -0,0 +1,170 @@ +/* + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ +package org.openstreetmap.josm.plugins.fixAddresses; + +import org.openstreetmap.josm.data.osm.Changeset; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.Relation; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.data.osm.visitor.Visitor; + +/** + * GuessedValueHandler visits all nodes and ways in order to find a guessed value for a given tag. + * The guess is determined by finding the closest way/node with the given tag. If no appropriate node + * is found within maximum distance, no guess is made. + + */ +public class GuessedValueHandler implements Visitor { + + /** Default maximum distance (100m) */ + private static final double DEFAULT_MAX_DIST = 100.0; + + private String tag; + protected double minDist; + protected String currentValue; + private AddressNode aNode; + private double maxDist = DEFAULT_MAX_DIST; + + /** + * Instantiates a new guessed value handler. + * + * @param tag the tag to find the guessed value for. + * @param aNode the address node to guess the values for. + * @param maxDist the maximum distance for a node/way to be considered as guessed value. + */ + public GuessedValueHandler(String tag, AddressNode aNode) { + this(tag, aNode, DEFAULT_MAX_DIST); + } + + /** + * Instantiates a new guessed value handler. + * + * @param tag the tag to find the guessed value for. + * @param aNode the address node to guess the values for. + * @param maxDist the maximum distance for a node/way to be considered as guessed value. + */ + public GuessedValueHandler(String tag, AddressNode aNode, double maxDist) { + super(); + + if (StringUtils.isNullOrEmpty(tag)) { + throw new RuntimeException("Tag must not be empty or null!"); + } + + if (aNode == null) { + throw new RuntimeException("Address node must not be null!"); + } + + if (maxDist < 1.0) { // clip value + maxDist = 1.0; + } + this.tag = tag; + + minDist = Double.MAX_VALUE; + this.aNode = aNode; + this.maxDist = maxDist; + } + + /** + * Gets the address node to make the guess for. + * + * @return the aNode + */ + protected AddressNode getAddressNode() { + return aNode; + } + + /** + * Gets the max distance allowed to consider a node as guess. + * If the distance of the node is greater than maxDist, the + * node/way will be ignored. + * + * @return the maxDist + */ + protected double getMaxDistance() { + return maxDist; + } + + /** + * Gets the tag name to use as guess. + * + * @return the tag + */ + protected String getTag() { + return tag; + } + + /** + * Gets the distance of the node/way which has been used for the guessed value. + * + * @return the minDist + */ + protected double getMinimumDist() { + return minDist; + } + + /** + * Gets the current guessed value or null, if no guess has been possible (so far). + * + * @return the currentValue + */ + protected String getCurrentValue() { + return currentValue; + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Node) + */ + @Override + public void visit(Node n) { + if (n.hasKey(tag)) { + double dist = n.getCoor().greatCircleDistance(aNode.getCoor()); + if (dist < minDist && dist < maxDist) { + minDist = dist; + currentValue = n.get(tag); + aNode.setGuessedValue(tag, currentValue); + } + } + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Way) + */ + @Override + public void visit(Way w) { + if (w.hasKey(tag)) { + double dist = OsmUtils.getMinimumDistanceToWay(aNode.getCoor(), w); + if (dist < minDist && dist < maxDist) { + minDist = dist; + currentValue = w.get(tag); + aNode.setGuessedValue(tag, currentValue); + } + } + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Relation) + */ + @Override + public void visit(Relation e) { + // nothing to do (yet) + } + + /* (non-Javadoc) + * @see org.openstreetmap.josm.data.osm.visitor.Visitor#visit(org.openstreetmap.josm.data.osm.Changeset) + */ + @Override + public void visit(Changeset cs) { + // nothing to do (yet) + } +} Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/OsmUtils.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/OsmUtils.java (revision 24018) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/OsmUtils.java (revision 24018) @@ -0,0 +1,86 @@ +/* + * This program is free software: you can redistribute it and/or modify it under + * the terms of the GNU General Public License as published by the + * Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; + * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along with this program. + * If not, see . + */ +package org.openstreetmap.josm.plugins.fixAddresses; + +import java.util.List; + +import org.openstreetmap.josm.data.coor.LatLon; +import org.openstreetmap.josm.data.osm.Node; +import org.openstreetmap.josm.data.osm.Way; +import org.openstreetmap.josm.tools.Pair; + +/** + * The Class OsmUtils provides some utilities not provided by the OSM data framework. + */ +public class OsmUtils { + private OsmUtils() {} + + /** + * Gets the minimum distance of single coordinate to a way. + * + * @param coor the coordinate to get the minimum distance for. + * @param w the w the way to compare against + * @return the minimum distance between the given coordinate and the way + */ + public static double getMinimumDistanceToWay(LatLon coor, Way w) { + if (coor == null || w == null) return Double.POSITIVE_INFINITY; + + double minDist = Double.MAX_VALUE; + List> x = w.getNodePairs(true); + + for (Pair pair : x) { + LatLon ap = pair.a.getCoor(); + LatLon bp = pair.b.getCoor(); + + double dist = findMinimum(ap, bp, coor); + if (dist < minDist) { + minDist = dist; + } + } + return minDist; + } + + /** + * Find the minimum distance between a point and two way coordinates recursively. + * + * @param a the a the first way point coordinate + * @param b the b the second way point coordinate + * @param c the c the node coordinate + * @return the double the minimum distance in m of the way and the node + */ + private static double findMinimum(LatLon a, LatLon b, LatLon c) { + LatLon mid = new LatLon((a.lat() + b.lat()) / 2, (a.lon() + b.lon()) / 2); + + double ac = a.greatCircleDistance(c); + double bc = b.greatCircleDistance(c); + double mc = mid.greatCircleDistance(c); + + double min = Math.min(Math.min(ac, mc), bc); + + if (min < 5.0) { // close enough? + return min; + } + + if (mc < ac && mc < bc) { + // mid point has lower distance than a and b + if (ac > bc) { // recurse + return findMinimum(b, mid, c); + } else { + return findMinimum(a, mid, c); + } + } else { // mid point is not closer than a or b + return Math.min(ac, bc); + } + } +} Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/TagUtils.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/TagUtils.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/TagUtils.java (revision 24018) @@ -24,4 +24,5 @@ */ public final class TagUtils { + /** * Checks if the given OSM primitive is an address node. @@ -1072,4 +1073,26 @@ public static String getAddrHousenumberValue(OsmPrimitive osmPrimitive) { return osmPrimitive != null ? osmPrimitive.get(ADDR_HOUSENUMBER_TAG) + : null; + } + + /** + * Check if OSM primitive has a tag 'addr:housename'. + * + * @param osmPrimitive + * The OSM entity to check. + */ + public static boolean hasAddrHousenameTag(OsmPrimitive osmPrimitive) { + return osmPrimitive != null ? osmPrimitive.hasKey(ADDR_HOUSENAME_TAG) + : false; + } + + /** + * Gets the value of tag 'addr:housename'. + * + * @param osmPrimitive + * The OSM entity to check. + */ + public static String getAddrHousenameValue(OsmPrimitive osmPrimitive) { + return osmPrimitive != null ? osmPrimitive.get(ADDR_HOUSENAME_TAG) : null; } @@ -1944,3 +1967,4 @@ public static final String WHITEWATER_TAG = "whitewater"; public static final String EMBANKMENT_TAG = "embankment"; + public static final String ADDR_HOUSENAME_TAG = "addr:housename"; } Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditDialog.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditDialog.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/AddressEditDialog.java (revision 24018) @@ -130,5 +130,5 @@ unresolvedTable.getSelectionModel().addListSelectionListener(this); unresolvedTable.getSelectionModel().addListSelectionListener(new IncompleteAddressListener()); - unresolvedTable.addMouseListener(new IncompleteAddressesMouseListener()); + unresolvedTable.addMouseListener(applyAllGuessesAction); JScrollPane scroll2 = new JScrollPane(unresolvedTable); Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/ApplyAllGuessesAction.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/ApplyAllGuessesAction.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/ApplyAllGuessesAction.java (revision 24018) @@ -16,9 +16,15 @@ import static org.openstreetmap.josm.tools.I18n.tr; +import java.awt.Point; +import java.awt.event.MouseEvent; +import java.awt.event.MouseListener; import java.util.ArrayList; import java.util.List; +import javax.swing.JTable; + import org.openstreetmap.josm.plugins.fixAddresses.AddressEditContainer; import org.openstreetmap.josm.plugins.fixAddresses.AddressNode; +import org.openstreetmap.josm.plugins.fixAddresses.INodeEntity; /** @@ -29,5 +35,5 @@ @SuppressWarnings("serial") -public class ApplyAllGuessesAction extends AbstractAddressEditAction { +public class ApplyAllGuessesAction extends AbstractAddressEditAction implements MouseListener{ public ApplyAllGuessesAction() { @@ -72,3 +78,50 @@ applyGuesses(addrToFix); } + + @Override + public void mouseClicked(MouseEvent e) { + JTable table = (JTable)e.getSource(); + Point p = e.getPoint(); + if(e.getClickCount() == 2) { + AddressEditTableModel model = (AddressEditTableModel) table.getModel(); + if (model != null) { + int row = table.rowAtPoint(p); + INodeEntity node = model.getEntityOfRow(row); + if (node instanceof AddressNode) { + beginTransaction(tr("Applied guessed values for ") + node.getOsmObject()); + beginObjectTransaction(node); + AddressNode aNode = (AddressNode) node; + if (aNode.hasGuessedStreetName()) { + aNode.applyAllGuesses(); + } + finishObjectTransaction(node); + finishTransaction(); + } + } + } + } + + @Override + public void mouseEntered(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseExited(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void mousePressed(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseReleased(MouseEvent arg0) { + // TODO Auto-generated method stub + + } } Index: plications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/IncompleteAddressesMouseListener.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/IncompleteAddressesMouseListener.java (revision 24017) +++ (revision ) @@ -1,70 +1,0 @@ -/* - * This program is free software: you can redistribute it and/or modify it under - * the terms of the GNU General Public License as published by the - * Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; - * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - * See the GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along with this program. - * If not, see . - */ -package org.openstreetmap.josm.plugins.fixAddresses.gui; - -import java.awt.Point; -import java.awt.event.MouseEvent; -import java.awt.event.MouseListener; - -import javax.swing.JTable; - -import org.openstreetmap.josm.plugins.fixAddresses.AddressNode; -import org.openstreetmap.josm.plugins.fixAddresses.INodeEntity; - -public class IncompleteAddressesMouseListener implements MouseListener { - - @Override - public void mouseClicked(MouseEvent e) { - JTable table = (JTable)e.getSource(); - Point p = e.getPoint(); - if(e.getClickCount() == 2) { - AddressEditTableModel model = (AddressEditTableModel) table.getModel(); - if (model != null) { - int row = table.rowAtPoint(p); - INodeEntity node = model.getEntityOfRow(row); - if (node instanceof AddressNode) { - AddressNode aNode = (AddressNode) node; - if (aNode.hasGuessedStreetName()) { - aNode.applyGuessedStreet(); - } - } - } - } - } - - @Override - public void mouseEntered(MouseEvent arg0) { - // TODO Auto-generated method stub - - } - - @Override - public void mouseExited(MouseEvent arg0) { - // TODO Auto-generated method stub - - } - - @Override - public void mousePressed(MouseEvent arg0) { - // TODO Auto-generated method stub - - } - - @Override - public void mouseReleased(MouseEvent arg0) { - // TODO Auto-generated method stub - - } - -} Index: /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/UnresolvedAddressesTableModel.java =================================================================== --- /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/UnresolvedAddressesTableModel.java (revision 24017) +++ /applications/editors/josm/plugins/FixAddresses/src/org/openstreetmap/josm/plugins/fixAddresses/gui/UnresolvedAddressesTableModel.java (revision 24018) @@ -34,4 +34,6 @@ import org.openstreetmap.josm.plugins.fixAddresses.AddressNode; import org.openstreetmap.josm.plugins.fixAddresses.INodeEntity; +import org.openstreetmap.josm.plugins.fixAddresses.StringUtils; +import org.openstreetmap.josm.plugins.fixAddresses.TagUtils; /** @@ -102,11 +104,5 @@ switch (column) { case 0: - String guessed = aNode.getGuessedStreetName(); - String cur = aNode.getStreetName(); - if (aNode.hasGuessedStreetName() && AddressNode.MISSING_TAG.equals(cur)) { - return "*" + guessed; - } else { - return aNode.getStreetName(); - } + return aNode.getStreetName(); case 1: return aNode.getHouseNumber(); @@ -116,5 +112,10 @@ return aNode.getPostCode(); case 4: - return aNode.getName(); + String name = aNode.getName(); + if (!StringUtils.isNullOrEmpty(name)) { + // TODO: Provide a getter/setter for this? + return TagUtils.getAddrHousenameValue(aNode.getOsmObject()); + } + return ""; default: throw new RuntimeException("Invalid column index: " + column);