lastSelection;
+
+ /**
+ * Constructor
+ */
+ public CheckAction(LicenseChangePlugin plugin)
+ {
+ super(tr("License Check"), "licensechange", tr("Performs the license check"),
+ Shortcut.registerShortcut("tools:licensechange", tr("Tool: {0}", tr("License Check")), KeyEvent.VK_C, Shortcut.GROUP_EDIT, Shortcut.SHIFT_DEFAULT), true);
+ this.plugin = plugin;
+ }
+
+ public void actionPerformed(ActionEvent ev)
+ {
+ doCheck(ev);
+ }
+
+ /**
+ * Does the validation.
+ *
+ *
+ * @param ev The event
+ */
+ public void doCheck(ActionEvent ev)
+ {
+ if (plugin.validateAction == null || Main.map == null || !Main.map.isVisible())
+ return;
+
+ plugin.initializeProblemLayer();
+
+ Collection selection;
+ selection = Main.main.getCurrentDataSet().getSelected();
+ if (selection.isEmpty())
+ {
+ selection = Main.main.getCurrentDataSet().allNonDeletedPrimitives();
+ lastSelection = null;
+ }
+ else
+ {
+ AggregatePrimitivesVisitor v = new AggregatePrimitivesVisitor();
+ selection = v.visit(selection);
+ lastSelection = selection;
+ }
+
+ CheckTask task = new CheckTask(selection, lastSelection);
+ Main.worker.submit(task);
+ }
+
+ @Override
+ public void updateEnabledState()
+ {
+ setEnabled(getEditLayer() != null);
+ }
+
+ class CheckTask extends PleaseWaitRunnable
+ {
+ private Check licenseCheck;
+ private Collection validatedPrimitives;
+ private Collection formerValidatedPrimitives;
+ private boolean cancelled;
+ private List problems;
+
+ /**
+ *
+ * @param validatedPrimitives the collection of primitives to validate.
+ * @param formerValidatedPrimitives the last collection of primitives being validates. May be null.
+ */
+ public CheckTask(Collection validatedPrimitives, Collection formerValidatedPrimitives)
+ {
+ super(tr("Loading from Quick History Service"), false /*don't ignore exceptions */);
+ this.validatedPrimitives = validatedPrimitives;
+ this.formerValidatedPrimitives = formerValidatedPrimitives;
+ this.licenseCheck = new BasicLicenseCheck(plugin);
+ }
+
+ @Override
+ protected void cancel()
+ {
+ this.cancelled = true;
+ }
+
+ @Override
+ protected void finish()
+ {
+ if (cancelled) return;
+
+ // update GUI on Swing EDT
+ //
+ Runnable r = new Runnable() {
+ public void run() {
+ plugin.validationDialog.tree.setErrors(problems);
+ plugin.validationDialog.setVisible(true);
+ Main.main.getCurrentDataSet().fireSelectionChanged();
+ }
+ };
+ if (SwingUtilities.isEventDispatchThread())
+ {
+ r.run();
+ }
+ else
+ {
+ SwingUtilities.invokeLater(r);
+ }
+ }
+
+ @Override
+ protected void realRun() throws SAXException, IOException,
+ OsmTransferException
+ {
+ plugin.loadDataFromQuickHistoryService(validatedPrimitives);
+ problems = new ArrayList(200);
+ getProgressMonitor().setTicksCount(validatedPrimitives.size());
+ int testCounter = 0;
+ getProgressMonitor().setCustomText(tr("Analyzing"));
+ licenseCheck.startCheck(getProgressMonitor().createSubTaskMonitor(validatedPrimitives.size(), false));
+ licenseCheck.visit(validatedPrimitives);
+ licenseCheck.endCheck();
+ problems.addAll(licenseCheck.getProblems());
+ }
+ }
+}
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeDialog.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeDialog.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeDialog.java (revision 25955)
@@ -0,0 +1,327 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import static org.openstreetmap.josm.tools.I18n.marktr;
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.BorderLayout;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JPopupMenu;
+import javax.swing.JScrollPane;
+import javax.swing.SwingUtilities;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.TreePath;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.AutoScaleAction;
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.data.SelectionChangedListener;
+import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
+import org.openstreetmap.josm.gui.PleaseWaitRunnable;
+import org.openstreetmap.josm.gui.SideButton;
+import org.openstreetmap.josm.gui.dialogs.ToggleDialog;
+import org.openstreetmap.josm.gui.progress.ProgressMonitor;
+import org.openstreetmap.josm.io.OsmTransferException;
+import org.openstreetmap.josm.tools.Shortcut;
+import org.xml.sax.SAXException;
+
+/**
+ * A small tool dialog for displaying the current problems. The selection manager
+ * respects clicks into the selection list. Ctrl-click will remove entries from
+ * the list while single click will make the clicked entry the only selection.
+ */
+public class LicenseChangeDialog extends ToggleDialog implements ActionListener, SelectionChangedListener {
+ private LicenseChangePlugin plugin;
+
+ /** The display tree */
+ protected ProblemTreePanel tree;
+
+ private SideButton selectButton;
+ /** The select button */
+
+ private JPopupMenu popupMenu;
+ private LicenseProblem popupMenuError = null;
+
+ /** Last selected element */
+ private DefaultMutableTreeNode lastSelectedNode = null;
+
+ /**
+ * Constructor
+ */
+ public LicenseChangeDialog(LicenseChangePlugin plugin)
+ {
+ super(tr("Relicensing problems"), "licensechange", tr("Open the relicensing window."),
+ Shortcut.registerShortcut("subwindow:licensechange", tr("Toggle: {0}", tr("Relicensing problems")),
+ KeyEvent.VK_V, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 150);
+
+ this.plugin = plugin;
+ popupMenu = new JPopupMenu();
+
+ JMenuItem zoomTo = new JMenuItem(tr("Zoom to problem"));
+ zoomTo.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ zoomToProblem();
+ }
+ });
+ popupMenu.add(zoomTo);
+
+ tree = new ProblemTreePanel();
+ tree.addMouseListener(new ClickWatch());
+ tree.addTreeSelectionListener(new SelectionWatch());
+
+ add(new JScrollPane(tree), BorderLayout.CENTER);
+
+ JPanel buttonPanel = new JPanel(new GridLayout(1, 3));
+
+ selectButton = new SideButton(marktr("Select"), "select", "LicenseChange",
+ tr("Set the selected elements on the map to the selected items in the list above."), this);
+ selectButton.setEnabled(false);
+ buttonPanel.add(selectButton);
+ buttonPanel.add(new SideButton(plugin.validateAction), "refresh");
+ add(buttonPanel, BorderLayout.SOUTH);
+
+ }
+
+ @Override
+ public void showNotify()
+ {
+ DataSet.addSelectionListener(this);
+ DataSet ds = Main.main.getCurrentDataSet();
+ if (ds != null) {
+ updateSelection(ds.getSelected());
+ }
+ }
+
+ @Override
+ public void hideNotify()
+ {
+ DataSet.removeSelectionListener(this);
+ }
+
+ @Override
+ public void setVisible(boolean v)
+ {
+ if (tree != null)
+ tree.setVisible(v);
+ super.setVisible(v);
+ Main.map.repaint();
+ }
+
+ @SuppressWarnings("unchecked")
+ private void showPopupMenu(MouseEvent e)
+ {
+ if (!e.isPopupTrigger())
+ return;
+ popupMenuError = null;
+ TreePath selPath = tree.getPathForLocation(e.getX(), e.getY());
+ if (selPath == null)
+ return;
+ DefaultMutableTreeNode node = (DefaultMutableTreeNode) selPath.getPathComponent(selPath.getPathCount() - 1);
+ if (!(node.getUserObject() instanceof LicenseProblem))
+ return;
+ popupMenuError = (LicenseProblem) node.getUserObject();
+ popupMenu.show(e.getComponent(), e.getX(), e.getY());
+ }
+
+ private void zoomToProblem()
+ {
+ if (popupMenuError == null)
+ return;
+ LicenseChangeBoundingXYVisitor bbox = new LicenseChangeBoundingXYVisitor();
+ popupMenuError.visitHighlighted(bbox);
+ if (bbox.getBounds() == null)
+ return;
+ bbox.enlargeBoundingBox();
+ Main.map.mapView.recalculateCenterScale(bbox);
+ }
+
+ /**
+ * Sets the selection of the map to the current selected items.
+ */
+ @SuppressWarnings("unchecked")
+ private void setSelectedItems()
+ {
+ if (tree == null)
+ return;
+
+ Collection sel = new HashSet(40);
+
+ TreePath[] selectedPaths = tree.getSelectionPaths();
+ if (selectedPaths == null)
+ return;
+
+ for (TreePath path : selectedPaths) {
+ DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
+ Enumeration children = node.breadthFirstEnumeration();
+ while (children.hasMoreElements()) {
+ DefaultMutableTreeNode childNode = children.nextElement();
+ Object nodeInfo = childNode.getUserObject();
+ if (nodeInfo instanceof LicenseProblem) {
+ LicenseProblem error = (LicenseProblem) nodeInfo;
+ sel.addAll(error.getPrimitives());
+ }
+ }
+ }
+
+ Main.main.getCurrentDataSet().setSelected(sel);
+ }
+
+ public void actionPerformed(ActionEvent e)
+ {
+ String actionCommand = e.getActionCommand();
+ if (actionCommand.equals("Select"))
+ setSelectedItems();
+ }
+
+ /**
+ * @param sel
+ * The collection where to add all selected elements
+ * @param addSelected
+ * if true, add all selected elements to collection
+ */
+ @SuppressWarnings("unchecked")
+ private void setSelection(Collection sel, boolean addSelected) {
+
+ DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
+ if (lastSelectedNode != null && !lastSelectedNode.equals(node)) {
+ Enumeration children = lastSelectedNode.breadthFirstEnumeration();
+ while (children.hasMoreElements()) {
+ DefaultMutableTreeNode childNode = children.nextElement();
+ Object nodeInfo = childNode.getUserObject();
+ if (nodeInfo instanceof LicenseProblem) {
+ LicenseProblem error = (LicenseProblem) nodeInfo;
+ error.setSelected(false);
+ }
+ }
+ }
+
+ lastSelectedNode = node;
+ if (node == null) return;
+
+ Enumeration children = node.breadthFirstEnumeration();
+ while (children.hasMoreElements()) {
+ DefaultMutableTreeNode childNode = children.nextElement();
+ Object nodeInfo = childNode.getUserObject();
+ if (nodeInfo instanceof LicenseProblem) {
+ LicenseProblem error = (LicenseProblem) nodeInfo;
+ error.setSelected(true);
+
+ if (addSelected) {
+ sel.addAll(error.getPrimitives());
+ }
+ }
+ }
+ selectButton.setEnabled(true);
+ }
+
+ /**
+ * Watches for clicks.
+ */
+ public class ClickWatch extends MouseAdapter
+ {
+ @Override
+ public void mouseClicked(MouseEvent e) {
+ selectButton.setEnabled(false);
+
+ boolean isDblClick = e.getClickCount() > 1;
+
+ Collection sel = isDblClick ? new HashSet(40) : null;
+
+ setSelection(sel, isDblClick);
+
+ if (isDblClick) {
+ Main.main.getCurrentDataSet().setSelected(sel);
+ if(Main.pref.getBoolean("licensechange.autozoom", false))
+ AutoScaleAction.zoomTo(sel);
+ }
+ }
+
+ @Override
+ public void mousePressed(MouseEvent e) {
+ showPopupMenu(e);
+ }
+
+ @Override
+ public void mouseReleased(MouseEvent e) {
+ showPopupMenu(e);
+ }
+
+ }
+
+ /**
+ * Watches for tree selection.
+ */
+ public class SelectionWatch implements TreeSelectionListener
+ {
+ public void valueChanged(TreeSelectionEvent e) {
+ selectButton.setEnabled(false);
+
+ if (e.getSource() instanceof JScrollPane) {
+ System.out.println(e.getSource());
+ return;
+ }
+
+ setSelection(null, false);
+ Main.map.repaint();
+ }
+ }
+
+ public static class LicenseChangeBoundingXYVisitor extends BoundingXYVisitor implements LicenseChangeVisitor
+ {
+ public void visit(OsmPrimitive p) {
+ if (p.isUsable()) {
+ p.visit(this);
+ }
+ }
+
+ public void visit(WaySegment ws) {
+ if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
+ return;
+ visit(ws.way.getNodes().get(ws.lowerIndex));
+ visit(ws.way.getNodes().get(ws.lowerIndex + 1));
+ }
+
+ public void visit(List nodes) {
+ for (Node n: nodes) {
+ visit(n);
+ }
+ }
+ }
+
+ public void updateSelection(Collection newSelection)
+ {
+ if (newSelection.isEmpty())
+ tree.setFilter(null);
+ HashSet filter = new HashSet(newSelection);
+ tree.setFilter(filter);
+ }
+
+ public void selectionChanged(Collection newSelection)
+ {
+ updateSelection(newSelection);
+ }
+}
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangePlugin.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangePlugin.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangePlugin.java (revision 25955)
@@ -0,0 +1,270 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.OutputStream;
+import java.io.BufferedWriter;
+
+import javax.swing.JOptionPane;
+
+import org.xml.sax.helpers.DefaultHandler;
+import org.xml.sax.Attributes;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import javax.xml.parsers.SAXParserFactory;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.UploadAction;
+import org.openstreetmap.josm.data.osm.*;
+import org.openstreetmap.josm.data.osm.visitor.Visitor;
+import org.openstreetmap.josm.data.projection.Epsg4326;
+import org.openstreetmap.josm.data.projection.Lambert;
+import org.openstreetmap.josm.data.projection.Mercator;
+import org.openstreetmap.josm.gui.MapFrame;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
+import org.openstreetmap.josm.gui.layer.Layer;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.preferences.PreferenceSetting;
+import org.openstreetmap.josm.plugins.Plugin;
+import org.openstreetmap.josm.plugins.PluginInformation;
+
+/**
+ *
+ * Plugin that highlights data with unclear re-licensing status
+ *
+ * @author Frederik Ramm
+ * based on old Validator plugin by Francisco R. Santos and Dirk Stoecker
+ */
+public class LicenseChangePlugin extends Plugin implements LayerChangeListener
+{
+
+ protected static ProblemLayer problemLayer = null;
+
+ /** The validate action */
+ CheckAction validateAction = new CheckAction(this);
+
+ /** The validation dialog */
+ LicenseChangeDialog validationDialog;
+
+ /** The list of errors per layer*/
+ Map> layerProblems = new HashMap>();
+
+ /** Database of users who have edited something. */
+ private final Map> nodeUsers = new HashMap>();
+ private final Map> wayUsers = new HashMap>();
+ private final Map> relationUsers = new HashMap>();
+
+ public List getUsers(Node n) { return nodeUsers.get(n.getId()); }
+ public List getUsers(Way n) { return wayUsers.get(n.getId()); }
+ public List getUsers(Relation n) { return relationUsers.get(n.getId()); }
+
+ /**
+ * Creates the plugin
+ */
+ public LicenseChangePlugin(PluginInformation info)
+ {
+ super(info);
+ }
+
+ @Override
+ public void mapFrameInitialized(MapFrame oldFrame, MapFrame newFrame)
+ {
+ if (newFrame != null)
+ {
+ validationDialog = new LicenseChangeDialog(this);
+ newFrame.addToggleDialog(validationDialog);
+ initializeProblemLayer();
+ MapView.addLayerChangeListener(this);
+ }
+ else
+ {
+ MapView.removeLayerChangeListener(this);
+ }
+ }
+
+ public void initializeProblemLayer()
+ {
+ if (problemLayer == null)
+ {
+ problemLayer = new ProblemLayer(this);
+ Main.main.addLayer(problemLayer);
+ }
+ }
+
+ /* -------------------------------------------------------------------------- */
+ /* interface LayerChangeListener */
+ /* -------------------------------------------------------------------------- */
+
+ public void activeLayerChange(Layer oldLayer, Layer newLayer)
+ {
+ if (newLayer instanceof OsmDataLayer) {
+ List errors = layerProblems.get(newLayer);
+ validationDialog.tree.setErrorList(errors);
+ Main.map.repaint();
+ }
+ }
+
+ public void layerAdded(Layer newLayer)
+ {
+ if (newLayer instanceof OsmDataLayer) {
+ layerProblems.put(newLayer, new ArrayList());
+ }
+ }
+
+ public void layerRemoved(Layer oldLayer)
+ {
+ if (oldLayer == problemLayer) {
+ problemLayer = null;
+ return;
+ }
+ layerProblems.remove(oldLayer);
+ if (Main.map.mapView.getLayersOfType(OsmDataLayer.class).isEmpty()) {
+ if (problemLayer != null) {
+ Main.map.mapView.removeLayer(problemLayer);
+ }
+ }
+ }
+
+ private class QhsParser extends DefaultHandler
+ {
+ List theList = null;
+
+ @Override
+ public void startDocument() throws SAXException {
+ }
+
+ @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException
+ {
+ if ("node".equals(qName) || "way".equals(qName) || "relation".equals(qName))
+ {
+ Map> theMap = ("node".equals(qName)) ? nodeUsers : ("way".equals(qName)) ? wayUsers : relationUsers;
+ // we always overwrite a list that might already exist
+ theMap.put(Long.decode(atts.getValue("id")), theList = new ArrayList());
+ }
+ else if ("user".equals(qName))
+ {
+ String v = atts.getValue("version");
+ String i = atts.getValue("id");
+ String d = atts.getValue("decision");
+ User u = User.createOsmUser(Long.parseLong(i), null);
+ if ("first".equals(v)) theList.add(0, u); else theList.add(u);
+ u.setRelicensingStatus(
+ "undecided".equals(d) ? User.STATUS_UNDECIDED :
+ "auto".equals(d) ? User.STATUS_AUTO_AGREED :
+ "yes".equals(d) ? User.STATUS_AGREED :
+ "no".equals(d) ? User.STATUS_NOT_AGREED :
+ "anonymous".equals(d) ? User.STATUS_ANONYMOUS :
+ User.STATUS_UNKNOWN);
+ }
+ }
+ }
+
+ public void loadDataFromQuickHistoryService(Collection objectList)
+ {
+ final StringBuffer nodesToLoad = new StringBuffer();
+ final StringBuffer waysToLoad = new StringBuffer();
+ final StringBuffer relationsToLoad = new StringBuffer();
+
+ Visitor v = new Visitor() {
+ public void visit(Node n) {
+ if (!nodeUsers.containsKey(n.getId())) {
+ nodesToLoad.append(",");
+ nodesToLoad.append(n.getId());
+ }
+ }
+ public void visit(Way n) {
+ if (!wayUsers.containsKey(n.getId())) {
+ waysToLoad.append(",");
+ waysToLoad.append(n.getId());
+ }
+ }
+ public void visit(Relation n) {
+ if (!relationUsers.containsKey(n.getId())) {
+ relationsToLoad.append(",");
+ relationsToLoad.append(n.getId());
+ }
+ }
+ public void visit(Changeset c) {};
+ };
+
+ for (OsmPrimitive p : objectList) if (p.getId() > 0) p.visit(v);
+
+
+ if (nodesToLoad.length()==0 && waysToLoad.length()==0 && relationsToLoad.length()==0) return;
+
+ try {
+ URL qhs = new URL("http://wtfe.gryph.de/api/0.6/userlist");
+ HttpURLConnection activeConnection = (HttpURLConnection)qhs.openConnection();
+ activeConnection.setRequestMethod("POST");
+ activeConnection.setDoOutput(true);
+ activeConnection.setRequestProperty("Content-type", "text/xml");
+ OutputStream out = activeConnection.getOutputStream();
+ BufferedWriter bwr = new BufferedWriter(new OutputStreamWriter(out, "UTF-8"));
+ if (nodesToLoad.length() > 0)
+ {
+ bwr.write("&nodes=0");
+ bwr.write(nodesToLoad.toString());
+ }
+ if (waysToLoad.length() > 0)
+ {
+ bwr.write("&ways=0");
+ bwr.write(waysToLoad.toString());
+ }
+ if (relationsToLoad.length() > 0)
+ {
+ bwr.write("&relations=0");
+ bwr.write(relationsToLoad.toString());
+ }
+ bwr.flush();
+
+ activeConnection.connect();
+ System.out.println(activeConnection.getResponseMessage());
+ int retCode = activeConnection.getResponseCode();
+
+ InputStream i = null;
+ try {
+ i = activeConnection.getInputStream();
+ } catch (IOException ioe) {
+ i = activeConnection.getErrorStream();
+ }
+
+ StringBuffer responseBody = new StringBuffer();
+
+
+ if (i != null) {
+ InputSource inputSource = new InputSource(i);
+ SAXParserFactory.newInstance().newSAXParser().parse(inputSource, new QhsParser());
+ }
+
+ activeConnection.disconnect();
+ }
+ catch (Exception ex)
+ {
+ ex.printStackTrace();
+ }
+ }
+}
+
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeVisitor.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeVisitor.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseChangeVisitor.java (revision 25955)
@@ -0,0 +1,14 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import java.util.List;
+
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.WaySegment;
+
+public interface LicenseChangeVisitor {
+ void visit(OsmPrimitive p);
+ void visit(WaySegment ws);
+ void visit(List nodes);
+}
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseProblem.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseProblem.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/LicenseProblem.java (revision 25955)
@@ -0,0 +1,292 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Point;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.TreeSet;
+
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.data.osm.WaySegment;
+import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
+import org.openstreetmap.josm.gui.MapView;
+
+/**
+ */
+public class LicenseProblem
+{
+ /** Severity */
+ private Severity severity;
+ /** The problem message */
+ private String message;
+ /** The affected primitives */
+ private List primitives;
+ /** The primitives to be highlighted */
+ private List highlighted;
+ /** The tester that raised this error */
+ private Check tester;
+ /** Whether this is selected */
+ private boolean selected;
+
+ /**
+ * Constructors
+ * @param tester The tester
+ * @param severity The severity of this problem
+ * @param message The error message
+ * @param primitive The affected primitive
+ * @param primitives The affected primitives
+ */
+ public LicenseProblem(Check tester, Severity severity, String message, List primitives, List highlighted) {
+ this.tester = tester;
+ this.severity = severity;
+ this.message = message;
+ this.primitives = primitives;
+ this.highlighted = highlighted;
+ }
+
+ /**
+ * Gets the error message
+ * @return the error message
+ */
+ public String getMessage() {
+ return message;
+ }
+
+ /**
+ * Sets the error message
+ * @param message The error message
+ */
+ public void setMessage(String message) {
+ this.message = message;
+ }
+
+ /**
+ * Gets the list of primitives affected by this error
+ * @return the list of primitives affected by this error
+ */
+ public List getPrimitives() {
+ return primitives;
+ }
+
+ /**
+ * Sets the list of primitives affected by this error
+ * @param primitives the list of primitives affected by this error
+ */
+
+ public void setPrimitives(List primitives) {
+ this.primitives = primitives;
+ }
+
+ /**
+ * Gets the severity of this error
+ * @return the severity of this error
+ */
+ public Severity getSeverity() {
+ return severity;
+ }
+
+ /**
+ * Sets the severity of this error
+ * @param severity the severity of this error
+ */
+ public void setSeverity(Severity severity) {
+ this.severity = severity;
+ }
+
+
+ /**
+ * Gets the tester that raised this error
+ * @return the tester that raised this error
+ */
+ public Check getTester() {
+ return tester;
+ }
+
+ /**
+ * Paints the error on affected primitives
+ *
+ * @param g The graphics
+ * @param mv The MapView
+ */
+ public void paint(Graphics g, MapView mv) {
+ PaintVisitor v = new PaintVisitor(g, mv);
+ visitHighlighted(v);
+ }
+
+ @SuppressWarnings("unchecked")
+ public void visitHighlighted(LicenseChangeVisitor v) {
+ for (Object o : highlighted) {
+ if (o instanceof OsmPrimitive)
+ v.visit((OsmPrimitive) o);
+ else if (o instanceof WaySegment)
+ v.visit((WaySegment) o);
+ else if (o instanceof List) {
+ v.visit((List)o);
+ }
+ }
+ }
+
+ /**
+ * Visitor that highlights the primitives affected by this error
+ * @author frsantos
+ */
+ class PaintVisitor extends AbstractVisitor implements LicenseChangeVisitor {
+ /** The graphics */
+ private final Graphics g;
+ /** The MapView */
+ private final MapView mv;
+
+ /**
+ * Constructor
+ * @param g The graphics
+ * @param mv The Mapview
+ */
+ public PaintVisitor(Graphics g, MapView mv) {
+ this.g = g;
+ this.mv = mv;
+ }
+
+ public void visit(OsmPrimitive p) {
+ if (p.isUsable()) {
+ p.visit(this);
+ }
+ }
+
+ /**
+ * Draws a circle around the node
+ * @param n The node
+ * @param color The circle color
+ */
+ public void drawNode(Node n, Color color) {
+ Point p = mv.getPoint(n);
+ g.setColor(color);
+ if (selected) {
+ g.fillOval(p.x - 5, p.y - 5, 10, 10);
+ } else
+ g.drawOval(p.x - 5, p.y - 5, 10, 10);
+ }
+
+ public void drawSegment(Point p1, Point p2, Color color) {
+ g.setColor(color);
+
+ double t = Math.atan2(p2.x - p1.x, p2.y - p1.y);
+ double cosT = Math.cos(t);
+ double sinT = Math.sin(t);
+ int deg = (int) Math.toDegrees(t);
+ if (selected) {
+ int[] x = new int[] { (int) (p1.x + 5 * cosT), (int) (p2.x + 5 * cosT), (int) (p2.x - 5 * cosT),
+ (int) (p1.x - 5 * cosT) };
+ int[] y = new int[] { (int) (p1.y - 5 * sinT), (int) (p2.y - 5 * sinT), (int) (p2.y + 5 * sinT),
+ (int) (p1.y + 5 * sinT) };
+ g.fillPolygon(x, y, 4);
+ g.fillArc(p1.x - 5, p1.y - 5, 10, 10, deg, 180);
+ g.fillArc(p2.x - 5, p2.y - 5, 10, 10, deg, -180);
+ } else {
+ g.drawLine((int) (p1.x + 5 * cosT), (int) (p1.y - 5 * sinT), (int) (p2.x + 5 * cosT),
+ (int) (p2.y - 5 * sinT));
+ g.drawLine((int) (p1.x - 5 * cosT), (int) (p1.y + 5 * sinT), (int) (p2.x - 5 * cosT),
+ (int) (p2.y + 5 * sinT));
+ g.drawArc(p1.x - 5, p1.y - 5, 10, 10, deg, 180);
+ g.drawArc(p2.x - 5, p2.y - 5, 10, 10, deg, -180);
+ }
+ }
+
+ /**
+ * Draws a line around the segment
+ *
+ * @param s The segment
+ * @param color The color
+ */
+ public void drawSegment(Node n1, Node n2, Color color) {
+ drawSegment(mv.getPoint(n1), mv.getPoint(n2), color);
+ }
+
+ /**
+ * Draw a small rectangle.
+ * White if selected (as always) or red otherwise.
+ *
+ * @param n The node to draw.
+ */
+ public void visit(Node n) {
+ if (isNodeVisible(n))
+ drawNode(n, severity.getColor());
+ }
+
+ public void visit(Way w) {
+ visit(w.getNodes());
+ }
+
+ public void visit(WaySegment ws) {
+ if (ws.lowerIndex < 0 || ws.lowerIndex + 1 >= ws.way.getNodesCount())
+ return;
+ Node a = ws.way.getNodes().get(ws.lowerIndex), b = ws.way.getNodes().get(ws.lowerIndex + 1);
+ if (isSegmentVisible(a, b)) {
+ drawSegment(a, b, severity.getColor());
+ }
+ }
+
+ public void visit(Relation r) {
+ /* No idea how to draw a relation. */
+ }
+
+ /**
+ * Checks if the given node is in the visible area.
+ * @param n The node to check for visibility
+ * @return true if the node is visible
+ */
+ protected boolean isNodeVisible(Node n) {
+ Point p = mv.getPoint(n);
+ return !((p.x < 0) || (p.y < 0) || (p.x > mv.getWidth()) || (p.y > mv.getHeight()));
+ }
+
+ /**
+ * Checks if the given segment is in the visible area.
+ * NOTE: This will return true for a small number of non-visible
+ * segments.
+ * @param ls The segment to check
+ * @return true if the segment is visible
+ */
+ protected boolean isSegmentVisible(Node n1, Node n2) {
+ Point p1 = mv.getPoint(n1);
+ Point p2 = mv.getPoint(n2);
+ if ((p1.x < 0) && (p2.x < 0))
+ return false;
+ if ((p1.y < 0) && (p2.y < 0))
+ return false;
+ if ((p1.x > mv.getWidth()) && (p2.x > mv.getWidth()))
+ return false;
+ if ((p1.y > mv.getHeight()) && (p2.y > mv.getHeight()))
+ return false;
+ return true;
+ }
+
+ public void visit(List nodes) {
+ Node lastN = null;
+ for (Node n : nodes) {
+ if (lastN == null) {
+ lastN = n;
+ continue;
+ }
+ if (n.isDrawable() && isSegmentVisible(lastN, n)) {
+ drawSegment(lastN, n, severity.getColor());
+ }
+ lastN = n;
+ }
+ }
+ }
+
+ /**
+ * Sets the selection flag of this error
+ * @param selected if this error is selected
+ */
+ public void setSelected(boolean selected) {
+ this.selected = selected;
+ }
+}
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemLayer.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemLayer.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemLayer.java (revision 25955)
@@ -0,0 +1,174 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import java.awt.Graphics2D;
+import java.util.Enumeration;
+import java.util.List;
+
+import javax.swing.Action;
+import javax.swing.Icon;
+import javax.swing.tree.DefaultMutableTreeNode;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.RenameLayerAction;
+import org.openstreetmap.josm.data.Bounds;
+import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
+import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
+import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
+import org.openstreetmap.josm.gui.layer.Layer;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.plugins.licensechange.util.Bag;
+import org.openstreetmap.josm.tools.ImageProvider;
+
+/**
+ * A layer showing problem messages.
+ */
+public class ProblemLayer extends Layer implements LayerChangeListener
+{
+
+ private LicenseChangePlugin plugin;
+
+ private int updateCount = -1;
+
+
+ public ProblemLayer(LicenseChangePlugin plugin)
+ {
+ super(tr("Relicensing Problems"));
+ this.plugin = plugin;
+ MapView.addLayerChangeListener(this);
+ }
+
+ /**
+ * Return a static icon.
+ */
+ @Override
+ public Icon getIcon()
+ {
+ return ImageProvider.get("layer", "licensechange");
+ }
+
+ /**
+ * Draw all primitives in this layer but do not draw modified ones (they
+ * are drawn by the edit layer).
+ * Draw nodes last to overlap the ways they belong to.
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void paint(final Graphics2D g, final MapView mv, Bounds bounds)
+ {
+ updateCount = plugin.validationDialog.tree.getUpdateCount();
+ DefaultMutableTreeNode root = plugin.validationDialog.tree.getRoot();
+ if (root == null || root.getChildCount() == 0)
+ return;
+
+ DefaultMutableTreeNode severity = (DefaultMutableTreeNode) root.getLastChild();
+ while (severity != null)
+ {
+ Enumeration problemMessages = severity.breadthFirstEnumeration();
+ while (problemMessages.hasMoreElements())
+ {
+ Object tn = problemMessages.nextElement().getUserObject();
+ if (tn instanceof LicenseProblem)
+ ((LicenseProblem) tn).paint(g, mv);
+ }
+
+ // Severities in inverse order
+ severity = severity.getPreviousSibling();
+ }
+ }
+
+ @Override
+ public String getToolTipText()
+ {
+ Bag problemTree = new Bag();
+ List problems = plugin.validationDialog.tree.getErrors();
+ for (LicenseProblem e : problems) {
+ problemTree.add(e.getSeverity(), e);
+ }
+
+ StringBuilder b = new StringBuilder();
+ for (Severity s : Severity.values())
+ {
+ if (problemTree.containsKey(s))
+ b.append(tr(s.toString())).append(": ").append(problemTree.get(s).size()).append("
");
+ }
+
+ if (b.length() == 0)
+ return "" + tr("No relicensing problems") + "";
+ else
+ return "" + tr("Relicensing problems") + ":
" + b + "";
+ }
+
+ @Override
+ public void mergeFrom(Layer from)
+ {
+ }
+
+ @Override
+ public boolean isMergable(Layer other)
+ {
+ return false;
+ }
+
+ @Override
+ public boolean isChanged()
+ {
+ return updateCount != plugin.validationDialog.tree.getUpdateCount();
+ }
+
+ @Override
+ public void visitBoundingBox(BoundingXYVisitor v)
+ {
+ }
+
+ @Override
+ public Object getInfoComponent()
+ {
+ return getToolTipText();
+ }
+
+ @Override
+ public Action[] getMenuEntries()
+ {
+ return new Action[] {
+ LayerListDialog.getInstance().createShowHideLayerAction(),
+ LayerListDialog.getInstance().createDeleteLayerAction(),
+ SeparatorLayerAction.INSTANCE,
+ new RenameLayerAction(null, this),
+ SeparatorLayerAction.INSTANCE,
+ new LayerListPopup.InfoAction(this) };
+ }
+
+ @Override
+ public void destroy()
+ {
+ }
+
+ public void activeLayerChange(Layer oldLayer, Layer newLayer)
+ {
+ }
+
+ public void layerAdded(Layer newLayer)
+ {
+ }
+
+ /**
+ * If layer is the OSM Data layer, remove all problems
+ */
+ public void layerRemoved(Layer oldLayer)
+ {
+ if (oldLayer instanceof OsmDataLayer && Main.map.mapView.getEditLayer() == null)
+ {
+ Main.map.mapView.removeLayer(this);
+ }
+ else if (oldLayer == this)
+ {
+ MapView.removeLayerChangeListener(this);
+ LicenseChangePlugin.problemLayer = null;
+ }
+ }
+}
Index: applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemTreePanel.java
===================================================================
--- applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemTreePanel.java (revision 25955)
+++ applications/editors/josm/plugins/licensechange/src/org/openstreetmap/josm/plugins/licensechange/ProblemTreePanel.java (revision 25955)
@@ -0,0 +1,315 @@
+// License: GPL. See LICENSE file for details.
+package org.openstreetmap.josm.plugins.licensechange;
+
+import java.awt.event.MouseEvent;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.swing.JTree;
+import javax.swing.ToolTipManager;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeModel;
+import javax.swing.tree.TreePath;
+import javax.swing.tree.TreeSelectionModel;
+
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.plugins.licensechange.util.Bag;
+import org.openstreetmap.josm.data.validation.util.MultipleNameVisitor;
+
+/**
+ * A panel that displays the tree of license change problems.
+ */
+
+public class ProblemTreePanel extends JTree {
+
+ /**
+ * The validation data.
+ */
+ protected DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
+
+ /** The list of errors shown in the tree */
+ private List errors;
+
+ /**
+ * If {@link #filter} is not null only errors are displayed
+ * that refer to one of the primitives in the filter.
+ */
+ private Set filter = null;
+
+ private int updateCount;
+
+ /**
+ * Constructor
+ * @param errors The list of errors
+ */
+ public ProblemTreePanel(List errors) {
+ ToolTipManager.sharedInstance().registerComponent(this);
+ this.setModel(treeModel);
+ this.setRootVisible(false);
+ this.setShowsRootHandles(true);
+ this.expandRow(0);
+ this.setVisibleRowCount(8);
+ this.setCellRenderer(new ProblemTreeRenderer());
+ this.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
+ setErrorList(errors);
+ }
+
+ @Override
+ public String getToolTipText(MouseEvent e) {
+ String res = null;
+ TreePath path = getPathForLocation(e.getX(), e.getY());
+ if (path != null) {
+ DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
+ Object nodeInfo = node.getUserObject();
+
+ if (nodeInfo instanceof LicenseProblem) {
+ LicenseProblem error = (LicenseProblem) nodeInfo;
+ MultipleNameVisitor v = new MultipleNameVisitor();
+ v.visit(error.getPrimitives());
+ res = "" + v.getText() + "
" + error.getMessage();
+ res += "";
+ } else
+ res = node.toString();
+ }
+ return res;
+ }
+
+ /** Constructor */
+ public ProblemTreePanel() {
+ this(null);
+ }
+
+ @Override
+ public void setVisible(boolean v) {
+ if (v)
+ buildTree();
+ else
+ treeModel.setRoot(new DefaultMutableTreeNode());
+ super.setVisible(v);
+ }
+
+ /**
+ * Builds the errors tree
+ */
+ public void buildTree() {
+ updateCount++;
+ DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode();
+
+ if (errors == null || errors.isEmpty()) {
+ treeModel.setRoot(rootNode);
+ return;
+ }
+
+ // Remember the currently expanded rows
+ Set