Changeset 1631 in josm


Ignore:
Timestamp:
2009-06-01T22:20:03+02:00 (11 years ago)
Author:
Gubaer
Message:

added support for merging member lists of relations in extended conflict resolution dialog

Location:
trunk
Files:
9 added
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/gui/conflict/ConflictResolver.java

    r1626 r1631  
    77import java.beans.PropertyChangeEvent;
    88import java.beans.PropertyChangeListener;
    9 import java.net.URL;
    109import java.util.ArrayList;
    1110import java.util.logging.Logger;
     
    2524import org.openstreetmap.josm.gui.conflict.nodes.NodeListMergeModel;
    2625import org.openstreetmap.josm.gui.conflict.nodes.NodeListMerger;
     26import org.openstreetmap.josm.gui.conflict.relation.RelationMemberListMergeModel;
     27import org.openstreetmap.josm.gui.conflict.relation.RelationMemberMerger;
    2728import org.openstreetmap.josm.gui.conflict.tags.TagMergeModel;
    2829import org.openstreetmap.josm.gui.conflict.tags.TagMerger;
     30import org.openstreetmap.josm.tools.ImageProvider;
    2931
    3032/**
    3133 * An UI component for resolving conflicts between two {@see OsmPrimitive}s.
    32  *   
    33  *
     34 *
    3435 */
    3536public class ConflictResolver extends JPanel implements PropertyChangeListener  {
    36    
    37    private static final Logger logger = Logger.getLogger(ConflictResolver.class.getName());
     37
     38    private static final Logger logger = Logger.getLogger(ConflictResolver.class.getName());
    3839
    3940    private JTabbedPane tabbedPane = null;
    4041    private TagMerger tagMerger;
    4142    private NodeListMerger nodeListMerger;
     43    private RelationMemberMerger relationMemberMerger;
    4244    private OsmPrimitive my;
    4345    private OsmPrimitive their;
    44    
     46
    4547    private ImageIcon mergeComplete;
    4648    private ImageIcon mergeIncomplete;
    47    
    48     // FIXME copied code -> refactor
    49     /**
    50      * load an icon given by iconName
    51      *
    52      * @param iconName  the name of the icon (without path, i.e. <tt>copystartleft.png</tt>
    53      * @return the icon; null, if the icon was not found
    54      */
    55     protected ImageIcon getIcon(String iconName) {
    56         String fullIconName  = "/images/dialogs/conflict/" + iconName;
    57         URL imageURL   = this.getClass().getResource(fullIconName);           
    58         if (imageURL == null) {
    59             System.out.println(tr("WARNING: failed to load resource {0}", fullIconName));
    60             return null;
    61         }
    62         return new ImageIcon(imageURL);
     49
     50    protected void loadIcons() {
     51        mergeComplete = ImageProvider.get("dialogs/conflict","mergecomplete.png" );
     52        mergeIncomplete = ImageProvider.get("dialogs/conflict","mergeincomplete.png" );
    6353    }
    64    
    65     protected void loadIcons() {
    66         mergeComplete = getIcon("mergecomplete.png");
    67         mergeIncomplete = getIcon("mergeincomplete.png");
    68     }
    69    
     54
    7055    protected void build() {
    7156        tabbedPane = new JTabbedPane();
    72        
     57
    7358        tagMerger = new TagMerger();
     59        tagMerger.setName("panel.tagmerger");
    7460        tagMerger.getModel().addPropertyChangeListener(this);
    7561        tabbedPane.add("Tags", tagMerger);
    76        
     62
    7763        nodeListMerger = new NodeListMerger();
     64        nodeListMerger.setName("panel.nodelistmerger");
    7865        nodeListMerger.getModel().addPropertyChangeListener(this);
    7966        tabbedPane.add("Nodes", nodeListMerger);
    80        
    81         tabbedPane.add("Members", new JPanel());
    82        
     67
     68        relationMemberMerger = new RelationMemberMerger();
     69        relationMemberMerger.setName("panel.relationmembermerger");
     70        relationMemberMerger.getModel().addPropertyChangeListener(this);
     71        tabbedPane.add("Members", relationMemberMerger);
     72
    8373        setLayout(new BorderLayout());
    8474        add(tabbedPane, BorderLayout.CENTER);
    8575    }
    86    
    87    
     76
    8877    public ConflictResolver() {
    8978        build();
     
    9281
    9382    public void propertyChange(PropertyChangeEvent evt) {
    94        
     83
    9584        if (evt.getPropertyName().equals(TagMergeModel.PROP_NUM_UNDECIDED_TAGS)) {
    9685            int newValue = (Integer)evt.getNewValue();
     
    10493                tabbedPane.setIconAt(0, mergeIncomplete);
    10594            }
    106         } else if (evt.getPropertyName().equals(NodeListMergeModel.PROP_FROZEN)) {
     95        } else if (evt.getPropertyName().equals(ListMergeModel.PROP_FROZEN)) {
    10796            boolean frozen = (Boolean)evt.getNewValue();
    108             if (frozen) {
     97            if (frozen && evt.getSource() == nodeListMerger.getModel()) {
    10998                tabbedPane.setTitleAt(1, tr("Nodes(resolved)"));
    110                 tabbedPane.setToolTipTextAt(1, tr("Pending conflicts in the node list of this way"));
     99                tabbedPane.setToolTipTextAt(1, tr("Merged node list frozen. No pending conflicts in the node list of this way"));
    111100                tabbedPane.setIconAt(1, mergeComplete);
    112101            } else {
    113102                tabbedPane.setTitleAt(1, tr("Nodes(with conflicts)"));
    114                 tabbedPane.setToolTipTextAt(1, tr("Merged node list frozen. No pending conflicts in the node list of this way"));
     103                tabbedPane.setToolTipTextAt(1,tr("Pending conflicts in the node list of this way"));
    115104                tabbedPane.setIconAt(1, mergeIncomplete);
     105            }
     106            if (frozen && evt.getSource() == relationMemberMerger.getModel()) {
     107                tabbedPane.setTitleAt(2, tr("Members(resolved)"));
     108                tabbedPane.setToolTipTextAt(2, tr("Merged member list frozen. No pending conflicts in the member list of this relation"));
     109                tabbedPane.setIconAt(2, mergeComplete);
     110            } else {
     111                tabbedPane.setTitleAt(2, tr("Members(with conflicts)"));
     112                tabbedPane.setToolTipTextAt(2, tr("Pending conflicts in the member list of this relation"));
     113                tabbedPane.setIconAt(2, mergeIncomplete);
    116114            }
    117115        }
    118116    }
    119    
    120     public void populate(OsmPrimitive my, OsmPrimitive their) {
     117
     118    /**
     119     * populates the conflict resolver with the conflicts between my and their
     120     *
     121     * @param my   my primitive (i.e. the primitive in the local dataset)
     122     * @param their their primitive (i.e. the primitive in the server dataset)
     123     *
     124     */
     125    public void populate(OsmPrimitive my, OsmPrimitive their) {
    121126        this.my = my;
    122         this.their =  their; 
     127        this.their =  their;
    123128        tagMerger.getModel().populate(my, their);
    124         if (my instanceof Way) {
    125            nodeListMerger.populate((Way)my, (Way)their);
    126            tabbedPane.setEnabledAt(1, true);
    127            tabbedPane.setEnabledAt(2, false);
     129        tabbedPane.setEnabledAt(0,true);
     130        if (my instanceof Node) {
     131            tabbedPane.setEnabledAt(1,false);
     132            tabbedPane.setEnabledAt(2,false);
     133        } else if (my instanceof Way) {
     134            nodeListMerger.populate((Way)my, (Way)their);
     135            tabbedPane.setEnabledAt(1, true);
     136            tabbedPane.setEnabledAt(2, false);
    128137        } else if (my instanceof Relation) {
     138            relationMemberMerger.populate((Relation)my, (Relation)their);
    129139            tabbedPane.setEnabledAt(1, false);
    130             tabbedPane.setEnabledAt(2, true);       
    131          }
     140            tabbedPane.setEnabledAt(2, true);
     141        }
    132142    }
    133    
     143
     144    /**
     145     * Builds the resolution command(s) for for the resolved conflicts in this
     146     * ConflictResolver
     147     *
     148     * @return the resolution command
     149     */
    134150    public Command buildResolveCommand() {
    135151        ArrayList<Command> commands = new ArrayList<Command>();
     
    137153        commands.add(cmd);
    138154        if (my instanceof Way && nodeListMerger.getModel().isFrozen()) {
    139             commands.add(nodeListMerger.getModel().buildResolveCommand((Way)my, (Way)their));           
     155            NodeListMergeModel model  =(NodeListMergeModel)nodeListMerger.getModel();
     156            commands.add(model.buildResolveCommand((Way)my, (Way)their));
     157        } else if (my instanceof Relation && relationMemberMerger.getModel().isFrozen()) {
     158            RelationMemberListMergeModel model  =(RelationMemberListMergeModel)relationMemberMerger.getModel();
     159            commands.add(model.buildResolveCommand((Relation)my, (Relation)their));
    140160        }
    141161        if (my instanceof Node) {
    142             // resolve the version conflict if this is a node and all tag 
    143             // conflicts have been resolved 
    144             // 
     162            // resolve the version conflict if this is a node and all tag
     163            // conflicts have been resolved
     164            //
    145165            if (tagMerger.getModel().isResolvedCompletely()) {
    146166                commands.add(
    147                    new VersionConflictResolveCommand(my, their)
     167                        new VersionConflictResolveCommand(my, their)
    148168                );
    149169            }
    150170        } else if (my instanceof Way) {
    151             // resolve the version conflict if this is a way, all tag 
     171            // resolve the version conflict if this is a way, all tag
    152172            // conflicts have been resolved, and conflicts in the node list
    153             // have been resolved 
    154             // 
     173            // have been resolved
     174            //
    155175            if (tagMerger.getModel().isResolvedCompletely() && nodeListMerger.getModel().isFrozen()) {
    156176                commands.add(
    157                    new VersionConflictResolveCommand(my, their)
     177                        new VersionConflictResolveCommand(my, their)
    158178                );
    159             }           
     179            }
     180        }  else if (my instanceof Relation) {
     181            // resolve the version conflict if this is a relation, all tag
     182            // conflicts and all conflicts in the member list
     183            // have been resolved
     184            //
     185            if (tagMerger.getModel().isResolvedCompletely() && relationMemberMerger.getModel().isFrozen()) {
     186                commands.add(
     187                        new VersionConflictResolveCommand(my, their)
     188                );
     189            }
    160190        }
    161         return new SequenceCommand("Conflict Resolution", commands);
     191
     192        return new SequenceCommand(tr("Conflict Resolution"), commands);
    162193    }
    163194}
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListColumnModel.java

    r1622 r1631  
    1111
    1212    protected void createColumns(TableCellRenderer renderer) {
    13        
     13
    1414        TableColumn col = null;
    15        
    16         // column 0 - Node 
     15
     16        // column 0 - Node
    1717        col = new TableColumn(0);
    1818        col.setHeaderValue(tr("Node"));
    1919        col.setResizable(true);
    2020        col.setCellRenderer(renderer);
    21         addColumn(col);       
     21        addColumn(col);
    2222    }
    2323
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModel.java

    r1622 r1631  
    22package org.openstreetmap.josm.gui.conflict.nodes;
    33
    4 import static org.openstreetmap.josm.tools.I18n.tr;
    5 
    6 import java.beans.PropertyChangeEvent;
    7 import java.beans.PropertyChangeListener;
    84import java.util.ArrayList;
    9 import java.util.List;
    105import java.util.logging.Logger;
    116
    12 import javax.swing.DefaultListSelectionModel;
    13 import javax.swing.ListSelectionModel;
    147import javax.swing.table.DefaultTableModel;
    15 import javax.swing.table.TableModel;
    168
    179import org.openstreetmap.josm.command.WayNodesConflictResolverCommand;
    1810import org.openstreetmap.josm.data.osm.Node;
    1911import org.openstreetmap.josm.data.osm.Way;
     12import org.openstreetmap.josm.gui.conflict.ListMergeModel;
    2013
    21 public class NodeListMergeModel {
     14public class NodeListMergeModel extends ListMergeModel<Node>{
     15
    2216    private static final Logger logger = Logger.getLogger(NodeListMergeModel.class.getName());
    23    
    24     public static final String PROP_FROZEN = NodeListMergeModel.class.getName() + ".frozen";
    25    
    2617
    27     private ArrayList<Node> myNodes;
    28     private ArrayList<Node> theirNodes;
    29     private ArrayList<Node> mergedNodes;
    30    
    31    
    32     private DefaultTableModel myNodesTableModel;
    33     private DefaultTableModel theirNodesTableModel;
    34     private DefaultTableModel mergedNodesTableModel;
    35    
    36     private DefaultListSelectionModel myNodesSelectionModel;
    37     private DefaultListSelectionModel theirNodesSelectionModel;
    38     private DefaultListSelectionModel mergedNodesSelectionModel;
    39    
    40     private ArrayList<PropertyChangeListener> listeners;
    41     private boolean isFrozen = false;
    42    
    43    
    44     public NodeListMergeModel() {
    45         myNodes = new ArrayList<Node>();
    46         theirNodes = new ArrayList<Node>();
    47         mergedNodes = new ArrayList<Node>();
    48        
    49         myNodesTableModel = new NodeListTableModel(myNodes);
    50         theirNodesTableModel = new NodeListTableModel(theirNodes);
    51         mergedNodesTableModel = new NodeListTableModel(mergedNodes);
    52        
    53         myNodesSelectionModel = new DefaultListSelectionModel();
    54         theirNodesSelectionModel = new DefaultListSelectionModel();
    55         mergedNodesSelectionModel = new DefaultListSelectionModel();
    56        
    57         listeners = new ArrayList<PropertyChangeListener>();
    58        
    59         setFrozen(true);
    60     }
    61    
    62    
    63     public void addPropertyChangeListener(PropertyChangeListener listener) {
    64         synchronized(listeners) {
    65             if (listener != null && ! listeners.contains(listener)) {
    66                 listeners.add(listener);
    67             }
    68         }
    69     }
    70    
    71     public void removePropertyChangeListener(PropertyChangeListener listener) {
    72         synchronized(listeners) {
    73             if (listener != null && listeners.contains(listener)) {
    74                 listeners.remove(listener);
    75             }
    76         }
    77     }
    78    
    79     protected void fireFrozenChanged(boolean oldValue, boolean newValue) {
    80         synchronized(listeners) {
    81             PropertyChangeEvent evt = new PropertyChangeEvent(this, PROP_FROZEN, oldValue, newValue);
    82             for (PropertyChangeListener listener: listeners) {
    83                 listener.propertyChange(evt);
    84             }
    85         }
    86     }
    87    
    88     public void setFrozen(boolean isFrozen) {
    89         boolean oldValue = this.isFrozen;
    90         this.isFrozen = isFrozen;
    91         fireFrozenChanged(oldValue, this.isFrozen);
    92     }
    93    
    94     public boolean isFrozen() {
    95         return isFrozen;
    96     }
    97    
    98     public TableModel getMyNodesTableModel() {
    99         return myNodesTableModel;
    100     }
    101    
    102     public TableModel getTheirNodesTableModel() {
    103         return theirNodesTableModel;
    104     }
    105    
    106     public TableModel getMergedNodesTableModel() {
    107         return mergedNodesTableModel;
    108     }
    109    
    110     public ListSelectionModel getMyNodesSelectionModel() {
    111         return myNodesSelectionModel;
    112     }
    11318
    114     public ListSelectionModel getTheirNodesSelectionModel() {
    115         return theirNodesSelectionModel;
    116     }
    117    
    118     public ListSelectionModel getMergedNodesSelectionModel() {
    119         return mergedNodesSelectionModel;
    120     }
    121    
    122    
    123     protected void fireModelDataChanged() {
    124         myNodesTableModel.fireTableDataChanged();
    125         theirNodesTableModel.fireTableDataChanged();
    126         mergedNodesTableModel.fireTableDataChanged();
    127     }
    128    
    129     protected void copyNodesToTop(List<Node> source, int []rows) {
    130         if (rows == null || rows.length == 0) {
    131             return;
    132         }
    133         for (int i = rows.length - 1; i >= 0; i--) {
    134             int row = rows[i];
    135             Node n = source.get(row);
    136             mergedNodes.add(0, n);
    137         }
    138         fireModelDataChanged();
    139         mergedNodesSelectionModel.setSelectionInterval(0, rows.length -1);
    140     }
    141    
    142     /**
    143      * Copies the nodes given by indices in rows from the list of my nodes to the
    144      * list of merged nodes. Inserts the nodes at the top of the list of merged
    145      * nodes. 
    146      *
    147      * @param rows the indices
    148      */
    149     public void copyMyNodesToTop(int [] rows) {
    150         copyNodesToTop(myNodes, rows);       
    151     }
    152    
    153     /**
    154      * Copies the nodes given by indices in rows from the list of their nodes to the
    155      * list of merged nodes. Inserts the nodes at the top of the list of merged
    156      * nodes. 
    157      *
    158      * @param rows the indices
    159      */
    160     public void copyTheirNodesToTop(int [] rows) {
    161         copyNodesToTop(theirNodes, rows);       
    162     }
    163    
    164     /**
    165      * Copies the nodes given by indices in rows from the list of  nodes in source to the
    166      * list of merged nodes. Inserts the nodes at the end of the list of merged
    167      * nodes. 
    168      *
    169      * @param source the list of nodes to copy from
    170      * @param rows the indices
    171      */   
    172 
    173     public void copyNodesToEnd(List<Node> source, int [] rows) {
    174         if (rows == null || rows.length == 0) {
    175             return;
    176         }
    177         for (int row : rows) {
    178             Node n = source.get(row);
    179             mergedNodes.add(n);
    180         }
    181         fireModelDataChanged();
    182         mergedNodesSelectionModel.setSelectionInterval(mergedNodes.size()-rows.length, mergedNodes.size() -1);
    183 
    184     }
    185    
    186     /**
    187      * Copies the nodes given by indices in rows from the list of my nodes to the
    188      * list of merged nodes. Inserts the nodes at the end of the list of merged
    189      * nodes. 
    190      *
    191      * @param rows the indices
    192      */   
    193     public void copyMyNodesToEnd(int [] rows) {
    194         copyNodesToEnd(myNodes, rows);
    195     }
    196    
    197     /**
    198      * Copies the nodes given by indices in rows from the list of their nodes to the
    199      * list of merged nodes. Inserts the nodes at the end of the list of merged
    200      * nodes. 
    201      *
    202      * @param rows the indices
    203      */   
    204     public void copyTheirNodesToEnd(int [] rows) {
    205         copyNodesToEnd(theirNodes, rows);
    206     }
    207    
    208     /**
    209      * Copies the nodes given by indices in rows from the list of  nodes <code>source</code> to the
    210      * list of merged nodes. Inserts the nodes before row given by current.
    211      *
    212      * @param source the list of nodes to copy from
    213      * @param rows the indices
    214      * @param current the row index before which the nodes are inserted
    215      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    216      *
    217      */ 
    218     protected void copyNodesBeforeCurrent(List<Node> source, int [] rows, int current) {
    219         if (rows == null || rows.length == 0) {
    220             return;
    221         }
    222         if (current < 0 || current >= mergedNodes.size()) {
    223             throw new IllegalArgumentException(tr("parameter current out of range: got {0}", current));
    224         }
    225         for (int i=rows.length -1; i>=0; i--) {
    226             int row = rows[i];
    227             Node n = source.get(row);
    228             mergedNodes.add(current, n);
    229         }
    230         fireModelDataChanged();
    231         mergedNodesSelectionModel.setSelectionInterval(current, current + rows.length-1);
    232      }
    233    
    234     /**
    235      * Copies the nodes given by indices in rows from the list of my nodes to the
    236      * list of merged nodes. Inserts the nodes before row given by current.
    237      *
    238      * @param rows the indices
    239      * @param current the row index before which the nodes are inserted
    240      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    241      *
    242      */       
    243     public void copyMyNodesBeforeCurrent(int [] rows, int current) {
    244         copyNodesBeforeCurrent(myNodes,rows,current);
    245     }
    246    
    247     /**
    248      * Copies the nodes given by indices in rows from the list of their nodes to the
    249      * list of merged nodes. Inserts the nodes before row given by current.
    250      *
    251      * @param rows the indices
    252      * @param current the row index before which the nodes are inserted
    253      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    254      *
    255      */       
    256     public void copyTheirNodesBeforeCurrent(int [] rows, int current) {
    257         copyNodesBeforeCurrent(theirNodes,rows,current);
    258     }
    259    
    260     /**
    261      * Copies the nodes given by indices in rows from the list of  nodes <code>source</code> to the
    262      * list of merged nodes. Inserts the nodes after the row given by current.
    263      *
    264      * @param source the list of nodes to copy from
    265      * @param rows the indices
    266      * @param current the row index after which the nodes are inserted
    267      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    268      *
    269      */       
    270     protected void copyNodesAfterCurrent(List<Node> source, int [] rows, int current) {
    271         if (rows == null || rows.length == 0) {
    272             return;
    273         }
    274         if (current < 0 || current >= mergedNodes.size()) {
    275             throw new IllegalArgumentException(tr("parameter current out of range: got {0}", current));
    276         }
    277         if (current == mergedNodes.size() -1) {
    278             copyMyNodesToEnd(rows);
    279         } else {
    280             for (int i=rows.length -1; i>=0; i--) {
    281                 int row = rows[i];
    282                 Node n = source.get(row);
    283                 mergedNodes.add(current+1, n);
    284             }
    285         }
    286         fireModelDataChanged();   
    287         mergedNodesSelectionModel.setSelectionInterval(current+1, current + rows.length-1);
    288     }
    289    
    290     /**
    291      * Copies the nodes given by indices in rows from the list of my nodes to the
    292      * list of merged nodes. Inserts the nodes after the row given by current.
    293      *
    294      * @param rows the indices
    295      * @param current the row index after which the nodes are inserted
    296      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    297      *
    298      */       
    299     public void copyMyNodesAfterCurrent(int [] rows, int current) {
    300         copyNodesAfterCurrent(myNodes, rows, current);
    301     }
    302    
    303     /**
    304      * Copies the nodes given by indices in rows from the list of my nodes to the
    305      * list of merged nodes. Inserts the nodes after the row given by current.
    306      *
    307      * @param rows the indices
    308      * @param current the row index after which the nodes are inserted
    309      * @exception IllegalArgumentException thrown, if current < 0 or >= #nodes in list of merged nodes
    310      *
    311      */       
    312     public void copyTheirNodesAfterCurrent(int [] rows, int current) {
    313         copyNodesAfterCurrent(theirNodes, rows, current);
    314     }
    315 
    316     /**
    317      * Moves the nodes given by indices in rows  up by one position in the list
    318      * of merged nodes.
    319      *
    320      * @param rows the indices
    321      *
    322      */
    323     protected void moveUpMergedNodes(int [] rows) {
    324         if (rows == null || rows.length == 0) {
    325             return;
    326         }
    327         if (rows[0] == 0) {
    328             // can't move up
    329             return;
    330         }
    331         for (int row: rows) {
    332            Node n = mergedNodes.get(row);
    333            mergedNodes.remove(row);
    334            mergedNodes.add(row -1, n);
    335         }
    336         fireModelDataChanged();
    337         mergedNodesSelectionModel.clearSelection();
    338         for (int row: rows) {
    339             mergedNodesSelectionModel.addSelectionInterval(row-1, row-1);
    340         }
    341     }
    342 
    343     /**
    344      * Moves the nodes given by indices in rows down by one position in the list
    345      * of merged nodes.
    346      *
    347      * @param rows the indices
    348      */
    349     protected void moveDownMergedNodes(int [] rows) {
    350         if (rows == null || rows.length == 0) {
    351             return;
    352         }
    353         if (rows[rows.length -1] == mergedNodes.size() -1) {
    354             // can't move down
    355             return;
    356         }
    357         for (int i = rows.length-1; i>=0;i--) {
    358             int row = rows[i];
    359             Node n = mergedNodes.get(row);
    360             mergedNodes.remove(row);
    361             mergedNodes.add(row +1, n);
    362          }
    363         fireModelDataChanged();
    364         mergedNodesSelectionModel.clearSelection();
    365         for (int row: rows) {
    366             mergedNodesSelectionModel.addSelectionInterval(row+1, row+1);
    367         }       
    368     }
    369    
    370     /**
    371      * Removes the nodes given by indices in rows from the list
    372      * of merged nodes.
    373      *
    374      * @param rows the indices
    375      */   
    376     protected void removeMergedNodes(int [] rows) {
    377         if (rows == null || rows.length == 0) {
    378             return;
    379         }
    380         for (int i = rows.length-1; i>=0;i--) {
    381             mergedNodes.remove(rows[i]);
    382          }
    383         fireModelDataChanged();
    384         mergedNodesSelectionModel.clearSelection();
    385     }
    386    
    387 
    388     /**
    389      * Replies true if the list of my nodes and the list of their
    390      * nodes are equal, i.e. if they consists of a list of nodes with
    391      * identical ids in the same order.
    392      *
    393      * @return true, if the lists are equal; false otherwise
    394      */
    395     protected boolean myAndTheirNodesEqual() {
    396         if (myNodes.size() != theirNodes.size()) {
    397             return false;
    398         }
    399         for (int i=0; i < myNodes.size(); i++) {
    400             if (myNodes.get(i).id != theirNodes.get(i).id) {
    401                 return false;
    402             }
    403         }
    404         return true;
    405     }
    406    
    40719    /**
    40820     * Populates the model with the nodes in the two {@see Way}s <code>my</code> and
    40921     * <code>their</code>.
    410      *  
    411      * @param my  my way (i.e. the way in the local dataset) 
     22     *
     23     * @param my  my way (i.e. the way in the local dataset)
    41224     * @param their their way (i.e. the way in the server dataset)
    41325     * @exception IllegalArgumentException thrown, if my is null
     
    41527     */
    41628    public void populate(Way my, Way their) {
    417         if (my == null) 
     29        if (my == null)
    41830            throw new IllegalArgumentException("parameter 'way' must not be null");
    419         if (their == null) 
     31        if (their == null)
    42032            throw new IllegalArgumentException("parameter 'their' must not be null");
    421         mergedNodes.clear();
    422         myNodes.clear();
    423         theirNodes.clear();
     33        mergedEntries.clear();
     34        myEntries.clear();
     35        theirEntries.clear();
    42436        for (Node n : my.nodes) {
    425             myNodes.add(n);
     37            myEntries.add(n);
    42638        }
    42739        for (Node n : their.nodes) {
    428             theirNodes.add(n);
     40            theirEntries.add(n);
    42941        }
    430         if (myAndTheirNodesEqual()) {
    431             mergedNodes = new ArrayList<Node>(myNodes);
     42        if (myAndTheirEntriesEqual()) {
     43            mergedEntries = new ArrayList<Node>(myEntries);
    43244            setFrozen(true);
    43345        } else {
    43446            setFrozen(false);
    43547        }
    436        
     48
    43749        fireModelDataChanged();
    43850    }
    439    
     51
    44052    /**
    44153     * Builds the command to resolve conflicts in the node list of a way
    44254     *
    443      * @param my  my way. Must not be null. 
     55     * @param my  my way. Must not be null.
    44456     * @param their  their way. Must not be null
    44557     * @return the command
    44658     * @exception IllegalArgumentException thrown, if my is null or not a {@see Way}
    44759     * @exception IllegalArgumentException thrown, if their is null or not a {@see Way}
    448      * @exception IllegalStateException thrown, if the merge is not yet frozen 
     60     * @exception IllegalStateException thrown, if the merge is not yet frozen
    44961     */
    450     public WayNodesConflictResolverCommand buildResolveCommand(Way my, Way their) {       
    451         if (my == null) {
    452             throw new IllegalArgumentException("parameter my most not be null");           
    453         }
    454         if (their == null) {
    455             throw new IllegalArgumentException("parameter my most not be null");           
    456         }
    457         if (! isFrozen()) {
     62    public WayNodesConflictResolverCommand buildResolveCommand(Way my, Way their) {
     63        if (my == null)
     64            throw new IllegalArgumentException("parameter my most not be null");
     65        if (their == null)
     66            throw new IllegalArgumentException("parameter my most not be null");
     67        if (! isFrozen())
    45868            throw new IllegalArgumentException("merged nodes not frozen yet. Can't build resolution command");
    459         }
    460         return new WayNodesConflictResolverCommand(my, their, mergedNodes);
     69        return new WayNodesConflictResolverCommand(my, their, mergedEntries);
    46170    }
    462    
    463     class NodeListTableModel extends DefaultTableModel {
    464         private ArrayList<Node> nodes;
    465        
    466         public NodeListTableModel(ArrayList<Node> nodes) {
    467             this.nodes = nodes;
    468         }
    469        
    470         @Override
    471         public int getRowCount() {
    472             return nodes == null ? 0 : nodes.size();
    473         }
    474 
    475         @Override
    476         public Object getValueAt(int row, int column) {
    477             return nodes.get(row);           
    478         }
    479 
    480         @Override
    481         public boolean isCellEditable(int row, int column) {
    482             return false;
    483         } 
    484     }   
    48571
    48672
     73    @Override
     74    public boolean isEqualEntry(Node e1, Node e2) {
     75        return e1.id == e2.id;
     76    }
     77
     78    @Override
     79    protected void setValueAt(DefaultTableModel model, Object value, int row, int col) {
     80        // do nothing - node list tables are not editable
     81    }
     82
     83    @Override
     84    protected Node cloneEntry(Node entry) {
     85        Node n = new Node(entry.id);
     86        n.cloneFrom(entry);
     87        return n;
     88    }
    48789}
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListMerger.java

    r1626 r1631  
    11package org.openstreetmap.josm.gui.conflict.nodes;
    22
    3 import static org.openstreetmap.josm.tools.I18n.tr;
    4 
    5 import java.awt.GridBagConstraints;
    6 import java.awt.GridBagLayout;
    7 import java.awt.event.ActionEvent;
    8 import java.awt.event.ItemEvent;
    9 import java.awt.event.ItemListener;
    10 import java.beans.PropertyChangeEvent;
    11 import java.beans.PropertyChangeListener;
    12 import java.net.URL;
    133import java.util.logging.Logger;
    144
    15 import javax.swing.AbstractAction;
    16 import javax.swing.Action;
    17 import javax.swing.ImageIcon;
    18 import javax.swing.JButton;
    19 import javax.swing.JLabel;
    20 import javax.swing.JPanel;
    215import javax.swing.JScrollPane;
    226import javax.swing.JTable;
    23 import javax.swing.JToggleButton;
    24 import javax.swing.event.ListSelectionEvent;
    25 import javax.swing.event.ListSelectionListener;
    267
     8import org.openstreetmap.josm.data.osm.Node;
    279import org.openstreetmap.josm.data.osm.Way;
     10import org.openstreetmap.josm.gui.conflict.ListMerger;
    2811
    2912/**
     
    3114 *
    3215 */
    33 public class NodeListMerger extends JPanel implements PropertyChangeListener {
     16public class NodeListMerger extends ListMerger<Node> {
    3417    private static final Logger logger = Logger.getLogger(NodeListMerger.class.getName());
    35    
    36     private JTable myNodes;
    37     private JTable mergedNodes;
    38     private JTable theirNodes;
    39    
    40     private NodeListMergeModel model;
    41    
    42    
    43     private CopyStartLeftAction copyStartLeftAction;
    44     private CopyBeforeCurrentLeftAction copyBeforeCurrentLeftAction;
    45     private CopyAfterCurrentLeftAction copyAfterCurrentLeftAction;
    46     private CopyEndLeftAction copyEndLeftAction;
    4718
    48     private CopyStartRightAction copyStartRightAction;
    49     private CopyBeforeCurrentRightAction copyBeforeCurrentRightAction;
    50     private CopyAfterCurrentRightAction copyAfterCurrentRightAction;
    51     private CopyEndRightAction copyEndRightAction;
    52    
    53     private MoveUpMergedAction moveUpMergedAction;
    54     private MoveDownMergedAction moveDownMergedAction;
    55     private RemoveMergedAction removeMergedAction;
    56     private FreezeAction freezeAction;
    57    
    5819
    59    
    60     protected JScrollPane embeddInScrollPane(JTable table) {
    61         JScrollPane pane = new JScrollPane(table);
    62         pane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    63         pane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    64        return pane;
    65     }
    66    
    67     protected JScrollPane buildMyNodesTable() {
    68         myNodes  = new JTable(
    69             model.getMyNodesTableModel(),
    70             new NodeListColumnModel(
    71                new NodeListTableCellRenderer()
    72             ),
    73             model.getMyNodesSelectionModel()
    74          );
    75          myNodes.setName("table.mynodes");
    76          return embeddInScrollPane(myNodes);
     20    public NodeListMerger() {
     21        super(new NodeListMergeModel());
    7722    }
    7823
    79     protected JScrollPane buildMergedNodesTable() {
    80         mergedNodes  = new JTable(
    81             model.getMergedNodesTableModel(),
    82             new NodeListColumnModel(
    83                 new NodeListTableCellRenderer()
    84             ),
    85             model.getMergedNodesSelectionModel()
    86          );
    87          mergedNodes.setName("table.mergednodes");
    88          return embeddInScrollPane(mergedNodes);
    89     }
    90    
    91     protected JScrollPane buildTheirNodesTable() {
    92         theirNodes  = new JTable(
    93             model.getTheirNodesTableModel(),
    94             new NodeListColumnModel(
    95                 new NodeListTableCellRenderer()
    96             ),
    97             model.getTheirNodesSelectionModel()
    98          );
    99         theirNodes.setName("table.theirnodes");
    100         return embeddInScrollPane(theirNodes);
    101     }
    102    
    103     protected void wireActionsToSelectionModels() {
    104         myNodes.getSelectionModel().addListSelectionListener(copyStartLeftAction);
    105        
    106         myNodes.getSelectionModel().addListSelectionListener(copyBeforeCurrentLeftAction);
    107         mergedNodes.getSelectionModel().addListSelectionListener(copyBeforeCurrentLeftAction);
    108        
    109         myNodes.getSelectionModel().addListSelectionListener(copyAfterCurrentLeftAction);
    110         mergedNodes.getSelectionModel().addListSelectionListener(copyAfterCurrentLeftAction);
    111        
    112         myNodes.getSelectionModel().addListSelectionListener(copyEndLeftAction);
    113        
    114        
    115         theirNodes.getSelectionModel().addListSelectionListener(copyStartRightAction);
    116        
    117         theirNodes.getSelectionModel().addListSelectionListener(copyBeforeCurrentRightAction);
    118         mergedNodes.getSelectionModel().addListSelectionListener(copyBeforeCurrentRightAction);
    119        
    120         theirNodes.getSelectionModel().addListSelectionListener(copyAfterCurrentRightAction);
    121         mergedNodes.getSelectionModel().addListSelectionListener(copyAfterCurrentRightAction);
    122        
    123         theirNodes.getSelectionModel().addListSelectionListener(copyEndRightAction);     
    124        
    125         mergedNodes.getSelectionModel().addListSelectionListener(moveUpMergedAction);
    126         mergedNodes.getSelectionModel().addListSelectionListener(moveDownMergedAction);
    127         mergedNodes.getSelectionModel().addListSelectionListener(removeMergedAction);
    128     }
    129    
    130    
    131    
    132     protected JPanel buildLeftButtonPanel() {
    133         JPanel pnl = new JPanel();
    134         pnl.setLayout(new GridBagLayout());
    135         GridBagConstraints gc = new GridBagConstraints();
    136 
    137         gc.gridx = 0;
    138         gc.gridy = 0;     
    139         copyStartLeftAction = new CopyStartLeftAction();   
    140         JButton btn = new JButton(copyStartLeftAction);
    141         btn.setName("button.copystartleft");
    142         pnl.add(btn, gc);
    143        
    144         gc.gridx = 0;
    145         gc.gridy = 1;
    146         copyBeforeCurrentLeftAction = new CopyBeforeCurrentLeftAction();
    147         btn = new JButton(copyBeforeCurrentLeftAction);
    148         btn.setName("button.copybeforecurrentleft");
    149         pnl.add(btn, gc);
    150 
    151         gc.gridx = 0;
    152         gc.gridy = 2;       
    153         copyAfterCurrentLeftAction = new CopyAfterCurrentLeftAction();
    154         btn = new JButton(copyAfterCurrentLeftAction);
    155         btn.setName("button.copyaftercurrentleft");
    156         pnl.add(btn, gc);
    157        
    158         gc.gridx = 0;
    159         gc.gridy = 3;
    160         copyEndLeftAction = new CopyEndLeftAction();
    161         btn = new JButton(copyEndLeftAction);
    162         btn.setName("button.copyendleft");
    163         pnl.add(btn, gc);
    164 
    165        
    166         return pnl;
    167     }
    168    
    169     protected JPanel buildRightButtonPanel() {
    170         JPanel pnl = new JPanel();
    171         pnl.setLayout(new GridBagLayout());
    172         GridBagConstraints gc = new GridBagConstraints();
    173 
    174         gc.gridx = 0;
    175         gc.gridy = 0;     
    176         copyStartRightAction = new CopyStartRightAction();
    177         pnl.add(new JButton(copyStartRightAction), gc);
    178        
    179         gc.gridx = 0;
    180         gc.gridy = 1;
    181         copyBeforeCurrentRightAction = new CopyBeforeCurrentRightAction();
    182         pnl.add(new JButton(copyBeforeCurrentRightAction), gc);
    183 
    184         gc.gridx = 0;
    185         gc.gridy = 2;       
    186         copyAfterCurrentRightAction = new CopyAfterCurrentRightAction();
    187         pnl.add(new JButton(copyAfterCurrentRightAction), gc);
    188        
    189         gc.gridx = 0;
    190         gc.gridy = 3;
    191         copyEndRightAction = new CopyEndRightAction();
    192         pnl.add(new JButton(copyEndRightAction), gc);
    193        
    194         return pnl;
    195     }
    196    
    197     protected JPanel buildMergedListControlButtons() {
    198         JPanel pnl = new JPanel();
    199         pnl.setLayout(new GridBagLayout());
    200         GridBagConstraints gc = new GridBagConstraints();
    201 
    202         gc.gridx = 0;
    203         gc.gridy = 0;
    204         gc.gridwidth = 1;
    205         gc.gridheight = 1;
    206         gc.fill = GridBagConstraints.HORIZONTAL;
    207         gc.anchor = GridBagConstraints.CENTER; 
    208         gc.weightx = 0.3;
    209         gc.weighty = 0.0;
    210         moveUpMergedAction = new MoveUpMergedAction();
    211         pnl.add(new JButton(moveUpMergedAction), gc);
    212 
    213         gc.gridx = 1;
    214         gc.gridy = 0;
    215         moveDownMergedAction = new MoveDownMergedAction();
    216         pnl.add(new JButton(moveDownMergedAction), gc);
    217 
    218         gc.gridx = 2;
    219         gc.gridy = 0;
    220         removeMergedAction = new RemoveMergedAction();
    221         pnl.add(new JButton(removeMergedAction), gc);
    222 
    223         gc.gridx = 0;
    224         gc.gridy = 1;
    225         gc.gridwidth = 3;
    226         gc.weightx = 1.0;
    227         freezeAction = new FreezeAction();
    228         JToggleButton btn = new JToggleButton(freezeAction);
    229         btn.setName("button.freeze");
    230         btn.addItemListener(freezeAction);
    231         pnl.add(btn, gc);
    232        
    233         return pnl;
    234     }
    235        
    236    
    237     protected void build() {
    238        
    239         setLayout(new GridBagLayout());
    240         GridBagConstraints gc = new GridBagConstraints();
    241        
    242         gc.gridx = 0;
    243         gc.gridy = 0;
    244         gc.gridwidth = 1;
    245         gc.gridheight = 1;
    246         gc.fill = GridBagConstraints.NONE;
    247         gc.anchor = GridBagConstraints.CENTER; 
    248         gc.weightx = 0.0;
    249         gc.weighty = 0.0;
    250         JLabel lbl = new JLabel(tr("Nodes in my version (local dataset)"));
    251         add(lbl, gc);
    252 
    253         gc.gridx = 2;
    254         gc.gridy = 0;
    255         gc.gridwidth = 1;
    256         gc.gridheight = 1;
    257         gc.fill = GridBagConstraints.NONE;
    258         gc.anchor = GridBagConstraints.CENTER;
    259         gc.weightx = 0.0;
    260         gc.weighty = 0.0;
    261         lbl = new JLabel(tr("Merged version"));
    262         add(lbl, gc);
    263 
    264         gc.gridx = 4;
    265         gc.gridy = 0;
    266         gc.gridwidth = 1;
    267         gc.gridheight = 1;
    268         gc.fill = GridBagConstraints.NONE;
    269         gc.anchor = GridBagConstraints.CENTER;
    270         gc.weightx = 0.0;
    271         gc.weighty = 0.0;
    272         lbl = new JLabel(tr("Nodes in their version (server dataset)"));
    273         add(lbl, gc);
    274        
    275 
    276         gc.gridx = 0;
    277         gc.gridy = 1;
    278         gc.gridwidth = 1;
    279         gc.gridheight = 1;
    280         gc.fill = GridBagConstraints.BOTH;
    281         gc.anchor = GridBagConstraints.FIRST_LINE_START;
    282         gc.weightx = 0.3;
    283         gc.weighty = 1.0;
    284         add(buildMyNodesTable(), gc);
    285        
    286         gc.gridx = 1;
    287         gc.gridy = 1;
    288         gc.gridwidth = 1;
    289         gc.gridheight = 1;
    290         gc.fill = GridBagConstraints.NONE;
    291         gc.anchor = GridBagConstraints.CENTER;
    292         gc.weightx = 0.0;
    293         gc.weighty = 0.0;
    294         add(buildLeftButtonPanel(), gc);
    295        
    296         gc.gridx = 2;
    297         gc.gridy = 1;
    298         gc.gridwidth = 1;
    299         gc.gridheight = 1;
    300         gc.fill = GridBagConstraints.BOTH;
    301         gc.anchor = GridBagConstraints.FIRST_LINE_START;
    302         gc.weightx = 0.3;
    303         gc.weighty = 0.0;
    304         add(buildMergedNodesTable(), gc);
    305        
    306         gc.gridx = 3;
    307         gc.gridy = 1;
    308         gc.gridwidth = 1;
    309         gc.gridheight = 1;
    310         gc.fill = GridBagConstraints.NONE;
    311         gc.anchor = GridBagConstraints.CENTER;
    312         gc.weightx = 0.0;
    313         gc.weighty = 0.0;
    314         add(buildRightButtonPanel(), gc);
    315        
    316         gc.gridx = 4;
    317         gc.gridy = 1;
    318         gc.gridwidth = 1;
    319         gc.gridheight = 1;
    320         gc.fill = GridBagConstraints.BOTH;
    321         gc.anchor = GridBagConstraints.FIRST_LINE_START;
    322         gc.weightx = 0.3;
    323         gc.weighty = 0.0;
    324         add(buildTheirNodesTable(), gc);
    325        
    326         gc.gridx = 2;
    327         gc.gridy = 2;
    328         gc.gridwidth = 1;
    329         gc.gridheight = 1;
    330         gc.fill = GridBagConstraints.BOTH;
    331         gc.anchor = GridBagConstraints.CENTER;
    332         gc.weightx = 0.3;
    333         gc.weighty = 0.0;
    334         add(buildMergedListControlButtons(), gc);
    335                
    336         wireActionsToSelectionModels();
    337     }
    338        
    339     public NodeListMerger() {
    340         model = new NodeListMergeModel();       
    341         build();
    342         model.addPropertyChangeListener(this);
    343     }
    344    
    345     public void populate(Way my, Way their) {
    346         model.populate(my, their);
    347     }
    348    
    349     /**
    350      * Action for copying selected nodes in the list of my nodes to the list of merged
    351      * nodes. Inserts the nodes at the beginning of the list of merged nodes.
    352      *
    353      */ 
    354     abstract class AbstractNodeManipulationAction extends AbstractAction {
    355 
    356         /**
    357          * load an icon given by iconName
    358          *
    359          * @param iconName  the name of the icon (without path, i.e. <tt>copystartleft.png</tt>
    360          * @return the icon; null, if the icon was not found
    361          */
    362         protected ImageIcon getIcon(String iconName) {
    363             String fullIconName  = "/images/dialogs/conflict/" + iconName;
    364             URL imageURL   = this.getClass().getResource(fullIconName);           
    365             if (imageURL == null) {
    366                 System.out.println(tr("WARNING: failed to load resource {0}", fullIconName));
    367                 return null;
    368             }
    369             return new ImageIcon(imageURL);
    370         }
     24    @Override
     25    protected JScrollPane buildMyElementsTable() {
     26        myEntriesTable  = new JTable(
     27                model.getMyTableModel(),
     28                new NodeListColumnModel(
     29                        new NodeListTableCellRenderer()
     30                ),
     31                model.getMySelectionModel()
     32        );
     33        myEntriesTable.setName("table.mynodes");
     34        return embeddInScrollPane(myEntriesTable);
    37135    }
    37236
    373     /**
    374      * Action for copying selected nodes in the list of my nodes to the list of merged
    375      * nodes. Inserts the nodes at the beginning of the list of merged nodes.
    376      *
    377      */
    378     class CopyStartLeftAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    379 
    380         public CopyStartLeftAction() {           
    381             ImageIcon icon = getIcon("copystartleft.png");
    382             putValue(Action.SMALL_ICON, icon);
    383             if (icon == null) {
    384                 putValue(Action.NAME, tr("> top"));
    385             }
    386             putValue(Action.SHORT_DESCRIPTION, tr("Copy my selected nodes to the start of the merged node list"));
    387             setEnabled(false);
    388         }
    389 
    390         public void actionPerformed(ActionEvent arg0) {
    391             int [] rows = myNodes.getSelectedRows();
    392             model.copyMyNodesToTop(rows);           
    393         }
    394 
    395         public void valueChanged(ListSelectionEvent e) {
    396             setEnabled(!myNodes.getSelectionModel().isSelectionEmpty());           
    397         }
    398     }
    399    
    400     /**
    401      * Action for copying selected nodes in the list of my nodes to the list of merged
    402      * nodes. Inserts the nodes at the end of the list of merged nodes.
    403      *
    404      */
    405     class CopyEndLeftAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    406 
    407         public CopyEndLeftAction() {           
    408             ImageIcon icon = getIcon("copyendleft.png");
    409             putValue(Action.SMALL_ICON, icon);
    410             if (icon == null) {
    411                 putValue(Action.NAME, tr("> bottom"));
    412             }
    413             putValue(Action.SHORT_DESCRIPTION, tr("Copy my selected nodes to the end of the merged node list"));
    414             setEnabled(false);
    415         }
    416 
    417         public void actionPerformed(ActionEvent arg0) {
    418             int [] rows = myNodes.getSelectedRows();
    419             model.copyMyNodesToEnd(rows); 
    420         }
    421 
    422         public void valueChanged(ListSelectionEvent e) {
    423             setEnabled(!myNodes.getSelectionModel().isSelectionEmpty());           
    424         }
    425     }
    426    
    427     /**
    428      * Action for copying selected nodes in the list of my nodes to the list of merged
    429      * nodes. Inserts the nodes before the first selected row in the list of merged nodes.
    430      *
    431      */
    432     class CopyBeforeCurrentLeftAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    433 
    434         public CopyBeforeCurrentLeftAction() {           
    435             ImageIcon icon = getIcon("copybeforecurrentleft.png");
    436             putValue(Action.SMALL_ICON, icon);
    437             if (icon == null) {
    438                 putValue(Action.NAME, "> before");
    439             }
    440             putValue(Action.SHORT_DESCRIPTION, tr("Copy my selected nodes before the first selected node in the merged node list"));
    441             setEnabled(false);
    442         }
    443 
    444         public void actionPerformed(ActionEvent arg0) {
    445             int [] myRows = myNodes.getSelectedRows();
    446             int [] mergedRows = mergedNodes.getSelectedRows();
    447             if (mergedRows == null || mergedRows.length == 0) {
    448                 return;
    449             }
    450             int current = mergedRows[0];           
    451             model.copyMyNodesBeforeCurrent(myRows, current);           
    452         }
    453 
    454         public void valueChanged(ListSelectionEvent e) {       
    455             setEnabled(
    456                     !myNodes.getSelectionModel().isSelectionEmpty()
    457                   && ! mergedNodes.getSelectionModel().isSelectionEmpty()
    458             );           
    459         }
    460     }
    461    
    462     /**
    463      * Action for copying selected nodes in the list of my nodes to the list of merged
    464      * nodes. Inserts the nodes after the first selected row in the list of merged nodes.
    465      *
    466      */   
    467     class CopyAfterCurrentLeftAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    468 
    469         public CopyAfterCurrentLeftAction() {           
    470             ImageIcon icon = getIcon("copyaftercurrentleft.png");
    471             putValue(Action.SMALL_ICON, icon);
    472             if (icon == null) {
    473                 putValue(Action.NAME, "> after");
    474             }
    475             putValue(Action.SHORT_DESCRIPTION, tr("Copy my selected nodes after the first selected node in the merged node list"));
    476             setEnabled(false);
    477         }
    478 
    479         public void actionPerformed(ActionEvent arg0) {
    480             int [] myRows = myNodes.getSelectedRows();
    481             int [] mergedRows = mergedNodes.getSelectedRows();
    482             if (mergedRows == null || mergedRows.length == 0) {
    483                 return;
    484             }
    485             int current = mergedRows[0];           
    486             model.copyMyNodesAfterCurrent(myRows, current);                       
    487         }
    488 
    489         public void valueChanged(ListSelectionEvent e) {       
    490             setEnabled(
    491                     !myNodes.getSelectionModel().isSelectionEmpty()
    492                   && ! mergedNodes.getSelectionModel().isSelectionEmpty()
    493             );           
    494         }
    495     }
    496    
    497    
    498     class CopyStartRightAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    499 
    500         public CopyStartRightAction() {           
    501             ImageIcon icon = getIcon("copystartright.png");
    502             putValue(Action.SMALL_ICON, icon);
    503             if (icon == null) {
    504                 putValue(Action.NAME, "< top");
    505             }
    506             putValue(Action.SHORT_DESCRIPTION, tr("Copy their selected nodes to the start of the merged node list"));
    507             setEnabled(false);
    508         }
    509 
    510         public void actionPerformed(ActionEvent arg0) {
    511             int [] rows = theirNodes.getSelectedRows();
    512             model.copyTheirNodesToTop(rows);                       
    513         }
    514 
    515         public void valueChanged(ListSelectionEvent e) {
    516             setEnabled(!theirNodes.getSelectionModel().isSelectionEmpty());           
    517         }
    518     }
    519    
    520    
    521     class CopyEndRightAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    522 
    523         public CopyEndRightAction() {           
    524             ImageIcon icon = getIcon("copyendright.png");
    525             putValue(Action.SMALL_ICON, icon);
    526             if (icon == null) {
    527                 putValue(Action.NAME, "< bottom");
    528             }
    529             putValue(Action.SHORT_DESCRIPTION, tr("Copy their selected nodes to the end of the merged node list"));
    530             setEnabled(false);
    531         }
    532 
    533         public void actionPerformed(ActionEvent arg0) {
    534             int [] rows = theirNodes.getSelectedRows();
    535             model.copyTheirNodesToEnd(rows); 
    536         }
    537 
    538         public void valueChanged(ListSelectionEvent e) {
    539             setEnabled(!theirNodes.getSelectionModel().isSelectionEmpty());           
    540         }
    541     }
    542    
    543     class CopyBeforeCurrentRightAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    544 
    545         public CopyBeforeCurrentRightAction() {           
    546             ImageIcon icon = getIcon("copybeforecurrentright.png");
    547             putValue(Action.SMALL_ICON, icon);
    548             if (icon == null) {
    549                 putValue(Action.NAME, "< before");
    550             }
    551             putValue(Action.SHORT_DESCRIPTION, tr("Copy their selected nodes before the first selected node in the merged node list"));
    552             setEnabled(false);
    553         }
    554 
    555         public void actionPerformed(ActionEvent arg0) {
    556             int [] myRows = theirNodes.getSelectedRows();
    557             int [] mergedRows = mergedNodes.getSelectedRows();
    558             if (mergedRows == null || mergedRows.length == 0) {
    559                 return;
    560             }
    561             int current = mergedRows[0];           
    562             model.copyTheirNodesBeforeCurrent(myRows, current);           
    563         }
    564 
    565         public void valueChanged(ListSelectionEvent e) {       
    566             setEnabled(
    567                     !theirNodes.getSelectionModel().isSelectionEmpty()
    568                   && ! mergedNodes.getSelectionModel().isSelectionEmpty()
    569             );           
    570         }
    571     }
    572    
    573    
    574     class CopyAfterCurrentRightAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    575 
    576         public CopyAfterCurrentRightAction() {           
    577             ImageIcon icon = getIcon("copyaftercurrentright.png");
    578             putValue(Action.SMALL_ICON, icon);
    579             if (icon == null) {
    580                 putValue(Action.NAME, "< after");
    581             }
    582             putValue(Action.SHORT_DESCRIPTION, tr("Copy their selected nodes after the first selected node in the merged node list"));
    583             setEnabled(false);
    584         }
    585 
    586         public void actionPerformed(ActionEvent arg0) {
    587             int [] myRows = theirNodes.getSelectedRows();
    588             int [] mergedRows = mergedNodes.getSelectedRows();
    589             if (mergedRows == null || mergedRows.length == 0) {
    590                 return;
    591             }
    592             int current = mergedRows[0];           
    593             model.copyTheirNodesAfterCurrent(myRows, current);                       
    594         }
    595 
    596         public void valueChanged(ListSelectionEvent e) {       
    597             setEnabled(
    598                     !theirNodes.getSelectionModel().isSelectionEmpty()
    599                   && ! mergedNodes.getSelectionModel().isSelectionEmpty()
    600             );           
    601         }
    602     }
    603    
    604    
    605     class MoveUpMergedAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    606 
    607         public MoveUpMergedAction() {           
    608             ImageIcon icon = getIcon("moveup.png");
    609             putValue(Action.SMALL_ICON, icon);
    610             if (icon == null) {
    611                 putValue(Action.NAME, tr("Up"));
    612             }
    613             putValue(Action.SHORT_DESCRIPTION, tr("Move up the selected nodes by one position"));
    614             setEnabled(false);
    615         }
    616 
    617         public void actionPerformed(ActionEvent arg0) {
    618             int [] rows = mergedNodes.getSelectedRows();
    619             model.moveUpMergedNodes(rows);           
    620         }
    621 
    622         public void valueChanged(ListSelectionEvent e) {
    623             int [] rows = mergedNodes.getSelectedRows();
    624             setEnabled(
    625                     rows != null
    626                   && rows.length > 0
    627                   && rows[0] != 0
    628             );           
    629         }
    630     }
    631    
    632     class MoveDownMergedAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    633 
    634         public MoveDownMergedAction() {           
    635             ImageIcon icon = getIcon("movedown.png");
    636             putValue(Action.SMALL_ICON, icon);
    637             if (icon == null) {
    638                 putValue(Action.NAME, tr("Down"));
    639             }
    640             putValue(Action.SHORT_DESCRIPTION, tr("Move down the selected nodes by one position"));
    641             setEnabled(false);
    642         }
    643 
    644         public void actionPerformed(ActionEvent arg0) {
    645             int [] rows = mergedNodes.getSelectedRows();
    646             model.moveDownMergedNodes(rows);                       
    647         }
    648 
    649         public void valueChanged(ListSelectionEvent e) {
    650             int [] rows = mergedNodes.getSelectedRows();
    651             setEnabled(
    652                     rows != null
    653                   && rows.length > 0
    654                   && rows[rows.length -1] != mergedNodes.getRowCount() -1
    655             );           
    656         }
    657     }
    658    
    659     class RemoveMergedAction extends AbstractNodeManipulationAction implements ListSelectionListener {
    660 
    661         public RemoveMergedAction() {           
    662             ImageIcon icon = getIcon("remove.png");
    663             putValue(Action.SMALL_ICON, icon);
    664             if (icon == null) {
    665                 putValue(Action.NAME, tr("Remove"));
    666             }
    667             putValue(Action.SHORT_DESCRIPTION, tr("Remove the selected nodes from the list of merged nodes"));
    668             setEnabled(false);
    669         }
    670 
    671         public void actionPerformed(ActionEvent arg0) {
    672             int [] rows = mergedNodes.getSelectedRows();
    673             model.removeMergedNodes(rows);                       
    674         }
    675 
    676         public void valueChanged(ListSelectionEvent e) {
    677             int [] rows = mergedNodes.getSelectedRows();
    678             setEnabled(
    679                     rows != null
    680                   && rows.length > 0
    681             );           
    682         }
    683     }
    684    
    685     class FreezeAction extends AbstractNodeManipulationAction implements ItemListener  {
    686 
    687         public FreezeAction() {           
    688             // FIXME
    689 //            ImageIcon icon = getIcon("remove.png");
    690 //            putValue(Action.SMALL_ICON, icon);
    691 //            if (icon == null) {
    692 //                putValue(Action.NAME, tr("Remove"));
    693 //            }
    694             putValue(Action.NAME, tr("Freeze"));
    695             putValue(Action.SHORT_DESCRIPTION, tr("Freeze the current list of merged nodes."));
    696 //            putValue(Action.SELECTED_KEY, false);
    697             setEnabled(true);
    698            
    699         }
    700 
    701         public void actionPerformed(ActionEvent arg0) {
    702             int [] rows = mergedNodes.getSelectedRows();
    703             model.removeMergedNodes(rows);                       
    704         }
    705        
    706         public void itemStateChanged(ItemEvent e) {
    707             int state = e.getStateChange();
    708             if (state == ItemEvent.SELECTED) {
    709                 model.setFrozen(true);
    710                 putValue(Action.NAME, tr("Unfreeze"));
    711                 putValue(Action.SHORT_DESCRIPTION, tr("Unfreeze the list of merged nodes and start merging"));
    712             } else if (state == ItemEvent.DESELECTED) {
    713                 model.setFrozen(false);
    714                 putValue(Action.NAME, tr("Freeze"));
    715                 putValue(Action.SHORT_DESCRIPTION, tr("Freeze the current list of merged nodes"));
    716             }           
    717         } 
     37    @Override
     38    protected JScrollPane buildMergedElementsTable() {
     39        mergedEntriesTable  = new JTable(
     40                model.getMergedTableModel(),
     41                new NodeListColumnModel(
     42                        new NodeListTableCellRenderer()
     43                ),
     44                model.getMergedSelectionModel()
     45        );
     46        mergedEntriesTable.setName("table.mergednodes");
     47        return embeddInScrollPane(mergedEntriesTable);
    71848    }
    71949
    720     protected void handlePropertyChangeFrozen(boolean oldValue, boolean newValue) {
    721         myNodes.getSelectionModel().clearSelection();
    722         myNodes.setEnabled(!newValue);       
    723         theirNodes.getSelectionModel().clearSelection();
    724         theirNodes.setEnabled(!newValue);
    725         mergedNodes.getSelectionModel().clearSelection();
    726         mergedNodes.setEnabled(!newValue);
    727 //        freezeAction.putValue(Action.SELECTED_KEY, newValue);
     50    @Override
     51    protected JScrollPane buildTheirElementsTable() {
     52        theirEntriesTable  = new JTable(
     53                model.getTheirTableModel(),
     54                new NodeListColumnModel(
     55                        new NodeListTableCellRenderer()
     56                ),
     57                model.getTheirSelectionModel()
     58        );
     59        theirEntriesTable.setName("table.theirnodes");
     60        return embeddInScrollPane(theirEntriesTable);
    72861    }
    729    
    730     public void propertyChange(PropertyChangeEvent evt) {
    731         if (evt.getPropertyName().equals(NodeListMergeModel.PROP_FROZEN)) {
    732             handlePropertyChangeFrozen((Boolean)evt.getOldValue(), (Boolean)evt.getNewValue());
    733         }
    734        
    735     }
    736    
    737     public NodeListMergeModel getModel() {
    738         return model;
     62
     63
     64    public void populate(Way my, Way their) {
     65        ((NodeListMergeModel)model).populate(my, their);
    73966    }
    74067}
  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListTableCellRenderer.java

    r1626 r1631  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.gui.conflict.nodes;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
    35
    46import java.awt.Color;
     
    1315
    1416import org.openstreetmap.josm.data.osm.Node;
    15 import static org.openstreetmap.josm.tools.I18n.tr;
    1617
    1718/**
     
    2526
    2627    /**
    27      * Load the image icon for an OSM primitive of type node 
     28     * Load the image icon for an OSM primitive of type node
    2829     *
    29      * @return the icon; null, if not found 
     30     * @return the icon; null, if not found
    3031     */
    3132    protected ImageIcon loadIcon() {
     
    3738        return new ImageIcon(url);
    3839    }
    39    
     40
    4041    /**
    41      * constructor 
     42     * constructor
    4243     */
    4344    public NodeListTableCellRenderer() {
     
    4546        setOpaque(true);
    4647    }
    47    
     48
    4849    /**
    4950     * creates the display name for a node. The name is derived from the nodes id,
    5051     * its name (i.e. the value of the tag with key name) and its coordinates.
    51      *  
    52      * @param node  the node 
    53      * @return the display name 
     52     *
     53     * @param node  the node
     54     * @return the display name
    5455     */
    5556    protected String getDisplayName(Node node) {
    56        StringBuilder sb = new StringBuilder();
    57        if (node.get("name") != null) {
    58            sb.append(node.get("name"));
    59            sb.append("/");
    60            sb.append(node.id);
    61        } else {
    62            sb.append(node.id);
    63        }
    64        sb.append(" (");
    65        
    66        if (node.coor != null) {
    67            sb.append(COORD_FORMATTER.format(node.coor.lat()));
    68            sb.append(",");
    69            sb.append(COORD_FORMATTER.format(node.coor.lon()));
    70        } else {
    71            sb.append("?,?");
    72        }
    73        sb.append(")");
    74        return sb.toString();
     57        StringBuilder sb = new StringBuilder();
     58        if (node.get("name") != null) {
     59            sb.append(node.get("name"));
     60            sb.append("/");
     61            sb.append(node.id);
     62        } else {
     63            sb.append(node.id);
     64        }
     65        sb.append(" (");
     66
     67        if (node.coor != null) {
     68            sb.append(COORD_FORMATTER.format(node.coor.lat()));
     69            sb.append(",");
     70            sb.append(COORD_FORMATTER.format(node.coor.lon()));
     71        } else {
     72            sb.append("?,?");
     73        }
     74        sb.append(")");
     75        return sb.toString();
    7576    }
    76    
     77
    7778    /**
    78      * reset the renderer 
     79     * reset the renderer
    7980     */
    8081    protected void reset() {
     
    8283        setForeground(Color.BLACK);
    8384    }
    84    
     85
    8586    /**
    86      * render a node 
    87      * @param node the node 
     87     * render a node
     88     * @param node the node
    8889     * @param isSelected
    8990     */
     
    9192        if (isSelected) {
    9293            setBackground(BGCOLOR_SELECTED);
    93         } 
     94        }
    9495        setText(getDisplayName(node));
    9596    }
    96    
     97
    9798    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
    9899            int row, int column) {
    99        
     100
    100101        Node node = (Node)value;
    101102        reset();
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagMerger.java

    r1626 r1631  
    77import java.awt.GridBagConstraints;
    88import java.awt.GridBagLayout;
     9import java.awt.Insets;
    910import java.awt.event.ActionEvent;
    1011import java.awt.event.AdjustmentEvent;
     
    2930
    3031    private JTable mineTable;
    31     private JTable undecidedTable;
     32    private JTable mergedTable;
    3233    private JTable theirTable;
    33     private TagMergeModel model;
     34    private final TagMergeModel model;
    3435    private JButton btnKeepMine;
    3536    private JButton btnKeepTheir;
     
    4041        pane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
    4142        pane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
    42        
     43
    4344        adjustmentSynchronizer.synchronizeAdjustment(pane.getVerticalScrollBar());
    4445        return pane;
    4546    }
    46    
     47
    4748    protected JScrollPane buildMineTagTable() {
    4849        mineTable  = new JTable(
    49            model,
    50            new TagMergeColumnModel(
    51               new MineTableCellRenderer()
    52            )
     50                model,
     51                new TagMergeColumnModel(
     52                        new MineTableCellRenderer()
     53                )
    5354        );
     55        mineTable.setName("table.my");
    5456        return embeddInScrollPane(mineTable);
    5557    }
     
    5759    protected JScrollPane buildTheirTable() {
    5860        theirTable  = new JTable(
    59             model,
    60             new TagMergeColumnModel(
    61                new TheirTableCellRenderer()
    62             )
    63          );
    64          return embeddInScrollPane(theirTable);
    65     }
    66    
     61                model,
     62                new TagMergeColumnModel(
     63                        new TheirTableCellRenderer()
     64                )
     65        );
     66        theirTable.setName("table.their");
     67        return embeddInScrollPane(theirTable);
     68    }
     69
    6770    protected JScrollPane buildUndecidedTable() {
    68         undecidedTable  = new JTable(
    69             model,
    70             new TagMergeColumnModel(
    71                new UndecidedTableCellRenderer()
    72             )
    73          );
    74          return embeddInScrollPane(undecidedTable);
    75     }
    76    
     71        mergedTable  = new JTable(
     72                model,
     73                new TagMergeColumnModel(
     74                        new UndecidedTableCellRenderer()
     75                )
     76        );
     77        mergedTable.setName("table.merged");
     78        return embeddInScrollPane(mergedTable);
     79    }
     80
    7781    protected void build() {
    7882        GridBagConstraints gc = new GridBagConstraints();
    7983        setLayout(new GridBagLayout());
    80        
     84
    8185        adjustmentSynchronizer = new AdjustmentSynchronizer();
    82        
     86
    8387        gc.gridx = 0;
    8488        gc.gridy = 0;
     
    8690        gc.gridheight = 1;
    8791        gc.fill = GridBagConstraints.NONE;
    88         gc.anchor = GridBagConstraints.CENTER; 
    89         gc.weightx = 0.0;
    90         gc.weighty = 0.0;
     92        gc.anchor = GridBagConstraints.CENTER;
     93        gc.weightx = 0.0;
     94        gc.weighty = 0.0;
     95        gc.insets = new Insets(10,0,10,0);
    9196        JLabel lbl = new JLabel(tr("My version (local dataset)"));
    9297        add(lbl, gc);
     
    111116        gc.weightx = 0.0;
    112117        gc.weighty = 0.0;
     118        gc.insets = new Insets(0,0,0,0);
    113119        lbl = new JLabel(tr("Their version (server dataset)"));
    114120        add(lbl, gc);
     
    123129        gc.weighty = 1.0;
    124130        add(buildMineTagTable(), gc);
    125        
     131
    126132        gc.gridx = 1;
    127133        gc.gridy = 1;
     
    135141        mineTable.getSelectionModel().addListSelectionListener(keepMineAction);
    136142        btnKeepMine = new JButton(keepMineAction);
     143        btnKeepMine.setName("button.keepmine");
    137144        add(btnKeepMine, gc);
    138        
     145
    139146        gc.gridx = 2;
    140147        gc.gridy = 1;
     
    146153        gc.weighty = 1.0;
    147154        add(buildUndecidedTable(), gc);
    148        
     155
    149156        gc.gridx = 3;
    150157        gc.gridy = 1;
     
    157164        KeepTheirAction keepTheirAction = new KeepTheirAction();
    158165        btnKeepTheir = new JButton(keepTheirAction);
     166        btnKeepTheir.setName("button.keeptheir");
    159167        add(btnKeepTheir, gc);
    160        
     168
    161169        gc.gridx = 4;
    162170        gc.gridy = 1;
     
    169177        add(buildTheirTable(), gc);
    170178        theirTable.getSelectionModel().addListSelectionListener(keepTheirAction);
    171        
    172        
     179
     180
    173181        DoubleClickAdapter dblClickAdapter = new DoubleClickAdapter();
    174182        mineTable.addMouseListener(dblClickAdapter);
    175183        theirTable.addMouseListener(dblClickAdapter);
    176        
    177        
     184
     185
    178186        gc.gridx = 2;
    179187        gc.gridy = 2;
     
    185193        gc.weighty = 0.0;
    186194        UndecideAction undecidedAction = new UndecideAction();
    187         undecidedTable.getSelectionModel().addListSelectionListener(undecidedAction);
     195        mergedTable.getSelectionModel().addListSelectionListener(undecidedAction);
    188196        JButton btnUndecide = new JButton(undecidedAction);
     197        btnUndecide.setName("button.undecide");
    189198        add(btnUndecide, gc);
    190        
    191     }
    192    
     199
     200    }
     201
    193202    public TagMerger() {
    194203        model = new TagMergeModel();
    195204        build();
    196205    }
    197    
    198    
     206
    199207    public TagMergeModel getModel() {
    200208        return model;
    201209    }
    202    
     210
    203211    protected ImageIcon loadIcon(String name) {
    204        String path = "/images/dialogs/conflict/" + name;
    205        URL url = this.getClass().getResource(path);
    206        if (url == null) {
    207            System.out.println(tr("WARNING: failed to load resource {0}", path));
    208            return null;
    209        }
    210        return new ImageIcon(url);
    211     }
    212    
     212        String path = "/images/dialogs/conflict/" + name;
     213        URL url = this.getClass().getResource(path);
     214        if (url == null) {
     215            System.out.println(tr("WARNING: failed to load resource {0}", path));
     216            return null;
     217        }
     218        return new ImageIcon(url);
     219    }
     220
    213221    class KeepMineAction extends AbstractAction implements ListSelectionListener {
    214222
    215        
     223
    216224        public KeepMineAction() {
    217225            ImageIcon icon = loadIcon("tagkeepmine.png");
     
    225233            setEnabled(false);
    226234        }
    227        
     235
    228236        public void actionPerformed(ActionEvent arg0) {
    229237            int rows[] = mineTable.getSelectedRows();
    230             if (rows == null || rows.length == 0) {
    231                 return;
    232             }
    233             model.decide(rows, MergeDecisionType.KEEP_MINE);     
     238            if (rows == null || rows.length == 0)
     239                return;
     240            model.decide(rows, MergeDecisionType.KEEP_MINE);
    234241        }
    235242
    236243        public void valueChanged(ListSelectionEvent e) {
    237            setEnabled(mineTable.getSelectedRowCount() > 0);           
    238         }
    239     }
    240    
     244            setEnabled(mineTable.getSelectedRowCount() > 0);
     245        }
     246    }
     247
    241248    class KeepTheirAction extends AbstractAction implements ListSelectionListener {
    242        
     249
    243250        public KeepTheirAction() {
    244251            ImageIcon icon = loadIcon("tagkeeptheir.png");
     
    252259            setEnabled(false);
    253260        }
    254        
     261
    255262        public void actionPerformed(ActionEvent arg0) {
    256263            int rows[] = theirTable.getSelectedRows();
    257             if (rows == null || rows.length == 0) {
    258                 return;
    259             }
    260             model.decide(rows, MergeDecisionType.KEEP_THEIR);     
     264            if (rows == null || rows.length == 0)
     265                return;
     266            model.decide(rows, MergeDecisionType.KEEP_THEIR);
    261267        }
    262268
    263269        public void valueChanged(ListSelectionEvent e) {
    264            setEnabled(theirTable.getSelectedRowCount() > 0);           
    265         }
    266     }
    267    
     270            setEnabled(theirTable.getSelectedRowCount() > 0);
     271        }
     272    }
     273
    268274    class AdjustmentSynchronizer implements AdjustmentListener {
    269         private ArrayList<Adjustable> synchronizedAdjustables;
    270        
     275        private final ArrayList<Adjustable> synchronizedAdjustables;
     276
    271277        public AdjustmentSynchronizer() {
    272278            synchronizedAdjustables = new ArrayList<Adjustable>();
    273279        }
    274        
     280
    275281        public void synchronizeAdjustment(Adjustable adjustable) {
    276             if (adjustable == null) {
    277                 return;
    278             }
    279             if (synchronizedAdjustables.contains(adjustable)) {
    280                 return;
    281             }
     282            if (adjustable == null)
     283                return;
     284            if (synchronizedAdjustables.contains(adjustable))
     285                return;
    282286            synchronizedAdjustables.add(adjustable);
    283287            adjustable.addAdjustmentListener(this);
     
    292296        }
    293297    }
    294    
     298
    295299    class DoubleClickAdapter extends MouseAdapter {
    296300
     301        @Override
    297302        public void mouseClicked(MouseEvent e) {
    298             if (e.getClickCount() != 2) {
    299                 return;
    300             }
     303            if (e.getClickCount() != 2)
     304                return;
    301305            JTable table = null;
    302306            MergeDecisionType mergeDecision;
    303            
     307
    304308            if (e.getSource() == mineTable) {
    305                 table = (JTable)mineTable;
     309                table = mineTable;
    306310                mergeDecision = MergeDecisionType.KEEP_MINE;
    307311            } else if (e.getSource() == theirTable) {
    308                 table = (JTable)theirTable;
     312                table = theirTable;
    309313                mergeDecision = MergeDecisionType.KEEP_THEIR;
    310             } else if (e.getSource() == undecidedTable) {
    311                 table = (JTable)undecidedTable;
     314            } else if (e.getSource() == mergedTable) {
     315                table = mergedTable;
    312316                mergeDecision = MergeDecisionType.UNDECIDED;
    313             } else {
     317            } else
    314318                // double click in another component; shouldn't happen,
    315                 // but just in case
    316                 return;
    317             }
     319                // but just in case
     320                return;
    318321            int row = table.rowAtPoint(e.getPoint());
    319322            model.decide(row, mergeDecision);
    320323        }
    321     } 
    322    
     324    }
     325
    323326    class UndecideAction extends AbstractAction implements ListSelectionListener  {
    324327
     
    334337            setEnabled(false);
    335338        }
    336        
     339
    337340        public void actionPerformed(ActionEvent arg0) {
    338             int rows[] = undecidedTable.getSelectedRows();
    339             if (rows == null || rows.length == 0) {
    340                 return;
    341             }
    342             model.decide(rows, MergeDecisionType.UNDECIDED);     
     341            int rows[] = mergedTable.getSelectedRows();
     342            if (rows == null || rows.length == 0)
     343                return;
     344            model.decide(rows, MergeDecisionType.UNDECIDED);
    343345        }
    344346
    345347        public void valueChanged(ListSelectionEvent e) {
    346            setEnabled(undecidedTable.getSelectedRowCount() > 0);           
    347         }   
     348            setEnabled(mergedTable.getSelectedRowCount() > 0);
     349        }
    348350    }
    349351}
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictResolutionDialog.java

    r1627 r1631  
    1010import java.awt.Point;
    1111import java.awt.event.ActionEvent;
    12 import java.net.URL;
    1312import java.util.logging.Logger;
    1413
     
    1615import javax.swing.Action;
    1716import javax.swing.BorderFactory;
    18 import javax.swing.ImageIcon;
    1917import javax.swing.JButton;
    2018import javax.swing.JDialog;
     
    2523import org.openstreetmap.josm.command.Command;
    2624import org.openstreetmap.josm.gui.conflict.ConflictResolver;
     25import org.openstreetmap.josm.tools.ImageProvider;
    2726
     27/**
     28 * This is an extended dialog for resolving conflict between {@see OsmPrimitive}.
     29 *
     30 *
     31 */
    2832public class ConflictResolutionDialog extends JDialog {
    2933    private static final Logger logger = Logger.getLogger(ConflictResolutionDialog.class.getName());
    3034    public final static Dimension DEFAULT_SIZE = new Dimension(600,400);
    3135
     36    /** the conflict resolver component */
    3237    private ConflictResolver resolver;
    33        
     38
     39    /**
     40     * restore position and size on screen from preference settings
     41     *
     42     */
    3443    protected void restorePositionAndDimension() {
    3544        Point p = new Point();
     
    3948            p.x = Math.max(0,p.x);
    4049        } catch(Exception e) {
    41             logger.warning("unexpected value for preference conflictresolutiondialog.x, assuming 0"); 
     50            logger.warning("unexpected value for preference conflictresolutiondialog.x, assuming 0");
    4251            p.x = 0;
    4352        }
     
    4655            p.y = Math.max(0,p.y);
    4756        } catch(Exception e) {
    48             logger.warning("unexpected value for preference conflictresolutiondialog.x, assuming 0"); 
     57            logger.warning("unexpected value for preference conflictresolutiondialog.x, assuming 0");
    4958            p.y = 0;
    5059        }
     
    5362            d.width = Math.max(0,d.width);
    5463        } catch(Exception e) {
    55             logger.warning("unexpected value for preference conflictresolutiondialog.width, assuming " + DEFAULT_SIZE.width); 
     64            logger.warning("unexpected value for preference conflictresolutiondialog.width, assuming " + DEFAULT_SIZE.width);
    5665            p.y = 0;
    5766        }
     
    6069            d.height = Math.max(0,d.height);
    6170        } catch(Exception e) {
    62             logger.warning("unexpected value for preference conflictresolutiondialog.height, assuming " +  + DEFAULT_SIZE.height); 
     71            logger.warning("unexpected value for preference conflictresolutiondialog.height, assuming " +  + DEFAULT_SIZE.height);
    6372            p.y = 0;
    6473        }
    65        
     74
    6675        setLocation(p);
    6776        setSize(d);
    6877    }
    69    
     78
     79    /**
     80     * remember position and size on screen in the preferences
     81     *
     82     */
    7083    protected void rememberPositionAndDimension() {
    7184        Point p = getLocation();
    7285        Main.pref.put("conflictresolutiondialog.x", Integer.toString(p.x));
    7386        Main.pref.put("conflictresolutiondialog.y", Integer.toString(p.y));
    74        
     87
    7588        Dimension d = getSize();
    7689        Main.pref.put("conflictresolutiondialog.width", Integer.toString(d.width));
    7790        Main.pref.put("conflictresolutiondialog.height", Integer.toString(d.height));
    7891    }
    79    
     92
     93
     94    @Override
    8095    public void setVisible(boolean isVisible) {
    8196        if (isVisible){
     
    86101        super.setVisible(isVisible);
    87102    }
    88    
     103
     104    /**
     105     * builds the sub panel with the control buttons
     106     *
     107     * @return the panel
     108     */
    89109    protected JPanel buildButtonRow() {
    90110        JPanel pnl = new JPanel();
    91111        pnl.setLayout(new FlowLayout(FlowLayout.RIGHT));
    92        
     112
    93113        JButton btn = new JButton(new CancelAction());
    94114        btn.setName("button.cancel");
    95115        pnl.add(btn);
    96        
     116
    97117        btn = new JButton(new ApplyResolutionAction());
    98118        btn.setName("button.apply");
    99119        pnl.add(btn);
    100        
     120
    101121        pnl.setBorder(BorderFactory.createLoweredBevelBorder());
    102122        return pnl;
    103123    }
    104    
     124
     125    /**
     126     * builds the GUI
     127     */
    105128    protected void build() {
    106        setTitle(tr("Resolve conflicts"));
    107        getContentPane().setLayout(new BorderLayout());     
    108        
    109        resolver = new ConflictResolver();
    110        getContentPane().add(resolver, BorderLayout.CENTER);       
    111        getContentPane().add(buildButtonRow(), BorderLayout.SOUTH);       
     129        setTitle(tr("Resolve conflicts"));
     130        getContentPane().setLayout(new BorderLayout());
     131
     132        resolver = new ConflictResolver();
     133        resolver.setName("panel.conflictresolver");
     134        getContentPane().add(resolver, BorderLayout.CENTER);
     135        getContentPane().add(buildButtonRow(), BorderLayout.SOUTH);
    112136    }
    113    
    114    
     137
     138
    115139    public ConflictResolutionDialog(Component parent) {
    116140        super(JOptionPane.getFrameForComponent(parent), true /* modal */);
    117141        build();
    118142    }
    119    
     143
    120144    public ConflictResolver getConflictResolver() {
    121145        return resolver;
    122146    }
    123    
    124     protected ImageIcon getIcon(String iconPath) {
    125         URL imageURL   = this.getClass().getResource(iconPath);           
    126         if (imageURL == null) {
    127             System.out.println(tr("WARNING: failed to load resource {0}", iconPath));
    128             return null;
    129         }
    130         return new ImageIcon(imageURL);
    131     }
    132147
    133    
    134148    class CancelAction extends AbstractAction {
    135        
    136         public CancelAction() {           
     149        public CancelAction() {
    137150            putValue(Action.SHORT_DESCRIPTION, tr("Cancel conflict resolution and close the dialog"));
    138151            putValue(Action.NAME, tr("Cancel"));
    139             putValue(Action.SMALL_ICON, getIcon("/images/cancel.png"));
     152            putValue(Action.SMALL_ICON, ImageProvider.get("", "cancel"));
    140153            setEnabled(true);
    141154        }
    142155
    143        
     156
    144157        public void actionPerformed(ActionEvent arg0) {
    145158            setVisible(false);
    146         }       
    147     }   
    148    
    149     class ApplyResolutionAction extends AbstractAction {       
     159        }
     160    }
     161
     162    class ApplyResolutionAction extends AbstractAction {
    150163        public ApplyResolutionAction() {
    151164            putValue(Action.SHORT_DESCRIPTION, tr("Apply resolved conflicts and close the dialog"));
    152165            putValue(Action.NAME, tr("Apply Resolution"));
    153             putValue(Action.SMALL_ICON, getIcon("/images/dialogs/conflict.png"));
    154             setEnabled(true);           
     166            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs", "conflict"));
     167            setEnabled(true);
    155168        }
    156169
    157        
    158170        public void actionPerformed(ActionEvent arg0) {
    159171            Command cmd = resolver.buildResolveCommand();
    160172            Main.main.undoRedo.add(cmd);
    161173            setVisible(false);
    162         }       
     174        }
    163175    }
    164176}
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/nodes/NodeListMergeModelTest.java

    r1622 r1631  
    22package org.openstreetmap.josm.gui.conflict.nodes;
    33
     4import static org.fest.reflect.core.Reflection.field;
    45import static org.junit.Assert.assertEquals;
    56import static org.junit.Assert.assertTrue;
     
    89import java.beans.PropertyChangeEvent;
    910import java.beans.PropertyChangeListener;
    10 import java.lang.reflect.Field;
    1111import java.util.ArrayList;
    1212import java.util.List;
     
    1717import org.openstreetmap.josm.data.osm.Node;
    1818import org.openstreetmap.josm.data.osm.Way;
    19 import static org.fest.reflect.core.Reflection.field;
    2019
    2120public class NodeListMergeModelTest {
    22    
    23     protected List<Node> inspectNodeList(NodeListMergeModel model, String name) throws NoSuchFieldException, IllegalAccessException{
    24         Field f = NodeListMergeModel.class.getDeclaredField(name);
    25         f.setAccessible(true);
    26         Object o = f.get(model);
    27         return (List<Node>)o;
    28     }
    29    
     21
     22    protected List<Node> inspectNodeList(NodeListMergeModel model, String name) {
     23        return field(name).ofType(ArrayList.class)
     24        .in(model)
     25        .get();
     26    }
     27
    3028    protected DefaultListSelectionModel inspectListSelectionModel(NodeListMergeModel model, String name) throws NoSuchFieldException, IllegalAccessException {
    31         Field f = NodeListMergeModel.class.getDeclaredField(name);
    32         f.setAccessible(true);
    33         Object o = f.get(model);
    34         return (DefaultListSelectionModel)o;
    35        
    36     }
    37    
     29        return field(name).ofType(DefaultListSelectionModel.class)
     30        .in(model)
     31        .get();
     32    }
     33
    3834    protected void ensureSelected(DefaultListSelectionModel model, Object... idx) {
    3935        if (idx == null) return;
     
    4339                assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
    4440                break;
    45             } 
     41            }
    4642            try {
    47               int rows[] = (int[])idx[i];
    48               if (rows == null || rows.length != 2) {
    49                   fail("illegal selection range. Either null or not length 2: " + rows);
    50               }
    51               if (rows[0] > rows[1]) {
    52                   fail("illegal selection range. lower bound > upper bound ");
    53               }
    54               for (int j = rows[0]; j <= rows[1]; j++) {
    55                   assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
    56               }
     43                int rows[] = (int[])idx[i];
     44                if (rows == null || rows.length != 2) {
     45                    fail("illegal selection range. Either null or not length 2: " + rows);
     46                }
     47                if (rows[0] > rows[1]) {
     48                    fail("illegal selection range. lower bound > upper bound ");
     49                }
     50                for (int j = rows[0]; j <= rows[1]; j++) {
     51                    assertTrue("expected row " + j + " to be selected", model.isSelectedIndex(j));
     52                }
    5753            } catch(ClassCastException e) {
    5854                fail("illegal selection range:" + idx[i]);
    59             }           
     55            }
    6056        }
    6157    }
    62    
     58
    6359    @Test
    6460    public void test_copyMyNodesToTop_1() throws IllegalAccessException, NoSuchFieldException {
    6561        NodeListMergeModel model = new NodeListMergeModel();
    66        
    67         Way myWay = new Way(1);
    68         myWay.nodes.add(new Node(2));
    69         myWay.nodes.add(new Node(3));
    70         Way theirWay = new Way(1);
    71 
    72         model.populate(myWay, theirWay);
    73         model.copyMyNodesToTop(new int[]{0});
    74        
    75         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    76        
     62
     63        Way myWay = new Way(1);
     64        myWay.nodes.add(new Node(2));
     65        myWay.nodes.add(new Node(3));
     66        Way theirWay = new Way(1);
     67
     68        model.populate(myWay, theirWay);
     69        model.copyMyToTop(new int[]{0});
     70
     71        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     72
    7773        assertEquals(1, mergedNodes.size());
    7874        assertEquals(2, mergedNodes.get(0).id);
    79        
    80         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    81         ensureSelected(mergedSelection, 0);       
    82 
    83     }
    84    
    85    
     75
     76        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     77        ensureSelected(mergedSelection, 0);
     78
     79    }
     80
     81
    8682    @Test
    8783    public void test_copyMyNodesToTop_2() throws IllegalAccessException, NoSuchFieldException {
    8884        NodeListMergeModel model = new NodeListMergeModel();
    8985
    90        
    91         Way myWay = new Way(1);
    92         myWay.nodes.add(new Node(2));
    93         myWay.nodes.add(new Node(3));
    94         Way theirWay = new Way(1);
    95 
    96         model.populate(myWay, theirWay);
    97 
    98         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     86
     87        Way myWay = new Way(1);
     88        myWay.nodes.add(new Node(2));
     89        myWay.nodes.add(new Node(3));
     90        Way theirWay = new Way(1);
     91
     92        model.populate(myWay, theirWay);
     93
     94        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    9995        mergedNodes.add(new Node(1));
    10096
    101         model.copyMyNodesToTop(new int[]{0});
    102        
    103         mergedNodes = inspectNodeList(model, "mergedNodes");
     97        model.copyMyToTop(new int[]{0});
     98
     99        mergedNodes = inspectNodeList(model, "mergedEntries");
    104100        assertEquals(2, mergedNodes.size());
    105101        assertEquals(2, mergedNodes.get(0).id);
    106102        assertEquals(1, mergedNodes.get(1).id);
    107        
    108         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    109         ensureSelected(mergedSelection, 0);       
    110 
    111     }
    112    
    113    
    114 
    115    
    116    
     103
     104        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     105        ensureSelected(mergedSelection, 0);
     106
     107    }
     108
     109
     110
     111
     112
    117113    @Test
    118114    public void test_copyMyNodesToTop_3() throws IllegalAccessException, NoSuchFieldException {
    119115        NodeListMergeModel model = new NodeListMergeModel();
    120116
    121        
    122         Way myWay = new Way(1);
    123         myWay.nodes.add(new Node(2));
    124         myWay.nodes.add(new Node(3));
    125         Way theirWay = new Way(1);
    126 
    127         model.populate(myWay, theirWay);
    128 
    129         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     117
     118        Way myWay = new Way(1);
     119        myWay.nodes.add(new Node(2));
     120        myWay.nodes.add(new Node(3));
     121        Way theirWay = new Way(1);
     122
     123        model.populate(myWay, theirWay);
     124
     125        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    130126        mergedNodes.add(new Node(1));
    131127
    132         model.copyMyNodesToTop(new int[]{1}); // copy node 3
    133        
    134         mergedNodes = inspectNodeList(model, "mergedNodes");
     128        model.copyMyToTop(new int[]{1}); // copy node 3
     129
     130        mergedNodes = inspectNodeList(model, "mergedEntries");
    135131        assertEquals(2, mergedNodes.size());
    136132        assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
    137133        assertEquals(1, mergedNodes.get(1).id); // already merged node 1 at position 1
    138        
    139         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    140         ensureSelected(mergedSelection, 0);       
    141     }
    142    
     134
     135        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     136        ensureSelected(mergedSelection, 0);
     137    }
     138
    143139    @Test
    144140    public void test_copyMyNodesToTop_4() throws IllegalAccessException, NoSuchFieldException {
    145141        NodeListMergeModel model = new NodeListMergeModel();
    146142
    147        
     143
    148144        Way myWay = new Way(1);
    149145        myWay.nodes.add(new Node(2));
     
    154150        model.populate(myWay, theirWay);
    155151
    156         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     152        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    157153        mergedNodes.add(new Node(1));
    158154
    159         model.copyMyNodesToTop(new int[]{1,2}); // copy node 3 and 4
    160        
    161         mergedNodes = inspectNodeList(model, "mergedNodes");
     155        model.copyMyToTop(new int[]{1,2}); // copy node 3 and 4
     156
     157        mergedNodes = inspectNodeList(model, "mergedEntries");
    162158        assertEquals(3, mergedNodes.size());
    163159        assertEquals(3, mergedNodes.get(0).id); // my node 3 at position 0
    164160        assertEquals(4, mergedNodes.get(1).id); // my node 4 at position 1
    165161        assertEquals(1, mergedNodes.get(2).id); // already merged node 1 at position 2
    166        
    167         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    168         ensureSelected(mergedSelection, 0,1); // first two rows selected       
    169     }
    170    
    171    
     162
     163        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     164        ensureSelected(mergedSelection, 0,1); // first two rows selected
     165    }
     166
     167
    172168    @Test
    173169    public void test_copyMyNodesToEnd_1() throws IllegalAccessException, NoSuchFieldException {
    174170        NodeListMergeModel model = new NodeListMergeModel();
    175        
    176         Way myWay = new Way(1);
    177         myWay.nodes.add(new Node(2));
    178         myWay.nodes.add(new Node(3));
    179         Way theirWay = new Way(1);
    180 
    181         model.populate(myWay, theirWay);
    182         model.copyMyNodesToEnd(new int[]{0});
    183        
    184         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    185        
     171
     172        Way myWay = new Way(1);
     173        myWay.nodes.add(new Node(2));
     174        myWay.nodes.add(new Node(3));
     175        Way theirWay = new Way(1);
     176
     177        model.populate(myWay, theirWay);
     178        model.copyMyToEnd(new int[]{0});
     179
     180        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     181
    186182        assertEquals(1, mergedNodes.size());
    187183        assertEquals(2, mergedNodes.get(0).id);
    188        
    189         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    190         ensureSelected(mergedSelection, 0);       
    191     }
    192    
     184
     185        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     186        ensureSelected(mergedSelection, 0);
     187    }
     188
    193189    @Test
    194190    public void test_copyMyNodesToEnd_2() throws IllegalAccessException, NoSuchFieldException {
    195191        NodeListMergeModel model = new NodeListMergeModel();
    196        
    197         Way myWay = new Way(1);
    198         myWay.nodes.add(new Node(2));
    199         myWay.nodes.add(new Node(3));
    200         Way theirWay = new Way(1);
    201 
    202         model.populate(myWay, theirWay);
    203 
    204         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     192
     193        Way myWay = new Way(1);
     194        myWay.nodes.add(new Node(2));
     195        myWay.nodes.add(new Node(3));
     196        Way theirWay = new Way(1);
     197
     198        model.populate(myWay, theirWay);
     199
     200        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    205201        mergedNodes.add(new Node(1));
    206202
    207         model.copyMyNodesToEnd(new int[]{0});
    208        
    209         mergedNodes = inspectNodeList(model, "mergedNodes");
     203        model.copyMyToEnd(new int[]{0});
     204
     205        mergedNodes = inspectNodeList(model, "mergedEntries");
    210206        assertEquals(2, mergedNodes.size());
    211207        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
    212208        assertEquals(2, mergedNodes.get(1).id); // copied node 2 at position 1
    213        
    214         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    215         ensureSelected(mergedSelection, 1);       
    216     }
    217    
     209
     210        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     211        ensureSelected(mergedSelection, 1);
     212    }
     213
    218214    @Test
    219215    public void test_copyMyNodesToEnd_3() throws IllegalAccessException, NoSuchFieldException {
    220216        NodeListMergeModel model = new NodeListMergeModel();
    221217
    222        
    223         Way myWay = new Way(1);
    224         myWay.nodes.add(new Node(2));
    225         myWay.nodes.add(new Node(3));
    226         Way theirWay = new Way(1);
    227 
    228         model.populate(myWay, theirWay);
    229 
    230         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     218
     219        Way myWay = new Way(1);
     220        myWay.nodes.add(new Node(2));
     221        myWay.nodes.add(new Node(3));
     222        Way theirWay = new Way(1);
     223
     224        model.populate(myWay, theirWay);
     225
     226        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    231227        mergedNodes.add(new Node(1));
    232228
    233         model.copyMyNodesToEnd(new int[]{1}); // copy node 3
    234        
    235         mergedNodes = inspectNodeList(model, "mergedNodes");
     229        model.copyMyToEnd(new int[]{1}); // copy node 3
     230
     231        mergedNodes = inspectNodeList(model, "mergedEntries");
    236232        assertEquals(2, mergedNodes.size());
    237233        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
    238234        assertEquals(3, mergedNodes.get(1).id); // my node 3 at position 1
    239        
    240        
    241         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    242         ensureSelected(mergedSelection, 1);       
    243     }
    244    
     235
     236
     237        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     238        ensureSelected(mergedSelection, 1);
     239    }
     240
    245241    @Test
    246242    public void test_copyMyNodesToEnd_4() throws IllegalAccessException, NoSuchFieldException {
    247243        NodeListMergeModel model = new NodeListMergeModel();
    248244
    249        
     245
    250246        Way myWay = new Way(1);
    251247        myWay.nodes.add(new Node(2));
     
    256252        model.populate(myWay, theirWay);
    257253
    258         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     254        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    259255        mergedNodes.add(new Node(1));
    260256
    261         model.copyMyNodesToEnd(new int[]{1,2}); // copy node 3 and 4
    262        
    263         mergedNodes = inspectNodeList(model, "mergedNodes");
     257        model.copyMyToEnd(new int[]{1,2}); // copy node 3 and 4
     258
     259        mergedNodes = inspectNodeList(model, "mergedEntries");
    264260        assertEquals(3, mergedNodes.size());
    265261        assertEquals(1, mergedNodes.get(0).id); // already merged node 1 at position 0
     
    267263        assertEquals(4, mergedNodes.get(2).id); // my node 4 at position 2
    268264
    269        
    270         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    271         ensureSelected(mergedSelection, 1,2); // last two rows selected       
    272     }
    273    
     265
     266        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     267        ensureSelected(mergedSelection, 1,2); // last two rows selected
     268    }
     269
    274270    /* ----------------------------------------------------------------------------- */
    275271    /* copyMyNodesBeforeCurrent                                                      */
    276272    /* ----------------------------------------------------------------------------- */
    277    
     273
    278274    @Test
    279275    public void test_copyMyNodesBeforeCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    280276        NodeListMergeModel model = new NodeListMergeModel();
    281        
    282         Way myWay = new Way(1);
    283         myWay.nodes.add(new Node(1));
    284         myWay.nodes.add(new Node(2));
    285         Way theirWay = new Way(1);
    286 
    287         model.populate(myWay, theirWay);
    288         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    289         mergedNodes.add(new Node(10));
    290         mergedNodes.add(new Node(11));
    291         mergedNodes.add(new Node(12));
    292        
    293         model.copyMyNodesBeforeCurrent(new int[]{0}, 1);
    294                
     277
     278        Way myWay = new Way(1);
     279        myWay.nodes.add(new Node(1));
     280        myWay.nodes.add(new Node(2));
     281        Way theirWay = new Way(1);
     282
     283        model.populate(myWay, theirWay);
     284        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     285        mergedNodes.add(new Node(10));
     286        mergedNodes.add(new Node(11));
     287        mergedNodes.add(new Node(12));
     288
     289        model.copyMyBeforeCurrent(new int[]{0}, 1);
     290
    295291        assertEquals(4, mergedNodes.size());
    296         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     292        assertEquals(10, mergedNodes.get(0).id); // already merged node
    297293        assertEquals(1, mergedNodes.get(1).id);  // copied node 1 at position 1
    298         assertEquals(11, mergedNodes.get(2).id); // already merged node 
    299         assertEquals(12, mergedNodes.get(3).id); // already merged node 
    300        
    301         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    302         ensureSelected(mergedSelection, 1); // position 1 selected       
    303     }
    304    
    305    
     294        assertEquals(11, mergedNodes.get(2).id); // already merged node
     295        assertEquals(12, mergedNodes.get(3).id); // already merged node
     296
     297        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     298        ensureSelected(mergedSelection, 1); // position 1 selected
     299    }
     300
     301
    306302    @Test
    307303    public void test_copyMyNodesBeforeCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    308304        NodeListMergeModel model = new NodeListMergeModel();
    309        
    310         Way myWay = new Way(1);
    311         myWay.nodes.add(new Node(1));
    312         myWay.nodes.add(new Node(2));
    313         Way theirWay = new Way(1);
    314 
    315         model.populate(myWay, theirWay);
    316         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    317         mergedNodes.add(new Node(10));
    318         mergedNodes.add(new Node(11));
    319         mergedNodes.add(new Node(12));
    320        
    321         model.copyMyNodesBeforeCurrent(new int[]{0,1}, 0);
    322                
     305
     306        Way myWay = new Way(1);
     307        myWay.nodes.add(new Node(1));
     308        myWay.nodes.add(new Node(2));
     309        Way theirWay = new Way(1);
     310
     311        model.populate(myWay, theirWay);
     312        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     313        mergedNodes.add(new Node(10));
     314        mergedNodes.add(new Node(11));
     315        mergedNodes.add(new Node(12));
     316
     317        model.copyMyBeforeCurrent(new int[]{0,1}, 0);
     318
    323319        assertEquals(5, mergedNodes.size());
    324320        assertEquals(1, mergedNodes.get(0).id);  // copied node 1 at position 0
    325321        assertEquals(2, mergedNodes.get(1).id);  // copied node 2 at position 1
    326         assertEquals(10, mergedNodes.get(2).id); // already merged node 
    327         assertEquals(11, mergedNodes.get(3).id); // already merged node 
    328         assertEquals(12, mergedNodes.get(4).id); // already merged node 
    329        
    330         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    331         ensureSelected(mergedSelection, 0,1); // position 0 and 1 selected       
    332     }
    333    
     322        assertEquals(10, mergedNodes.get(2).id); // already merged node
     323        assertEquals(11, mergedNodes.get(3).id); // already merged node
     324        assertEquals(12, mergedNodes.get(4).id); // already merged node
     325
     326        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     327        ensureSelected(mergedSelection, 0,1); // position 0 and 1 selected
     328    }
     329
    334330    @Test
    335331    public void test_copyMyNodesBeforeCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    336332        NodeListMergeModel model = new NodeListMergeModel();
    337        
    338         Way myWay = new Way(1);
    339         myWay.nodes.add(new Node(1));
    340         myWay.nodes.add(new Node(2));
    341         Way theirWay = new Way(1);
    342 
    343         model.populate(myWay, theirWay);
    344         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    345         mergedNodes.add(new Node(10));
    346         mergedNodes.add(new Node(11));
    347         mergedNodes.add(new Node(12));
    348        
    349         try {               
    350             model.copyMyNodesBeforeCurrent(new int[]{0,1}, -1);
     333
     334        Way myWay = new Way(1);
     335        myWay.nodes.add(new Node(1));
     336        myWay.nodes.add(new Node(2));
     337        Way theirWay = new Way(1);
     338
     339        model.populate(myWay, theirWay);
     340        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     341        mergedNodes.add(new Node(10));
     342        mergedNodes.add(new Node(11));
     343        mergedNodes.add(new Node(12));
     344
     345        try {
     346            model.copyMyBeforeCurrent(new int[]{0,1}, -1);
    351347            fail("expected IllegalArgumentException");
    352348        } catch(IllegalArgumentException e) {
    353349            // OK
    354350        }
    355                
    356         try {               
    357             model.copyMyNodesBeforeCurrent(new int[]{0,1}, 3);
     351
     352        try {
     353            model.copyMyBeforeCurrent(new int[]{0,1}, 3);
    358354            fail("expected IllegalArgumentException");
    359355        } catch(IllegalArgumentException e) {
    360356            // OK
    361         }     
    362     }
    363    
     357        }
     358    }
     359
    364360    /* ----------------------------------------------------------------------------- */
    365361    /* copyMyNodesAfterCurrent                                                       */
     
    368364    public void test_copyMyNodesAfterCurrent_1() throws IllegalAccessException, NoSuchFieldException {
    369365        NodeListMergeModel model = new NodeListMergeModel();
    370        
    371         Way myWay = new Way(1);
    372         myWay.nodes.add(new Node(1));
    373         myWay.nodes.add(new Node(2));
    374         Way theirWay = new Way(1);
    375 
    376         model.populate(myWay, theirWay);
    377         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    378         mergedNodes.add(new Node(10));
    379         mergedNodes.add(new Node(11));
    380         mergedNodes.add(new Node(12));
    381        
    382         model.copyMyNodesAfterCurrent(new int[]{0}, 1);
    383                
     366
     367        Way myWay = new Way(1);
     368        myWay.nodes.add(new Node(1));
     369        myWay.nodes.add(new Node(2));
     370        Way theirWay = new Way(1);
     371
     372        model.populate(myWay, theirWay);
     373        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     374        mergedNodes.add(new Node(10));
     375        mergedNodes.add(new Node(11));
     376        mergedNodes.add(new Node(12));
     377
     378        model.copyMyAfterCurrent(new int[]{0}, 1);
     379
    384380        assertEquals(4, mergedNodes.size());
    385         assertEquals(10, mergedNodes.get(0).id); // already merged node 
    386         assertEquals(11, mergedNodes.get(1).id); // already merged node 
     381        assertEquals(10, mergedNodes.get(0).id); // already merged node
     382        assertEquals(11, mergedNodes.get(1).id); // already merged node
    387383        assertEquals(1, mergedNodes.get(2).id);  // copied node 1 at position 2
    388         assertEquals(12, mergedNodes.get(3).id); // already merged node 
    389        
    390         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    391         ensureSelected(mergedSelection, 2); // position 1 selected       
    392     }
    393    
    394    
     384        assertEquals(12, mergedNodes.get(3).id); // already merged node
     385
     386        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     387        ensureSelected(mergedSelection, 2); // position 1 selected
     388    }
     389
     390
    395391    @Test
    396392    public void test_copyMyNodesAfterCurrent_2() throws IllegalAccessException, NoSuchFieldException {
    397393        NodeListMergeModel model = new NodeListMergeModel();
    398        
    399         Way myWay = new Way(1);
    400         myWay.nodes.add(new Node(1));
    401         myWay.nodes.add(new Node(2));
    402         myWay.nodes.add(new Node(3));
    403         Way theirWay = new Way(1);
    404 
    405         model.populate(myWay, theirWay);
    406         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    407         mergedNodes.add(new Node(10));
    408         mergedNodes.add(new Node(11));
    409         mergedNodes.add(new Node(12));
    410        
    411         model.copyMyNodesAfterCurrent(new int[]{0,1}, 2);
    412                
     394
     395        Way myWay = new Way(1);
     396        myWay.nodes.add(new Node(1));
     397        myWay.nodes.add(new Node(2));
     398        myWay.nodes.add(new Node(3));
     399        Way theirWay = new Way(1);
     400
     401        model.populate(myWay, theirWay);
     402        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     403        mergedNodes.add(new Node(10));
     404        mergedNodes.add(new Node(11));
     405        mergedNodes.add(new Node(12));
     406
     407        model.copyMyAfterCurrent(new int[]{0,1}, 2);
     408
    413409        assertEquals(5, mergedNodes.size());
    414         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     410        assertEquals(10, mergedNodes.get(0).id); // already merged node
    415411        assertEquals(11, mergedNodes.get(1).id); // already merged node
    416412        assertEquals(12, mergedNodes.get(2).id); // already merged node
    417413        assertEquals(1, mergedNodes.get(3).id);  // copied node 1 at position 3
    418414        assertEquals(2, mergedNodes.get(4).id);  // copied node 2 at position 4
    419          
    420        
    421         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    422         ensureSelected(mergedSelection, 3,4); // position 3,4 selected       
    423     }
    424    
     415
     416
     417        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     418        ensureSelected(mergedSelection, 3,4); // position 3,4 selected
     419    }
     420
    425421    @Test
    426422    public void test_copyMyNodesAfterCurrent_3() throws IllegalAccessException, NoSuchFieldException {
    427423        NodeListMergeModel model = new NodeListMergeModel();
    428        
    429         Way myWay = new Way(1);
    430         myWay.nodes.add(new Node(1));
    431         myWay.nodes.add(new Node(2));
    432         myWay.nodes.add(new Node(3));
    433         Way theirWay = new Way(1);
    434 
    435         model.populate(myWay, theirWay);
    436         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    437         mergedNodes.add(new Node(10));
    438         mergedNodes.add(new Node(11));
    439         mergedNodes.add(new Node(12));
    440        
    441         model.copyMyNodesAfterCurrent(new int[]{0,2}, 0);
    442                
     424
     425        Way myWay = new Way(1);
     426        myWay.nodes.add(new Node(1));
     427        myWay.nodes.add(new Node(2));
     428        myWay.nodes.add(new Node(3));
     429        Way theirWay = new Way(1);
     430
     431        model.populate(myWay, theirWay);
     432        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     433        mergedNodes.add(new Node(10));
     434        mergedNodes.add(new Node(11));
     435        mergedNodes.add(new Node(12));
     436
     437        model.copyMyAfterCurrent(new int[]{0,2}, 0);
     438
    443439        assertEquals(5, mergedNodes.size());
    444         assertEquals(10, mergedNodes.get(0).id); // already merged node 
     440        assertEquals(10, mergedNodes.get(0).id); // already merged node
    445441        assertEquals(1, mergedNodes.get(1).id);  // copied node 1 at position 1
    446442        assertEquals(3, mergedNodes.get(2).id);  // copied node 3 at position 2
    447443        assertEquals(11, mergedNodes.get(3).id); // already merged node
    448444        assertEquals(12, mergedNodes.get(4).id); // already merged node
    449        
    450         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    451         ensureSelected(mergedSelection, 1,2); // position 1,2 selected       
    452     }
    453    
     445
     446        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     447        ensureSelected(mergedSelection, 1,2); // position 1,2 selected
     448    }
     449
    454450    @Test
    455451    public void test_copyMyNodesAfterCurrent_4() throws IllegalAccessException, NoSuchFieldException {
    456452        NodeListMergeModel model = new NodeListMergeModel();
    457        
    458         Way myWay = new Way(1);
    459         myWay.nodes.add(new Node(1));
    460         myWay.nodes.add(new Node(2));
    461         Way theirWay = new Way(1);
    462 
    463         model.populate(myWay, theirWay);
    464         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    465         mergedNodes.add(new Node(10));
    466         mergedNodes.add(new Node(11));
    467         mergedNodes.add(new Node(12));
    468        
    469         try {               
    470             model.copyMyNodesAfterCurrent(new int[]{0,1}, -1);
     453
     454        Way myWay = new Way(1);
     455        myWay.nodes.add(new Node(1));
     456        myWay.nodes.add(new Node(2));
     457        Way theirWay = new Way(1);
     458
     459        model.populate(myWay, theirWay);
     460        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     461        mergedNodes.add(new Node(10));
     462        mergedNodes.add(new Node(11));
     463        mergedNodes.add(new Node(12));
     464
     465        try {
     466            model.copyMyAfterCurrent(new int[]{0,1}, -1);
    471467            fail("expected IllegalArgumentException");
    472468        } catch(IllegalArgumentException e) {
    473469            // OK
    474470        }
    475                
    476         try {               
    477             model.copyMyNodesAfterCurrent(new int[]{0,1}, 3);
     471
     472        try {
     473            model.copyMyAfterCurrent(new int[]{0,1}, 3);
    478474            fail("expected IllegalArgumentException");
    479475        } catch(IllegalArgumentException e) {
    480476            // OK
    481         }     
    482     }
    483    
     477        }
     478    }
     479
    484480    /* ----------------------------------------------------------------------------- */
    485481    /* moveUpMergedNodes                                                       */
     
    488484    public void test_moveUpMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    489485        NodeListMergeModel model = new NodeListMergeModel();
    490        
    491         Way myWay = new Way(1);
    492         myWay.nodes.add(new Node(1));
    493         myWay.nodes.add(new Node(2));
    494         Way theirWay = new Way(1);
    495 
    496         model.populate(myWay, theirWay);
    497         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    498         mergedNodes.add(new Node(10));
    499         mergedNodes.add(new Node(11));
    500         mergedNodes.add(new Node(12));
    501        
    502         model.moveUpMergedNodes(new int[]{1});
    503                
     486
     487        Way myWay = new Way(1);
     488        myWay.nodes.add(new Node(1));
     489        myWay.nodes.add(new Node(2));
     490        Way theirWay = new Way(1);
     491
     492        model.populate(myWay, theirWay);
     493        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     494        mergedNodes.add(new Node(10));
     495        mergedNodes.add(new Node(11));
     496        mergedNodes.add(new Node(12));
     497
     498        model.moveUpMerged(new int[]{1});
     499
    504500        assertEquals(3, mergedNodes.size());
    505         assertEquals(11, mergedNodes.get(0).id); 
    506         assertEquals(10, mergedNodes.get(1).id); 
    507         assertEquals(12, mergedNodes.get(2).id);   
    508        
    509         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    510         ensureSelected(mergedSelection, 0); // position 1 selecte0       
    511     }
    512    
     501        assertEquals(11, mergedNodes.get(0).id);
     502        assertEquals(10, mergedNodes.get(1).id);
     503        assertEquals(12, mergedNodes.get(2).id);
     504
     505        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     506        ensureSelected(mergedSelection, 0); // position 1 selecte0
     507    }
     508
    513509    @Test
    514510    public void test_moveUpMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    515511        NodeListMergeModel model = new NodeListMergeModel();
    516        
    517         Way myWay = new Way(1);
    518         myWay.nodes.add(new Node(1));
    519         myWay.nodes.add(new Node(2));
    520         Way theirWay = new Way(1);
    521 
    522         model.populate(myWay, theirWay);
    523         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     512
     513        Way myWay = new Way(1);
     514        myWay.nodes.add(new Node(1));
     515        myWay.nodes.add(new Node(2));
     516        Way theirWay = new Way(1);
     517
     518        model.populate(myWay, theirWay);
     519        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    524520        mergedNodes.add(new Node(10));
    525521        mergedNodes.add(new Node(11));
     
    527523        mergedNodes.add(new Node(13));
    528524        mergedNodes.add(new Node(14));
    529        
    530         model.moveUpMergedNodes(new int[]{1,4});
    531                
     525
     526        model.moveUpMerged(new int[]{1,4});
     527
    532528        assertEquals(5, mergedNodes.size());
    533         assertEquals(11, mergedNodes.get(0).id); 
    534         assertEquals(10, mergedNodes.get(1).id); 
    535         assertEquals(12, mergedNodes.get(2).id);   
     529        assertEquals(11, mergedNodes.get(0).id);
     530        assertEquals(10, mergedNodes.get(1).id);
     531        assertEquals(12, mergedNodes.get(2).id);
    536532        assertEquals(14, mergedNodes.get(3).id);
    537533        assertEquals(13, mergedNodes.get(4).id);
    538        
    539         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    540         ensureSelected(mergedSelection, 0,3); // position 0 and 3 selecte0       
    541     }
    542    
     534
     535        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     536        ensureSelected(mergedSelection, 0,3); // position 0 and 3 selecte0
     537    }
     538
    543539    @Test
    544540    public void test_moveUpMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    545541        NodeListMergeModel model = new NodeListMergeModel();
    546        
    547         Way myWay = new Way(1);
    548         myWay.nodes.add(new Node(1));
    549         myWay.nodes.add(new Node(2));
    550         Way theirWay = new Way(1);
    551 
    552         model.populate(myWay, theirWay);
    553         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     542
     543        Way myWay = new Way(1);
     544        myWay.nodes.add(new Node(1));
     545        myWay.nodes.add(new Node(2));
     546        Way theirWay = new Way(1);
     547
     548        model.populate(myWay, theirWay);
     549        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    554550        mergedNodes.add(new Node(10));
    555551        mergedNodes.add(new Node(11));
     
    557553        mergedNodes.add(new Node(13));
    558554        mergedNodes.add(new Node(14));
    559        
    560         model.moveUpMergedNodes(new int[]{1,2,3,4});
    561                
     555
     556        model.moveUpMerged(new int[]{1,2,3,4});
     557
    562558        assertEquals(5, mergedNodes.size());
    563         assertEquals(11, mergedNodes.get(0).id); 
    564         assertEquals(12, mergedNodes.get(1).id);   
     559        assertEquals(11, mergedNodes.get(0).id);
     560        assertEquals(12, mergedNodes.get(1).id);
    565561        assertEquals(13, mergedNodes.get(2).id);
    566562        assertEquals(14, mergedNodes.get(3).id);
    567         assertEquals(10, mergedNodes.get(4).id); 
    568        
    569         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    570         ensureSelected(mergedSelection, 0,1,2,3);         
    571     }
    572    
     563        assertEquals(10, mergedNodes.get(4).id);
     564
     565        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     566        ensureSelected(mergedSelection, 0,1,2,3);
     567    }
     568
    573569    /* ----------------------------------------------------------------------------- */
    574570    /* moveDownMergedNodes                                                       */
     
    577573    public void test_moveDownMergedNodes_1() throws IllegalAccessException, NoSuchFieldException {
    578574        NodeListMergeModel model = new NodeListMergeModel();
    579        
    580         Way myWay = new Way(1);
    581         myWay.nodes.add(new Node(1));
    582         myWay.nodes.add(new Node(2));
    583         Way theirWay = new Way(1);
    584 
    585         model.populate(myWay, theirWay);
    586         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
    587         mergedNodes.add(new Node(10));
    588         mergedNodes.add(new Node(11));
    589         mergedNodes.add(new Node(12));
    590        
    591         model.moveDownMergedNodes(new int[]{1});
    592                
     575
     576        Way myWay = new Way(1);
     577        myWay.nodes.add(new Node(1));
     578        myWay.nodes.add(new Node(2));
     579        Way theirWay = new Way(1);
     580
     581        model.populate(myWay, theirWay);
     582        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
     583        mergedNodes.add(new Node(10));
     584        mergedNodes.add(new Node(11));
     585        mergedNodes.add(new Node(12));
     586
     587        model.moveDownMerged(new int[]{1});
     588
    593589        assertEquals(3, mergedNodes.size());
    594         assertEquals(10, mergedNodes.get(0).id); 
    595         assertEquals(12, mergedNodes.get(1).id); 
    596         assertEquals(11, mergedNodes.get(2).id);   
    597        
    598         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    599         ensureSelected(mergedSelection, 2);       
    600     }
    601    
     590        assertEquals(10, mergedNodes.get(0).id);
     591        assertEquals(12, mergedNodes.get(1).id);
     592        assertEquals(11, mergedNodes.get(2).id);
     593
     594        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     595        ensureSelected(mergedSelection, 2);
     596    }
     597
    602598    @Test
    603599    public void test_moveDownMergedNodes_2() throws IllegalAccessException, NoSuchFieldException {
    604600        NodeListMergeModel model = new NodeListMergeModel();
    605        
    606         Way myWay = new Way(1);
    607         myWay.nodes.add(new Node(1));
    608         myWay.nodes.add(new Node(2));
    609         Way theirWay = new Way(1);
    610 
    611         model.populate(myWay, theirWay);
    612         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     601
     602        Way myWay = new Way(1);
     603        myWay.nodes.add(new Node(1));
     604        myWay.nodes.add(new Node(2));
     605        Way theirWay = new Way(1);
     606
     607        model.populate(myWay, theirWay);
     608        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    613609        mergedNodes.add(new Node(10));
    614610        mergedNodes.add(new Node(11));
     
    616612        mergedNodes.add(new Node(13));
    617613        mergedNodes.add(new Node(14));
    618        
    619         model.moveDownMergedNodes(new int[]{1,3});
    620                
     614
     615        model.moveDownMerged(new int[]{1,3});
     616
    621617        assertEquals(5, mergedNodes.size());
    622         assertEquals(10, mergedNodes.get(0).id); 
    623         assertEquals(12, mergedNodes.get(1).id); 
    624         assertEquals(11, mergedNodes.get(2).id);   
     618        assertEquals(10, mergedNodes.get(0).id);
     619        assertEquals(12, mergedNodes.get(1).id);
     620        assertEquals(11, mergedNodes.get(2).id);
    625621        assertEquals(14, mergedNodes.get(3).id);
    626622        assertEquals(13, mergedNodes.get(4).id);
    627        
    628         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    629         ensureSelected(mergedSelection, 2,4);         
    630     }
    631    
     623
     624        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     625        ensureSelected(mergedSelection, 2,4);
     626    }
     627
    632628    @Test
    633629    public void test_moveDownMergedNodes_3() throws IllegalAccessException, NoSuchFieldException {
    634630        NodeListMergeModel model = new NodeListMergeModel();
    635        
    636         Way myWay = new Way(1);
    637         myWay.nodes.add(new Node(1));
    638         myWay.nodes.add(new Node(2));
    639         Way theirWay = new Way(1);
    640 
    641         model.populate(myWay, theirWay);
    642         List<Node> mergedNodes = inspectNodeList(model, "mergedNodes");
     631
     632        Way myWay = new Way(1);
     633        myWay.nodes.add(new Node(1));
     634        myWay.nodes.add(new Node(2));
     635        Way theirWay = new Way(1);
     636
     637        model.populate(myWay, theirWay);
     638        List<Node> mergedNodes = inspectNodeList(model, "mergedEntries");
    643639        mergedNodes.add(new Node(10));
    644640        mergedNodes.add(new Node(11));
     
    646642        mergedNodes.add(new Node(13));
    647643        mergedNodes.add(new Node(14));
    648        
    649         model.moveDownMergedNodes(new int[]{1,2,3});
    650                
     644
     645        model.moveDownMerged(new int[]{1,2,3});
     646
    651647        assertEquals(5, mergedNodes.size());
    652         assertEquals(10, mergedNodes.get(0).id); 
    653         assertEquals(14, mergedNodes.get(1).id);   
     648        assertEquals(10, mergedNodes.get(0).id);
     649        assertEquals(14, mergedNodes.get(1).id);
    654650        assertEquals(11, mergedNodes.get(2).id);
    655651        assertEquals(12, mergedNodes.get(3).id);
    656         assertEquals(13, mergedNodes.get(4).id); 
    657        
    658         DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedNodesSelectionModel");
    659         ensureSelected(mergedSelection, 2,3,4);         
    660     }
    661    
     652        assertEquals(13, mergedNodes.get(4).id);
     653
     654        DefaultListSelectionModel mergedSelection = inspectListSelectionModel(model, "mergedEntriesSelectionModel");
     655        ensureSelected(mergedSelection, 2,3,4);
     656    }
     657
    662658    /* ----------------------------------------------------------------------------- */
    663659    /* PropertyChangeListener                                                        */
     
    666662    public void addPropertyChangeListener() {
    667663        NodeListMergeModel model = new NodeListMergeModel();
    668        
     664
    669665        PropertyChangeListener listener = new PropertyChangeListener() {
    670             @Override
     666
    671667            public void propertyChange(PropertyChangeEvent evt) {
    672668            }
    673669        };
    674        
     670
    675671        model.addPropertyChangeListener(listener);
    676        
     672
    677673        ArrayList<PropertyChangeListener> listeners = field("listeners")
    678           .ofType(ArrayList.class)
    679           .in(model)
    680           .get();
    681        
     674        .ofType(ArrayList.class)
     675        .in(model)
     676        .get();
     677
    682678        assertEquals(1, listeners.size());
    683679        assertEquals(listener, listeners.get(0));
    684680    }
    685    
     681
    686682    @Test
    687683    public void removePropertyChangeListener() {
    688684        NodeListMergeModel model = new NodeListMergeModel();
    689        
     685
    690686        PropertyChangeListener listener = new PropertyChangeListener() {
    691             @Override
     687
    692688            public void propertyChange(PropertyChangeEvent evt) {
    693689            }
    694690        };
    695        
     691
    696692        model.addPropertyChangeListener(listener);
    697693        model.removePropertyChangeListener(listener);
    698        
     694
    699695        ArrayList<PropertyChangeListener> listeners = field("listeners")
    700           .ofType(ArrayList.class)
    701           .in(model)
    702           .get();
    703        
     696        .ofType(ArrayList.class)
     697        .in(model)
     698        .get();
     699
    704700        assertEquals(0, listeners.size());
    705701    }
    706    
     702
    707703    /* ----------------------------------------------------------------------------- */
    708704    /* property frozen                                                               */
     
    721717    public void setFrozenWithPropertyChangeNotification() {
    722718        NodeListMergeModel model = new NodeListMergeModel();
    723        
     719
    724720        class MyListener implements PropertyChangeListener {
    725721            public ArrayList<PropertyChangeEvent> events = new ArrayList<PropertyChangeEvent>();
    726             @Override
     722
    727723            public void propertyChange(PropertyChangeEvent evt) {
    728724                events.add(evt);
     
    734730        model.setFrozen(!oldValue);
    735731        assertEquals(!oldValue, model.isFrozen());
    736        
     732
    737733        assertEquals(1, listener.events.size());
    738734        assertEquals(oldValue, listener.events.get(0).getOldValue());
  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/tags/TagMergeModelTest.java

    r1622 r1631  
    1919        TagMergeModel model = new TagMergeModel();
    2020    }
    21    
     21
    2222    @Test
    2323    public void addPropertyChangeListener() {
    2424        TagMergeModel model = new TagMergeModel();
    2525        PropertyChangeListener listener = new PropertyChangeListener() {
    26             @Override
     26
    2727            public void propertyChange(PropertyChangeEvent evt) {
    2828            }
    2929        };
    3030        model.addPropertyChangeListener(listener);
    31        
     31
    3232        ArrayList list = field("listeners").ofType(ArrayList.class)
    33            .in(model)
    34            .get();
    35        
    36         assertEquals(1, list.size());
    37         assertEquals(listener, list.get(0));       
    38     }
    39    
     33        .in(model)
     34        .get();
     35
     36        assertEquals(1, list.size());
     37        assertEquals(listener, list.get(0));
     38    }
     39
    4040    @Test
    4141    public void removePropertyChangeListener() {
    4242        TagMergeModel model = new TagMergeModel();
    4343        PropertyChangeListener listener = new PropertyChangeListener() {
    44             @Override
     44
    4545            public void propertyChange(PropertyChangeEvent evt) {
    4646            }
     
    4848        model.addPropertyChangeListener(listener);
    4949        model.removePropertyChangeListener(listener);
    50        
     50
    5151        ArrayList list = field("listeners")
    52             .ofType(ArrayList.class)
    53             .in(model)
    54             .get();
    55      
    56          assertEquals(0, list.size());       
    57     }
    58    
     52        .ofType(ArrayList.class)
     53        .in(model)
     54        .get();
     55
     56        assertEquals(0, list.size());
     57    }
     58
    5959    @Test
    6060    public void populateNoConflichts() {
     
    6363        TagMergeModel model = new TagMergeModel();
    6464        model.populate(my, their);
    65        
    66         ArrayList<TagMergeItem> list = field("tagMergeItems")
    67             .ofType(ArrayList.class)
    68             .in(model)
    69             .get();
    70        
     65
     66        ArrayList<TagMergeItem> list = field("tagMergeItems")
     67        .ofType(ArrayList.class)
     68        .in(model)
     69        .get();
     70
    7171        assertEquals(0, list.size());
    7272    }
    73    
     73
    7474    @Test
    7575    public void populateNoConflicts1() {
     
    8080        TagMergeModel model = new TagMergeModel();
    8181        model.populate(my, their);
    82        
    83         ArrayList<TagMergeItem> list = field("tagMergeItems")
    84             .ofType(ArrayList.class)
    85             .in(model)
    86             .get();
    87        
     82
     83        ArrayList<TagMergeItem> list = field("tagMergeItems")
     84        .ofType(ArrayList.class)
     85        .in(model)
     86        .get();
     87
    8888        assertEquals(0, list.size());
    8989    }
    90    
     90
    9191    @Test
    9292    public void populateMissingKeyMine() {
     
    9696        TagMergeModel model = new TagMergeModel();
    9797        model.populate(my, their);
    98        
    99         ArrayList<TagMergeItem> list = field("tagMergeItems")
    100             .ofType(ArrayList.class)
    101             .in(model)
    102             .get();
    103        
     98
     99        ArrayList<TagMergeItem> list = field("tagMergeItems")
     100        .ofType(ArrayList.class)
     101        .in(model)
     102        .get();
     103
    104104        assertEquals(1, list.size());
    105105        TagMergeItem item = list.get(0);
     
    109109        assertEquals("value", item.getTheirTagValue());
    110110    }
    111    
     111
    112112    @Test
    113113    public void populateMissingKeyTheir() {
    114114        Node my = new Node(1);
    115115        my.put("key", "value");
    116         Node their = new Node(1);       
    117         TagMergeModel model = new TagMergeModel();
    118         model.populate(my, their);
    119        
    120         ArrayList<TagMergeItem> list = field("tagMergeItems")
    121             .ofType(ArrayList.class)
    122             .in(model)
    123             .get();
    124        
     116        Node their = new Node(1);
     117        TagMergeModel model = new TagMergeModel();
     118        model.populate(my, their);
     119
     120        ArrayList<TagMergeItem> list = field("tagMergeItems")
     121        .ofType(ArrayList.class)
     122        .in(model)
     123        .get();
     124
    125125        assertEquals(1, list.size());
    126126        TagMergeItem item = list.get(0);
     
    130130        assertEquals("value", item.getMyTagValue());
    131131    }
    132    
     132
    133133    @Test
    134134    public void populateConflictingValues() {
     
    139139        TagMergeModel model = new TagMergeModel();
    140140        model.populate(my, their);
    141        
    142         ArrayList<TagMergeItem> list = field("tagMergeItems")
    143             .ofType(ArrayList.class)
    144             .in(model)
    145             .get();
    146        
     141
     142        ArrayList<TagMergeItem> list = field("tagMergeItems")
     143        .ofType(ArrayList.class)
     144        .in(model)
     145        .get();
     146
    147147        assertEquals(1, list.size());
    148148        TagMergeItem item = list.get(0);
     
    152152        assertEquals("theirvalue", item.getTheirTagValue());
    153153    }
    154    
     154
    155155    @Test
    156156    public void addItem() {
     
    158158        TagMergeModel model = new TagMergeModel();
    159159        model.addItem(item);
    160        
    161         ArrayList<TagMergeItem> list = field("tagMergeItems")
    162             .ofType(ArrayList.class)
    163             .in(model)
    164             .get();
    165        
     160
     161        ArrayList<TagMergeItem> list = field("tagMergeItems")
     162        .ofType(ArrayList.class)
     163        .in(model)
     164        .get();
     165
    166166        assertEquals(1, list.size());
    167167        item = list.get(0);
     
    171171        assertEquals("theirvalue", item.getTheirTagValue());
    172172    }
    173    
     173
    174174    @Test
    175175    public void decide() {
     
    177177        TagMergeModel model = new TagMergeModel();
    178178        model.addItem(item);
    179              
    180         ArrayList<TagMergeItem> list = field("tagMergeItems")
    181             .ofType(ArrayList.class)
    182             .in(model)
    183             .get();
    184        
    185         model.decide(0, MergeDecisionType.KEEP_MINE); 
     179
     180        ArrayList<TagMergeItem> list = field("tagMergeItems")
     181        .ofType(ArrayList.class)
     182        .in(model)
     183        .get();
     184
     185        model.decide(0, MergeDecisionType.KEEP_MINE);
    186186        assertEquals(1, list.size());
    187187        item = list.get(0);
    188188        assertEquals(MergeDecisionType.KEEP_MINE, item.getMergeDecision());
    189        
    190         model.decide(0, MergeDecisionType.KEEP_THEIR); 
     189
     190        model.decide(0, MergeDecisionType.KEEP_THEIR);
    191191        assertEquals(1, list.size());
    192192        item = list.get(0);
    193193        assertEquals(MergeDecisionType.KEEP_THEIR, item.getMergeDecision());
    194        
    195         model.decide(0, MergeDecisionType.UNDECIDED); 
    196         assertEquals(1, list.size());
    197         item = list.get(0);
    198         assertEquals(MergeDecisionType.UNDECIDED, item.getMergeDecision());
    199     }
    200    
     194
     195        model.decide(0, MergeDecisionType.UNDECIDED);
     196        assertEquals(1, list.size());
     197        item = list.get(0);
     198        assertEquals(MergeDecisionType.UNDECIDED, item.getMergeDecision());
     199    }
     200
    201201    @Test
    202202    public void decideMultiple() {
    203        
     203
    204204        TagMergeItem item = new TagMergeItem("key", "myvalue", "theirvalue");
    205205        TagMergeModel model = new TagMergeModel();
     
    207207            model.addItem(new TagMergeItem("key-" + i, "myvalue-" + i, "theirvalue-" +i));
    208208        }
    209              
    210         ArrayList<TagMergeItem> list = field("tagMergeItems")
    211             .ofType(ArrayList.class)
    212             .in(model)
    213             .get();
    214        
     209
     210        ArrayList<TagMergeItem> list = field("tagMergeItems")
     211        .ofType(ArrayList.class)
     212        .in(model)
     213        .get();
     214
    215215        assertEquals(10, list.size());
    216        
    217         model.decide(new int[] {0, 3, 5}, MergeDecisionType.KEEP_MINE); 
     216
     217        model.decide(new int[] {0, 3, 5}, MergeDecisionType.KEEP_MINE);
    218218        for (int i = 0; i< 10; i++) {
    219219            item = list.get(i);
Note: See TracChangeset for help on using the changeset viewer.