Ignore:
Timestamp:
2008-10-28T19:28:52+01:00 (17 years ago)
Author:
stotz
Message:

Added filter for ErrorTreePanel for only displaying errors regarding selected elements of the OSM layer

Location:
applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ErrorTreePanel.java

    r10666 r11530  
    11package org.openstreetmap.josm.plugins.validator;
    22
     3import java.awt.event.MouseEvent;
    34import java.util.ArrayList;
    45import java.util.Collections;
    … …  
    78import java.util.HashSet;
    89import java.util.List;
     10import java.util.Map;
    911import java.util.Set;
    10 import java.util.Map;
    1112import java.util.Map.Entry;
    12 
    13 import java.awt.event.MouseEvent;
    1413
    1514import javax.swing.JTree;
    … …  
    2019import javax.swing.tree.TreeSelectionModel;
    2120
     21import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2222import org.openstreetmap.josm.plugins.validator.util.Bag;
    2323import org.openstreetmap.josm.plugins.validator.util.MultipleNameVisitor;
    … …  
    3131 */
    3232
    33 public class ErrorTreePanel extends JTree
    34 {
    35         /** Serializable ID */
    36         private static final long serialVersionUID = 2952292777351992696L;
    37 
    38         /**
    39          * The validation data.
    40          */
    41         protected DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
    42 
    43         /** The list of errors shown in the tree */
    44         private List<TestError> errors;
    45         /**
    46          * Constructor
    47          * @param errors The list of errors
    48          */
    49         public ErrorTreePanel(List<TestError> errors)
    50         {
    51                 ToolTipManager.sharedInstance().registerComponent(this);
    52                 this.setModel(treeModel);
    53                 this.setRootVisible(false);
    54                 this.setShowsRootHandles(true);
    55                 this.expandRow(0);
    56                 this.setVisibleRowCount(8);
    57                 this.setCellRenderer(new ErrorTreeRenderer());
    58                 this.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
    59                 setErrorList(errors);
    60         }
    61 
    62         public String getToolTipText(MouseEvent e) {
    63                 String res = null;
    64                 TreePath path = getPathForLocation(e.getX(), e.getY());
    65                 if (path != null)
    66                 {
    67                         DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
    68                         Object nodeInfo = node.getUserObject();
    69 
    70                         if (nodeInfo instanceof TestError)
    71                         {
    72                                 TestError error = (TestError)nodeInfo;
    73                                 MultipleNameVisitor v = new MultipleNameVisitor();
    74                                 v.visit(error.getPrimitives());
    75                                 res = "<html>" + v.getText() + "<br>" + error.getMessage();
    76                                 String d = error.getDescription();
    77                                 if(d != null)
    78                                         res += "<br>" + d;
    79                                 res += "</html>";
    80                         }
    81                         else
    82                                 res = node.toString();
    83                 }
    84                 return res;
    85         }
    86 
    87         /** Constructor */
    88         public ErrorTreePanel()
    89         {
    90                 this(null);
    91         }
    92 
    93         @Override
    94         public void setVisible(boolean v)
    95         {
    96                 if (v)
    97                         buildTree();
    98                 else
    99                         treeModel.setRoot(new DefaultMutableTreeNode());
    100                 super.setVisible(v);
    101         }
    102 
    103         /**
    104          * Builds the errors tree
    105          */
    106         public void buildTree()
    107         {
    108                 DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode();
    109 
    110                 if( errors == null || errors.isEmpty() )
    111                 {
    112                         treeModel.setRoot(rootNode);
    113                         return;
    114                 }
    115 
    116                 // Remember the currently expanded rows
    117                 Set<Object> oldSelectedRows = new HashSet<Object>();
    118                 Enumeration<TreePath> expanded = getExpandedDescendants( new TreePath(getRoot()) );
    119                 if( expanded != null )
    120                 {
    121                         while( expanded.hasMoreElements() )
    122                         {
    123                                 TreePath path = expanded.nextElement();
    124                                 DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
    125                                 Object userObject = node.getUserObject();
    126                                 if( userObject instanceof Severity )
    127                                         oldSelectedRows.add(userObject);
    128                                 else if (userObject instanceof String)
    129                                 {
    130                                         String msg = (String)userObject;
    131                                         msg = msg.substring(0, msg.lastIndexOf(" ("));
    132                                         oldSelectedRows.add(msg);
    133                                 }
    134                         }
    135                 }
    136 
    137                 Map<Severity, Bag<String, TestError>> errorTree
    138                 = new HashMap<Severity, Bag<String, TestError>>();
    139                 Map<Severity, HashMap<String, Bag<String, TestError>>> errorTreeDeep
    140                 = new HashMap<Severity, HashMap<String, Bag<String, TestError>>>();
    141                 for(Severity s : Severity.values())
    142                 {
    143                         errorTree.put(s, new Bag<String, TestError>(20));
    144                         errorTreeDeep.put(s, new HashMap<String, Bag<String, TestError>>());
    145                 }
    146 
    147                 for(TestError e : errors)
    148                 {
    149                         if(e.getIgnored())
    150                                 continue;
    151                         Severity s = e.getSeverity();
    152                         String d = e.getDescription();
    153                         String m = e.getMessage();
    154                         if(d != null)
    155                         {
    156                                 Bag<String, TestError> b = errorTreeDeep.get(s).get(m);
    157                                 if(b == null)
    158                                 {
    159                                         b = new Bag<String, TestError>(20);
    160                                         errorTreeDeep.get(s).put(m, b);
    161                                 }
    162                                 b.add(d, e);
    163                         }
    164                         else
    165                                 errorTree.get(s).add(m, e);
    166                 }
    167 
    168                 List<TreePath> expandedPaths = new ArrayList<TreePath>();
    169                 for(Severity s : Severity.values())
    170                 {
    171                         Bag<String, TestError> severityErrors = errorTree.get(s);
    172                         Map<String, Bag<String, TestError>> severityErrorsDeep = errorTreeDeep.get(s);
    173                         if(severityErrors.isEmpty() && severityErrorsDeep.isEmpty())
    174                                 continue;
    175 
    176                         // Severity node
    177                         DefaultMutableTreeNode severityNode = new DefaultMutableTreeNode(s);
    178                         rootNode.add(severityNode);
    179 
    180                         if( oldSelectedRows.contains(s))
    181                                 expandedPaths.add( new TreePath( new Object[] {rootNode, severityNode} ) );
    182 
    183                         for(Entry<String, List<TestError>> msgErrors : severityErrors.entrySet()  )
    184                         {
    185                                 // Message node
    186                                 List<TestError> errors = msgErrors.getValue();
    187                                 String msg = msgErrors.getKey() + " (" + errors.size() + ")";
    188                                 DefaultMutableTreeNode messageNode = new DefaultMutableTreeNode(msg);
    189                                 severityNode.add(messageNode);
    190 
    191                                 if( oldSelectedRows.contains(msgErrors.getKey()))
    192                                 {
    193                                          expandedPaths.add( new TreePath( new Object[]
    194                                          {rootNode, severityNode, messageNode} ) );
    195                                 }
    196 
    197                                 for (TestError error : errors)
    198                                 {
    199                                         // Error node
    200                                         DefaultMutableTreeNode errorNode = new DefaultMutableTreeNode(error);
    201                                         messageNode.add(errorNode);
    202                                 }
    203                         }
    204                         for(Entry<String, Bag <String, TestError>> bag : severityErrorsDeep.entrySet())
    205                         {
    206                                 // Group node
    207                                 Bag <String, TestError> errorlist = bag.getValue();
    208                                 DefaultMutableTreeNode groupNode = null;
    209                                 if(errorlist.size() > 1)
    210                                 {
    211                                         String nmsg = bag.getKey() + " (" + errorlist.size() + ")";
    212                                         groupNode = new DefaultMutableTreeNode(nmsg);
    213                                         severityNode.add(groupNode);
    214                                         if( oldSelectedRows.contains(bag.getKey()))
    215                                         {
    216                                                  expandedPaths.add( new TreePath( new Object[]
    217                                                  {rootNode, severityNode, groupNode} ) );
    218                                         }
    219                                 }
    220 
    221                                 for(Entry<String, List<TestError>> msgErrors : errorlist.entrySet())
    222                                 {
    223                                         // Message node
    224                                         List<TestError> errors = msgErrors.getValue();
    225                                         String msg;
    226                                         if(groupNode != null)
    227                                                 msg = msgErrors.getKey() + " (" + errors.size() + ")";
    228                                         else
    229                                                 msg = msgErrors.getKey() + " - " + bag.getKey() + " (" + errors.size() + ")";
    230                                         DefaultMutableTreeNode messageNode = new DefaultMutableTreeNode(msg);
    231                                         if(groupNode != null)
    232                                                 groupNode.add(messageNode);
    233                                         else
    234                                                 severityNode.add(messageNode);
    235 
    236                                         if( oldSelectedRows.contains(msgErrors.getKey()))
    237                                         {
    238                                                 if(groupNode != null)
    239                                                 {
    240                                                         expandedPaths.add(new TreePath(new Object[]
    241                                                         {rootNode, severityNode, groupNode, messageNode}));
    242                                                 }
    243                                                 else
    244                                                 {
    245                                                         expandedPaths.add(new TreePath(new Object[]
    246                                                         {rootNode, severityNode, messageNode}));
    247                                                 }
    248                                         }
    249 
    250                                         for (TestError error : errors)
    251                                         {
    252                                                 // Error node
    253                                                 DefaultMutableTreeNode errorNode = new DefaultMutableTreeNode(error);
    254                                                 messageNode.add(errorNode);
    255                                         }
    256                                 }
    257                         }
    258                 }
    259 
    260                 treeModel.setRoot(rootNode);
    261                 for( TreePath path : expandedPaths)
    262                 {
    263                         this.expandPath(path);
    264                 }
    265         }
    266 
    267         /**
    268          * Sets the errors list used by a data layer
    269          * @param errors The error list that is used by a data layer
    270          */
    271         public void setErrorList(List<TestError> errors)
    272         {
    273                 this.errors = errors;
    274                 if( isVisible() )
    275                         buildTree();
    276         }
    277 
    278         /**
    279          * Clears the current error list and adds these errors to it
    280          * @param errors The validation errors
    281          */
    282         public void setErrors(List<TestError> newerrors)
    283         {
    284                 if(errors == null)
    285                         return;
    286                 errors.clear();
    287                 for(TestError error : newerrors)
    288                 {
    289                         if(!error.getIgnored())
    290                                 errors.add(error);
    291                 }
    292                 if( isVisible() )
    293                         buildTree();
    294         }
    295 
    296         /**
    297          * Returns the errors of the tree
    298          * @return  the errors of the tree
    299          */
    300         public List<TestError> getErrors()
    301         {
    302                 return errors != null ? errors : Collections.<TestError>emptyList();
    303         }
    304 
    305         /**
    306          * Updates the current errors list
    307          * @param errors The validation errors
    308          */
    309         public void resetErrors()
    310         {
    311                 List<TestError> e = new ArrayList<TestError>(errors);
    312                 setErrors(e);
    313         }
    314 
    315         /**
    316          * Expands all tree
    317          */
    318         @SuppressWarnings("unchecked")
    319         public void expandAll()
    320         {
    321                 DefaultMutableTreeNode root = getRoot();
    322 
    323                 int row = 0;
    324                 Enumeration<DefaultMutableTreeNode> children = root.breadthFirstEnumeration();
    325                 while( children.hasMoreElements() )
    326                 {
    327                         children.nextElement();
    328                         expandRow(row++);
    329                 }
    330         }
    331 
    332         /**
    333          * Returns the root node model.
    334          * @return The root node model
    335          */
    336         public DefaultMutableTreeNode getRoot()
    337         {
    338                 return (DefaultMutableTreeNode) treeModel.getRoot();
    339         }
     33public class ErrorTreePanel extends JTree {
     34    /** Serializable ID */
     35    private static final long serialVersionUID = 2952292777351992696L;
     36
     37    /**
     38     * The validation data.
     39     */
     40    protected DefaultTreeModel treeModel = new DefaultTreeModel(new DefaultMutableTreeNode());
     41
     42    /** The list of errors shown in the tree */
     43    private List<TestError> errors;
     44
     45    /**
     46     * If {@link #filter} is not <code>null</code> only errors are displayed
     47     * that refer to one of the primitives in the filter. 
     48     */
     49    private Set<OsmPrimitive> filter = null;
     50
     51    /**
     52     * Constructor
     53     * @param errors The list of errors
     54     */
     55    public ErrorTreePanel(List<TestError> errors) {
     56        ToolTipManager.sharedInstance().registerComponent(this);
     57        this.setModel(treeModel);
     58        this.setRootVisible(false);
     59        this.setShowsRootHandles(true);
     60        this.expandRow(0);
     61        this.setVisibleRowCount(8);
     62        this.setCellRenderer(new ErrorTreeRenderer());
     63        this.getSelectionModel().setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
     64        setErrorList(errors);
     65    }
     66
     67    public String getToolTipText(MouseEvent e) {
     68        String res = null;
     69        TreePath path = getPathForLocation(e.getX(), e.getY());
     70        if (path != null) {
     71            DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
     72            Object nodeInfo = node.getUserObject();
     73
     74            if (nodeInfo instanceof TestError) {
     75                TestError error = (TestError) nodeInfo;
     76                MultipleNameVisitor v = new MultipleNameVisitor();
     77                v.visit(error.getPrimitives());
     78                res = "<html>" + v.getText() + "<br>" + error.getMessage();
     79                String d = error.getDescription();
     80                if (d != null)
     81                    res += "<br>" + d;
     82                res += "</html>";
     83            } else
     84                res = node.toString();
     85        }
     86        return res;
     87    }
     88
     89    /** Constructor */
     90    public ErrorTreePanel() {
     91        this(null);
     92    }
     93
     94    @Override
     95    public void setVisible(boolean v) {
     96        if (v)
     97            buildTree();
     98        else
     99            treeModel.setRoot(new DefaultMutableTreeNode());
     100        super.setVisible(v);
     101    }
     102
     103    /**
     104     * Builds the errors tree
     105     */
     106    public void buildTree() {
     107        DefaultMutableTreeNode rootNode = new DefaultMutableTreeNode();
     108
     109        if (errors == null || errors.isEmpty()) {
     110            treeModel.setRoot(rootNode);
     111            return;
     112        }
     113
     114        // Remember the currently expanded rows
     115        Set<Object> oldSelectedRows = new HashSet<Object>();
     116        Enumeration<TreePath> expanded = getExpandedDescendants(new TreePath(getRoot()));
     117        if (expanded != null) {
     118            while (expanded.hasMoreElements()) {
     119                TreePath path = expanded.nextElement();
     120                DefaultMutableTreeNode node = (DefaultMutableTreeNode) path.getLastPathComponent();
     121                Object userObject = node.getUserObject();
     122                if (userObject instanceof Severity)
     123                    oldSelectedRows.add(userObject);
     124                else if (userObject instanceof String) {
     125                    String msg = (String) userObject;
     126                    msg = msg.substring(0, msg.lastIndexOf(" ("));
     127                    oldSelectedRows.add(msg);
     128                }
     129            }
     130        }
     131
     132        Map<Severity, Bag<String, TestError>> errorTree = new HashMap<Severity, Bag<String, TestError>>();
     133        Map<Severity, HashMap<String, Bag<String, TestError>>> errorTreeDeep = new HashMap<Severity, HashMap<String, Bag<String, TestError>>>();
     134        for (Severity s : Severity.values()) {
     135            errorTree.put(s, new Bag<String, TestError>(20));
     136            errorTreeDeep.put(s, new HashMap<String, Bag<String, TestError>>());
     137        }
     138
     139        for (TestError e : errors) {
     140            if (e.getIgnored())
     141                continue;
     142            Severity s = e.getSeverity();
     143            String d = e.getDescription();
     144            String m = e.getMessage();
     145            if (filter != null) {
     146                boolean found = false;
     147                for (OsmPrimitive p : e.getPrimitives()) {
     148                    if (filter.contains(p)) {
     149                        found = true;
     150                        break;
     151                    }
     152                }
     153                if (!found)
     154                    continue;
     155            }
     156            if (d != null) {
     157                Bag<String, TestError> b = errorTreeDeep.get(s).get(m);
     158                if (b == null) {
     159                    b = new Bag<String, TestError>(20);
     160                    errorTreeDeep.get(s).put(m, b);
     161                }
     162                b.add(d, e);
     163            } else
     164                errorTree.get(s).add(m, e);
     165        }
     166
     167        List<TreePath> expandedPaths = new ArrayList<TreePath>();
     168        for (Severity s : Severity.values()) {
     169            Bag<String, TestError> severityErrors = errorTree.get(s);
     170            Map<String, Bag<String, TestError>> severityErrorsDeep = errorTreeDeep.get(s);
     171            if (severityErrors.isEmpty() && severityErrorsDeep.isEmpty())
     172                continue;
     173
     174            // Severity node
     175            DefaultMutableTreeNode severityNode = new DefaultMutableTreeNode(s);
     176            rootNode.add(severityNode);
     177
     178            if (oldSelectedRows.contains(s))
     179                expandedPaths.add(new TreePath(new Object[] { rootNode, severityNode }));
     180
     181            for (Entry<String, List<TestError>> msgErrors : severityErrors.entrySet()) {
     182                // Message node
     183                List<TestError> errors = msgErrors.getValue();
     184                String msg = msgErrors.getKey() + " (" + errors.size() + ")";
     185                DefaultMutableTreeNode messageNode = new DefaultMutableTreeNode(msg);
     186                severityNode.add(messageNode);
     187
     188                if (oldSelectedRows.contains(msgErrors.getKey())) {
     189                    expandedPaths.add(new TreePath(new Object[] { rootNode, severityNode, messageNode }));
     190                }
     191
     192                for (TestError error : errors) {
     193                    // Error node
     194                    DefaultMutableTreeNode errorNode = new DefaultMutableTreeNode(error);
     195                    messageNode.add(errorNode);
     196                }
     197            }
     198            for (Entry<String, Bag<String, TestError>> bag : severityErrorsDeep.entrySet()) {
     199                // Group node
     200                Bag<String, TestError> errorlist = bag.getValue();
     201                DefaultMutableTreeNode groupNode = null;
     202                if (errorlist.size() > 1) {
     203                    String nmsg = bag.getKey() + " (" + errorlist.size() + ")";
     204                    groupNode = new DefaultMutableTreeNode(nmsg);
     205                    severityNode.add(groupNode);
     206                    if (oldSelectedRows.contains(bag.getKey())) {
     207                        expandedPaths.add(new TreePath(new Object[] { rootNode, severityNode, groupNode }));
     208                    }
     209                }
     210
     211                for (Entry<String, List<TestError>> msgErrors : errorlist.entrySet()) {
     212                    // Message node
     213                    List<TestError> errors = msgErrors.getValue();
     214                    String msg;
     215                    if (groupNode != null)
     216                        msg = msgErrors.getKey() + " (" + errors.size() + ")";
     217                    else
     218                        msg = msgErrors.getKey() + " - " + bag.getKey() + " (" + errors.size() + ")";
     219                    DefaultMutableTreeNode messageNode = new DefaultMutableTreeNode(msg);
     220                    if (groupNode != null)
     221                        groupNode.add(messageNode);
     222                    else
     223                        severityNode.add(messageNode);
     224
     225                    if (oldSelectedRows.contains(msgErrors.getKey())) {
     226                        if (groupNode != null) {
     227                            expandedPaths.add(new TreePath(new Object[] { rootNode, severityNode, groupNode,
     228                                    messageNode }));
     229                        } else {
     230                            expandedPaths.add(new TreePath(new Object[] { rootNode, severityNode, messageNode }));
     231                        }
     232                    }
     233
     234                    for (TestError error : errors) {
     235                        // Error node
     236                        DefaultMutableTreeNode errorNode = new DefaultMutableTreeNode(error);
     237                        messageNode.add(errorNode);
     238                    }
     239                }
     240            }
     241        }
     242
     243        treeModel.setRoot(rootNode);
     244        for (TreePath path : expandedPaths) {
     245            this.expandPath(path);
     246        }
     247    }
     248
     249    /**
     250     * Sets the errors list used by a data layer
     251     * @param errors The error list that is used by a data layer
     252     */
     253    public void setErrorList(List<TestError> errors) {
     254        this.errors = errors;
     255        if (isVisible())
     256            buildTree();
     257    }
     258
     259    /**
     260     * Clears the current error list and adds these errors to it
     261     * @param errors The validation errors
     262     */
     263    public void setErrors(List<TestError> newerrors) {
     264        if (errors == null)
     265            return;
     266        errors.clear();
     267        for (TestError error : newerrors) {
     268            if (!error.getIgnored())
     269                errors.add(error);
     270        }
     271        if (isVisible())
     272            buildTree();
     273    }
     274
     275    /**
     276     * Returns the errors of the tree
     277     * @return  the errors of the tree
     278     */
     279    public List<TestError> getErrors() {
     280        return errors != null ? errors : Collections.<TestError> emptyList();
     281    }
     282
     283    public Set<OsmPrimitive> getFilter() {
     284        return filter;
     285    }
     286
     287    public void setFilter(Set<OsmPrimitive> filter) {
     288        if (filter != null && filter.size() == 0)
     289            this.filter = null;
     290        else
     291            this.filter = filter;
     292        if (isVisible())
     293            buildTree();
     294    }
     295
     296    /**
     297     * Updates the current errors list
     298     * @param errors The validation errors
     299     */
     300    public void resetErrors() {
     301        List<TestError> e = new ArrayList<TestError>(errors);
     302        setErrors(e);
     303    }
     304
     305    /**
     306     * Expands all tree
     307     */
     308    @SuppressWarnings("unchecked")
     309    public void expandAll() {
     310        DefaultMutableTreeNode root = getRoot();
     311
     312        int row = 0;
     313        Enumeration<DefaultMutableTreeNode> children = root.breadthFirstEnumeration();
     314        while (children.hasMoreElements()) {
     315            children.nextElement();
     316            expandRow(row++);
     317        }
     318    }
     319
     320    /**
     321     * Returns the root node model.
     322     * @return The root node model
     323     */
     324    public DefaultMutableTreeNode getRoot() {
     325        return (DefaultMutableTreeNode) treeModel.getRoot();
     326    }
    340327}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/PreferenceEditor.java

    r10122 r11530  
    55import java.awt.GridBagLayout;
    66import java.util.Collection;
    7 import java.util.Map;
    8 import java.util.regex.Pattern;
    97
    10 import javax.swing.*;
     8import javax.swing.BorderFactory;
     9import javax.swing.JCheckBox;
     10import javax.swing.JLabel;
     11import javax.swing.JPanel;
     12import javax.swing.JScrollPane;
    1113
    1214import org.openstreetmap.josm.Main;
    … …  
    4345        /** The preferences key for enabled tests before upload*/
    4446        public static final String PREF_TESTS_BEFORE_UPLOAD = PREFIX + ".testsBeforeUpload";
     47
     48        /**
     49         * The preferences key for enabling the permanent filtering
     50         * of the displayed errors in the tree regarding the current selection
     51         */
     52    public static final String PREF_FILTER_BY_SELECTION = PREFIX + ".selectionFilter";
    4553
    4654        private JCheckBox prefUseIgnore;

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/Test.java

    r10490 r11530  
    11package org.openstreetmap.josm.plugins.validator;
    22
    3 import java.awt.event.ActionEvent;
    4 import java.awt.event.ActionListener;
    53import java.util.ArrayList;
    64import java.util.Collection;
    … …  
    119
    1210import org.openstreetmap.josm.command.Command;
    13 import org.openstreetmap.josm.data.osm.*;
     11import org.openstreetmap.josm.data.osm.Node;
     12import org.openstreetmap.josm.data.osm.OsmPrimitive;
     13import org.openstreetmap.josm.data.osm.Relation;
     14import org.openstreetmap.josm.data.osm.Way;
    1415import org.openstreetmap.josm.data.osm.visitor.Visitor;
    1516import org.openstreetmap.josm.tools.GBC;
    … …  
    7879         * @throws Exception When cannot initialize the test
    7980         */
    80         public static void initialize(@SuppressWarnings("unused") OSMValidatorPlugin plugin) throws Exception {}
     81        public static void initialize(OSMValidatorPlugin plugin) throws Exception {}
    8182       
    8283        /**
    … …  
    138139         * @param testPanel The panel to add any preferences component
    139140         */
    140         public void addGui(@SuppressWarnings("unused") JPanel testPanel)
     141        public void addGui(JPanel testPanel)
    141142        {
    142143                checkEnabled = new JCheckBox(name, enabled);
    … …  
    166167         * @return The command to fix the error
    167168         */
    168         public Command fixError(@SuppressWarnings("unused") TestError testError)
     169        public Command fixError(TestError testError)
    169170        {
    170171                return null;
    … …  
    177178         * @return true if the error can be fixed
    178179         */
    179         public boolean isFixable(@SuppressWarnings("unused") TestError testError)
     180        public boolean isFixable(TestError testError)
    180181        {
    181182                return false;

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ValidateAction.java

    r10663 r11530  
    8383        }
    8484
    85         List<TestError> errors = new ArrayList<TestError>();
     85        List<TestError> errors = new ArrayList<TestError>(200);
    8686        for (Test test : tests) {
    8787            test.setPartialSelection(lastSelection != null);

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ValidateUploadHook.java

    r10502 r11530  
    44
    55import java.awt.GridBagLayout;
     6import java.util.ArrayList;
    67import java.util.Collection;
    7 import java.util.ArrayList;
    88import java.util.List;
    99
    … …  
    1414import org.openstreetmap.josm.Main;
    1515import org.openstreetmap.josm.actions.UploadAction.UploadHook;
     16import org.openstreetmap.josm.data.osm.DataSet;
    1617import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1718import org.openstreetmap.josm.plugins.validator.util.AgregatePrimitivesVisitor;
    … …  
    110111                        plugin.validationDialog.tree.setErrors(errors);
    111112                        plugin.validationDialog.setVisible(true);
    112                         Main.ds.fireSelectionChanged(Main.ds.getSelected());
     113                        DataSet.fireSelectionChanged(Main.ds.getSelected());
    113114                }
    114115                return res == JOptionPane.YES_OPTION;

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/ValidatorDialog.java

    r10661 r11530  
    2828import org.openstreetmap.josm.Main;
    2929import org.openstreetmap.josm.command.Command;
     30import org.openstreetmap.josm.data.SelectionChangedListener;
    3031import org.openstreetmap.josm.data.osm.DataSet;
    3132import org.openstreetmap.josm.data.osm.OsmPrimitive;
    … …  
    4344 * @author frsantos
    4445 */
    45 public class ValidatorDialog extends ToggleDialog implements ActionListener {
     46public class ValidatorDialog extends ToggleDialog implements ActionListener, SelectionChangedListener {
    4647    private OSMValidatorPlugin plugin;
    4748
    … …  
    108109        }
    109110        add(buttonPanel, BorderLayout.SOUTH);
     111        DataSet.selListeners.add(this);
    110112    }
    111113
    … …  
    428430        }
    429431    }
     432
     433    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     434        if (!Main.pref.getBoolean(PreferenceEditor.PREF_FILTER_BY_SELECTION, false))
     435            return;
     436        if (newSelection == null || newSelection.size() == 0)
     437            tree.setFilter(null);
     438        HashSet<OsmPrimitive> filter = new HashSet<OsmPrimitive>(newSelection);
     439        tree.setFilter(filter);
     440    }
    430441}

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/CrossingWays.java

    r9684 r11530  
    55import java.awt.geom.Line2D;
    66import java.awt.geom.Point2D;
    7 import java.util.*;
    8 
    9 import org.openstreetmap.josm.data.osm.*;
    10 import org.openstreetmap.josm.plugins.validator.*;
    11 import org.openstreetmap.josm.plugins.validator.util.Bag;
     7import java.util.ArrayList;
     8import java.util.Arrays;
     9import java.util.HashMap;
     10import java.util.HashSet;
     11import java.util.List;
     12import java.util.Map;
     13
     14import org.openstreetmap.josm.data.osm.Node;
     15import org.openstreetmap.josm.data.osm.Way;
     16import org.openstreetmap.josm.data.osm.WaySegment;
     17import org.openstreetmap.josm.plugins.validator.Severity;
     18import org.openstreetmap.josm.plugins.validator.Test;
     19import org.openstreetmap.josm.plugins.validator.TestError;
    1220import org.openstreetmap.josm.plugins.validator.util.Util;
    1321

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/DuplicatedWayNodes.java

    r10774 r11530  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
     5import java.util.Arrays;
     6import java.util.Collections;
     7
     8import org.openstreetmap.josm.command.ChangeCommand;
     9import org.openstreetmap.josm.command.Command;
     10import org.openstreetmap.josm.command.DeleteCommand;
     11import org.openstreetmap.josm.data.osm.Node;
     12import org.openstreetmap.josm.data.osm.Way;
     13import org.openstreetmap.josm.plugins.validator.Severity;
    514import org.openstreetmap.josm.plugins.validator.Test;
    615import org.openstreetmap.josm.plugins.validator.TestError;
    7 import org.openstreetmap.josm.plugins.validator.Severity;
    8 import org.openstreetmap.josm.data.osm.Way;
    9 import org.openstreetmap.josm.data.osm.Node;
    10 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    11 import org.openstreetmap.josm.command.Command;
    12 import org.openstreetmap.josm.command.DeleteCommand;
    13 import org.openstreetmap.josm.command.ChangeCommand;
    14 import java.util.Collections;
    15 import java.util.Arrays;
    1616
    1717public class DuplicatedWayNodes extends Test {

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/OverlappingWays.java

    r10519 r11530  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.util.*;
     5import java.util.ArrayList;
     6import java.util.HashMap;
     7import java.util.List;
     8import java.util.Map;
    69
    7 import org.openstreetmap.josm.data.coor.LatLon;
     10import org.openstreetmap.josm.data.osm.Node;
    811import org.openstreetmap.josm.data.osm.OsmPrimitive;
    912import org.openstreetmap.josm.data.osm.OsmUtils;
    1013import org.openstreetmap.josm.data.osm.Way;
    1114import org.openstreetmap.josm.data.osm.WaySegment;
    12 import org.openstreetmap.josm.data.osm.Node;
    13 import org.openstreetmap.josm.tools.Pair;
    1415import org.openstreetmap.josm.plugins.validator.Severity;
    1516import org.openstreetmap.josm.plugins.validator.Test;
    1617import org.openstreetmap.josm.plugins.validator.TestError;
    1718import org.openstreetmap.josm.plugins.validator.util.Bag;
     19import org.openstreetmap.josm.tools.Pair;
    1820
    1921/**

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/TagChecker.java

    r10666 r11530  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.awt.Dimension;
     7import java.awt.GridBagLayout;
    68import java.awt.event.ActionEvent;
    79import java.awt.event.ActionListener;
    8 import java.awt.Dimension;
    9 import java.awt.GridBagLayout;
    1010import java.io.BufferedReader;
    11 import java.io.InputStream;
     11import java.io.FileNotFoundException;
     12import java.io.IOException;
    1213import java.io.InputStreamReader;
    13 import java.io.IOException;
    1414import java.io.UnsupportedEncodingException;
    15 import java.lang.IllegalStateException;
    16 import java.net.URL;
    1715import java.text.MessageFormat;
    1816import java.util.ArrayList;
    … …  
    3331import javax.swing.JList;
    3432import javax.swing.JOptionPane;
     33import javax.swing.JPanel;
    3534import javax.swing.JScrollPane;
    36 import javax.swing.JPanel;
    37 
     35
     36import org.openstreetmap.josm.Main;
    3837import org.openstreetmap.josm.command.ChangePropertyCommand;
    3938import org.openstreetmap.josm.command.Command;
    … …  
    4746import org.openstreetmap.josm.gui.tagging.TaggingPreset;
    4847import org.openstreetmap.josm.io.MirroredInputStream;
    49 import org.openstreetmap.josm.Main;
    5048import org.openstreetmap.josm.plugins.validator.OSMValidatorPlugin;
    5149import org.openstreetmap.josm.plugins.validator.PreferenceEditor;
    … …  
    5351import org.openstreetmap.josm.plugins.validator.Test;
    5452import org.openstreetmap.josm.plugins.validator.TestError;
    55 import org.openstreetmap.josm.plugins.validator.tests.ChangePropertyKeyCommand;
    5653import org.openstreetmap.josm.plugins.validator.util.Bag;
     54import org.openstreetmap.josm.plugins.validator.util.Entities;
    5755import org.openstreetmap.josm.plugins.validator.util.Util;
    58 import org.openstreetmap.josm.plugins.validator.util.Entities;
    5956import org.openstreetmap.josm.tools.GBC;
    60 import org.openstreetmap.josm.tools.XmlObjectParser;
    61 import org.xml.sax.SAXException;
    6257
    6358/**

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/tests/WronglyOrderedWays.java

    r9684 r11530  
    33import static org.openstreetmap.josm.tools.I18n.tr;
    44
    5 import java.awt.geom.Point2D;
    6 import java.util.*;
     5import java.util.ArrayList;
     6import java.util.List;
    77
    88import org.openstreetmap.josm.data.osm.OsmPrimitive;
    … …  
    1212import org.openstreetmap.josm.plugins.validator.TestError;
    1313import org.openstreetmap.josm.plugins.validator.util.Bag;
    14 import org.openstreetmap.josm.plugins.validator.util.Util;
    1514
    1615/**

  • applications/editors/josm/plugins/validator/src/org/openstreetmap/josm/plugins/validator/util/Util.java

    r10408 r11530  
    11package org.openstreetmap.josm.plugins.validator.util;
    22
    3 import static org.openstreetmap.josm.tools.I18n.tr;
    4 
    5 import java.awt.Insets;
    6 import java.awt.event.ActionListener;
    73import java.awt.geom.Point2D;
    8 import java.util.*;
    9 
    10 import javax.swing.JButton;
     4import java.util.ArrayList;
     5import java.util.Collections;
     6import java.util.HashSet;
     7import java.util.List;
     8import java.util.Map;
     9import java.util.Set;
    1110
    1211import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.data.osm.Node;
    1313import org.openstreetmap.josm.data.osm.Way;
    14 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    15 import org.openstreetmap.josm.data.osm.Node;
    16 import org.openstreetmap.josm.plugins.*;
    17 import org.openstreetmap.josm.plugins.validator.PreferenceEditor;
    18 import org.openstreetmap.josm.tools.ImageProvider;
     14import org.openstreetmap.josm.plugins.PluginInformation;
    1915
    2016/**
Note: See TracChangeset for help on using the changeset viewer.