Changeset 1654 in josm


Ignore:
Timestamp:
Jun 7, 2009 11:22:54 PM (4 years ago)
Author:
Gubaer
Message:

added merge support for coordinate conflicts
added merge support for conflicts due to different deleted states

Location:
trunk
Files:
5 added
14 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/command/TagConflictResolveCommand.java

    r1642 r1654  
    1616import org.openstreetmap.josm.data.osm.Relation; 
    1717import org.openstreetmap.josm.data.osm.Way; 
    18 import org.openstreetmap.josm.gui.conflict.tags.MergeDecisionType; 
     18import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    1919import org.openstreetmap.josm.gui.conflict.tags.TagMergeItem; 
    2020import org.openstreetmap.josm.tools.ImageProvider; 
    … …  
    121121        // 
    122122        if (!Main.map.conflictDialog.conflicts.containsKey(my)) { 
    123             Main.map.conflictDialog.conflicts.put(my,their); 
     123            Main.map.conflictDialog.addConflict(my, their); 
    124124        } 
    125125    } 
    126  
    127  
    128126} 

  • trunk/src/org/openstreetmap/josm/command/VersionConflictResolveCommand.java

    r1642 r1654  
    8686        } 
    8787    } 
    88  
    89  
    9088} 

  • trunk/src/org/openstreetmap/josm/command/WayNodesConflictResolverCommand.java

    r1622 r1654  
    2525 
    2626    /** my way */ 
    27     private Way my; 
    28     /** their way */  
    29     private Way their; 
     27    private final Way my; 
     28    /** their way */ 
     29    private final Way their; 
    3030    /** the list of merged nodes. This becomes the list of news of my way after the 
    3131     *  command is executed 
    3232     */ 
    33     private List<Node> mergedNodeList;  
    34      
     33    private final List<Node> mergedNodeList; 
     34 
    3535    /** 
    3636     *  
    3737     * @param my my may 
    3838     * @param their their way 
    39      * @param mergedNodeList  the list of merged nodes  
     39     * @param mergedNodeList  the list of merged nodes 
    4040     */ 
    4141    public WayNodesConflictResolverCommand(Way my, Way their, List<Node> mergedNodeList) { 
    … …  
    4444        this.mergedNodeList = mergedNodeList; 
    4545    } 
    46      
    47      
     46 
     47 
    4848    @Override 
    4949    public MutableTreeNode description() { 
    5050        return new DefaultMutableTreeNode( 
    5151                new JLabel( 
    52                    tr("Resolve conflicts in node list of of way {0}", my.id),  
    53                    ImageProvider.get("data", "object"),  
    54                    JLabel.HORIZONTAL 
     52                        tr("Resolve conflicts in node list of of way {0}", my.id), 
     53                        ImageProvider.get("data", "object"), 
     54                        JLabel.HORIZONTAL 
    5555                ) 
    56          ); 
     56        ); 
    5757    } 
    5858 
    … …  
    6262        // 
    6363        super.executeCommand(); 
    64          
     64 
    6565        // replace the list of nodes of 'my' way by the list of merged 
    66         // nodes  
     66        // nodes 
    6767        // 
    6868        my.nodes.clear(); 
    … …  
    7474            } 
    7575        } 
    76         return true;         
     76        return true; 
    7777    } 
    7878 
    … …  
    8080    public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, 
    8181            Collection<OsmPrimitive> added) { 
    82         modified.add(my);         
     82        modified.add(my); 
    8383    } 
    8484 
    … …  
    8888        // 
    8989        super.undoCommand(); 
    90          
     90 
    9191        // restore a conflict if necessary 
    9292        // 
    9393        if (!Main.map.conflictDialog.conflicts.containsKey(my)) { 
    94             Main.map.conflictDialog.conflicts.put(my,their); 
     94            Main.map.conflictDialog.addConflict(my, their); 
    9595        } 
    9696    } 

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

    r1650 r1654  
    1616import org.openstreetmap.josm.command.Command; 
    1717import org.openstreetmap.josm.command.SequenceCommand; 
    18 import org.openstreetmap.josm.command.TagConflictResolveCommand; 
    1918import org.openstreetmap.josm.command.VersionConflictResolveCommand; 
    2019import org.openstreetmap.josm.data.osm.Node; 
    … …  
    2423import org.openstreetmap.josm.gui.conflict.nodes.NodeListMergeModel; 
    2524import org.openstreetmap.josm.gui.conflict.nodes.NodeListMerger; 
     25import org.openstreetmap.josm.gui.conflict.properties.PropertiesMergeModel; 
     26import org.openstreetmap.josm.gui.conflict.properties.PropertiesMerger; 
    2627import org.openstreetmap.josm.gui.conflict.relation.RelationMemberListMergeModel; 
    2728import org.openstreetmap.josm.gui.conflict.relation.RelationMemberMerger; 
    … …  
    4243    private NodeListMerger nodeListMerger; 
    4344    private RelationMemberMerger relationMemberMerger; 
     45    private PropertiesMerger propertiesMerger; 
    4446    private OsmPrimitive my; 
    4547    private OsmPrimitive their; 
    … …  
    5658        tabbedPane = new JTabbedPane(); 
    5759 
     60        propertiesMerger = new PropertiesMerger(); 
     61        propertiesMerger.setName("panel.propertiesmerger"); 
     62        propertiesMerger.getModel().addPropertyChangeListener(this); 
     63        tabbedPane.add(tr("Properties"), propertiesMerger); 
     64 
    5865        tagMerger = new TagMerger(); 
    5966        tagMerger.setName("panel.tagmerger"); 
    6067        tagMerger.getModel().addPropertyChangeListener(this); 
    61         tabbedPane.add("Tags", tagMerger); 
     68        tabbedPane.add(tr("Tags"), tagMerger); 
    6269 
    6370        nodeListMerger = new NodeListMerger(); 
    6471        nodeListMerger.setName("panel.nodelistmerger"); 
    6572        nodeListMerger.getModel().addPropertyChangeListener(this); 
    66         tabbedPane.add("Nodes", nodeListMerger); 
     73        tabbedPane.add(tr("Nodes"), nodeListMerger); 
    6774 
    6875        relationMemberMerger = new RelationMemberMerger(); 
    6976        relationMemberMerger.setName("panel.relationmembermerger"); 
    7077        relationMemberMerger.getModel().addPropertyChangeListener(this); 
    71         tabbedPane.add("Members", relationMemberMerger); 
     78        tabbedPane.add(tr("Members"), relationMemberMerger); 
    7279 
    7380        setLayout(new BorderLayout()); 
    … …  
    8188 
    8289    public void propertyChange(PropertyChangeEvent evt) { 
    83  
    8490        if (evt.getPropertyName().equals(TagMergeModel.PROP_NUM_UNDECIDED_TAGS)) { 
    8591            int newValue = (Integer)evt.getNewValue(); 
    8692            if (newValue == 0) { 
    87                 tabbedPane.setTitleAt(0, tr("Tags")); 
    88                 tabbedPane.setToolTipTextAt(0, tr("No pending tag conflicts to be resolved")); 
    89                 tabbedPane.setIconAt(0, mergeComplete); 
    90             } else { 
    91                 tabbedPane.setTitleAt(0, tr("Tags({0} conflicts)", newValue)); 
    92                 tabbedPane.setToolTipTextAt(0, tr("{0} pending tag conflicts to be resolved")); 
    93                 tabbedPane.setIconAt(0, mergeIncomplete); 
     93                tabbedPane.setTitleAt(1, tr("Tags")); 
     94                tabbedPane.setToolTipTextAt(1, tr("No pending tag conflicts to be resolved")); 
     95                tabbedPane.setIconAt(1, mergeComplete); 
     96            } else { 
     97                tabbedPane.setTitleAt(1, tr("Tags({0} conflicts)", newValue)); 
     98                tabbedPane.setToolTipTextAt(1, tr("{0} pending tag conflicts to be resolved")); 
     99                tabbedPane.setIconAt(1, mergeIncomplete); 
    94100            } 
    95101        } else if (evt.getPropertyName().equals(ListMergeModel.FROZEN_PROP)) { 
    96102            boolean frozen = (Boolean)evt.getNewValue(); 
    97103            if (frozen && evt.getSource() == nodeListMerger.getModel()) { 
    98                 tabbedPane.setTitleAt(1, tr("Nodes(resolved)")); 
    99                 tabbedPane.setToolTipTextAt(1, tr("Merged node list frozen. No pending conflicts in the node list of this way")); 
    100                 tabbedPane.setIconAt(1, mergeComplete); 
    101             } else { 
    102                 tabbedPane.setTitleAt(1, tr("Nodes(with conflicts)")); 
    103                 tabbedPane.setToolTipTextAt(1,tr("Pending conflicts in the node list of this way")); 
    104                 tabbedPane.setIconAt(1, mergeIncomplete); 
     104                tabbedPane.setTitleAt(2, tr("Nodes(resolved)")); 
     105                tabbedPane.setToolTipTextAt(2, tr("Merged node list frozen. No pending conflicts in the node list of this way")); 
     106                tabbedPane.setIconAt(2, mergeComplete); 
     107            } else { 
     108                tabbedPane.setTitleAt(2, tr("Nodes(with conflicts)")); 
     109                tabbedPane.setToolTipTextAt(2,tr("Pending conflicts in the node list of this way")); 
     110                tabbedPane.setIconAt(2, mergeIncomplete); 
    105111            } 
    106112            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); 
    114             } 
    115         } 
    116     } 
     113                tabbedPane.setTitleAt(3, tr("Members(resolved)")); 
     114                tabbedPane.setToolTipTextAt(3, tr("Merged member list frozen. No pending conflicts in the member list of this relation")); 
     115                tabbedPane.setIconAt(3, mergeComplete); 
     116            } else { 
     117                tabbedPane.setTitleAt(3, tr("Members(with conflicts)")); 
     118                tabbedPane.setToolTipTextAt(3, tr("Pending conflicts in the member list of this relation")); 
     119                tabbedPane.setIconAt(3, mergeIncomplete); 
     120            } 
     121        } else if (evt.getPropertyName().equals(PropertiesMergeModel.RESOLVED_COMPLETELY_PROP)) { 
     122            boolean resolved = (Boolean)evt.getNewValue(); 
     123            if (resolved) { 
     124                tabbedPane.setTitleAt(0, tr("Properties")); 
     125                tabbedPane.setToolTipTextAt(0, tr("No pending property conflicts")); 
     126                tabbedPane.setIconAt(0, mergeComplete); 
     127            } else { 
     128                tabbedPane.setTitleAt(0, tr("Properties(with conflicts)")); 
     129                tabbedPane.setToolTipTextAt(0, tr("Pending property conflicts to be resolved")); 
     130                tabbedPane.setIconAt(0, mergeIncomplete); 
     131            } 
     132        } 
     133    } 
     134 
    117135 
    118136    /** 
    … …  
    126144        this.my = my; 
    127145        this.their =  their; 
     146        propertiesMerger.getModel().populate(my, their); 
     147        tabbedPane.setEnabledAt(0, true); 
    128148        tagMerger.getModel().populate(my, their); 
    129         tabbedPane.setEnabledAt(0,true); 
     149        tabbedPane.setEnabledAt(1, true); 
     150 
    130151        if (my instanceof Node) { 
    131             tabbedPane.setEnabledAt(1,false); 
    132152            tabbedPane.setEnabledAt(2,false); 
     153            tabbedPane.setEnabledAt(3,false); 
    133154        } else if (my instanceof Way) { 
    134155            nodeListMerger.populate((Way)my, (Way)their); 
    135             tabbedPane.setEnabledAt(1, true); 
    136             tabbedPane.setEnabledAt(2, false); 
     156            tabbedPane.setEnabledAt(2, true); 
     157            tabbedPane.setEnabledAt(3, false); 
     158            tabbedPane.setTitleAt(3,tr("Members")); 
     159            tabbedPane.setIconAt(3, null); 
    137160        } else if (my instanceof Relation) { 
    138161            relationMemberMerger.populate((Relation)my, (Relation)their); 
    139             tabbedPane.setEnabledAt(1, false); 
    140             tabbedPane.setEnabledAt(2, true); 
     162            tabbedPane.setEnabledAt(2, false); 
     163            tabbedPane.setTitleAt(2,tr("Nodes")); 
     164            tabbedPane.setIconAt(2, null); 
     165            tabbedPane.setEnabledAt(3, true); 
    141166        } 
    142167    } 
    … …  
    150175    public Command buildResolveCommand() { 
    151176        ArrayList<Command> commands = new ArrayList<Command>(); 
    152         TagConflictResolveCommand cmd = tagMerger.getModel().buildResolveCommand(my, their); 
    153         commands.add(cmd); 
     177        if (tagMerger.getModel().getNumResolvedConflicts() > 0) { 
     178            commands.add(tagMerger.getModel().buildResolveCommand(my, their)); 
     179        } 
     180        commands.addAll(propertiesMerger.getModel().buildResolveCommand(my, their)); 
    154181        if (my instanceof Way && nodeListMerger.getModel().isFrozen()) { 
    155182            NodeListMergeModel model  =(NodeListMergeModel)nodeListMerger.getModel(); 
    … …  
    159186            commands.add(model.buildResolveCommand((Relation)my, (Relation)their)); 
    160187        } 
     188        if (isResolvedCompletely()) { 
     189            commands.add( 
     190                    new VersionConflictResolveCommand(my, their) 
     191            ); 
     192        } 
     193        return new SequenceCommand(tr("Conflict Resolution"), commands); 
     194    } 
     195 
     196    public boolean isResolvedCompletely() { 
    161197        if (my instanceof Node) { 
    162198            // resolve the version conflict if this is a node and all tag 
    163199            // conflicts have been resolved 
    164200            // 
    165             if (tagMerger.getModel().isResolvedCompletely()) { 
    166                 commands.add( 
    167                         new VersionConflictResolveCommand(my, their) 
    168                 ); 
    169             } 
    170         } else if (my instanceof Way) { 
    171             // resolve the version conflict if this is a way, all tag 
    172             // conflicts have been resolved, and conflicts in the node list 
    173             // have been resolved 
    174             // 
    175             if (tagMerger.getModel().isResolvedCompletely() && nodeListMerger.getModel().isFrozen()) { 
    176                 commands.add( 
    177                         new VersionConflictResolveCommand(my, their) 
    178                 ); 
    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             } 
    190         } 
    191         return new SequenceCommand(tr("Conflict Resolution"), commands); 
    192     } 
    193  
    194     public boolean isCompletelyResolved() { 
    195         if (my instanceof Node) { 
    196             // resolve the version conflict if this is a node and all tag 
    197             // conflicts have been resolved 
    198             // 
    199             if (tagMerger.getModel().isResolvedCompletely()) 
     201            if (tagMerger.getModel().isResolvedCompletely() 
     202                    && propertiesMerger.getModel().isResolvedCompletely()) 
    200203                return true; 
    201204        } else if (my instanceof Way) { 
    … …  
    204207            // have been resolved 
    205208            // 
    206             if (tagMerger.getModel().isResolvedCompletely() && nodeListMerger.getModel().isFrozen()) 
     209            if (tagMerger.getModel().isResolvedCompletely() 
     210                    &&  propertiesMerger.getModel().isResolvedCompletely() 
     211                    && nodeListMerger.getModel().isFrozen()) 
    207212                return true; 
    208213        }  else if (my instanceof Relation) { 
    … …  
    211216            // have been resolved 
    212217            // 
    213             if (tagMerger.getModel().isResolvedCompletely() && relationMemberMerger.getModel().isFrozen()) 
     218            if (tagMerger.getModel().isResolvedCompletely() 
     219                    &&  propertiesMerger.getModel().isResolvedCompletely() 
     220                    && relationMemberMerger.getModel().isFrozen()) 
    214221                return true; 
    215222        } 

  • trunk/src/org/openstreetmap/josm/gui/conflict/MergeDecisionType.java

    r1653 r1654  
    11// License: GPL. For details, see LICENSE file. 
    2 package org.openstreetmap.josm.gui.conflict.tags; 
     2package org.openstreetmap.josm.gui.conflict; 
    33 
    44public enum MergeDecisionType { 

  • trunk/src/org/openstreetmap/josm/gui/conflict/nodes/NodeListTableCellRenderer.java

    r1650 r1654  
    8181    } 
    8282 
    83  
     83    /** 
     84     * build the tool tip text for an {@see OsmPrimitive}. It consist of the formatted 
     85     * key/value pairs for this primitive. 
     86     *  
     87     * @param primitive 
     88     * @return the tool tip text 
     89     */ 
    8490    public String buildToolTipText(OsmPrimitive primitive) { 
    8591        StringBuilder sb = new StringBuilder(); 
     92 
    8693        sb.append("<html>"); 
     94        // show the id 
     95        // 
    8796        sb.append("<strong>id</strong>=") 
    8897        .append(primitive.id) 
    8998        .append("<br>"); 
     99 
     100        // show the key/value-pairs, sorted by key 
     101        // 
    90102        ArrayList<String> keyList = new ArrayList<String>(primitive.keySet()); 
    91103        Collections.sort(keyList); 
    … …  
    99111            .append("</strong>") 
    100112            .append("="); 
     113            // make sure long values are split into several rows. Otherwise 
     114            // the tool tip window can become to wide 
     115            // 
    101116            String value = primitive.get(key); 
    102117            while(value.length() != 0) { 
    … …  
    121136        setForeground(Color.BLACK); 
    122137    } 
    123  
    124  
    125138 
    126139    /** 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MergedTableCellRenderer.java

    r1642 r1654  
    55 
    66import java.awt.Color; 
     7 
     8import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    79 
    810public class MergedTableCellRenderer extends TagMergeTableCellRenderer { 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MineTableCellRenderer.java

    r1622 r1654  
    33 
    44import java.awt.Color; 
     5 
     6import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
     7 
    58import static org.openstreetmap.josm.tools.I18n.tr; 
    69 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagMergeItem.java

    r1622 r1654  
    77 
    88import org.openstreetmap.josm.data.osm.OsmPrimitive; 
     9import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    910 
    1011/** 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagMergeModel.java

    r1622 r1654  
    1313import org.openstreetmap.josm.command.TagConflictResolveCommand; 
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive; 
     15import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    1516 
    1617/** 
    … …  
    2122 *  
    2223 *  {@see #decide(int, MergeDecisionType)} and {@see #decide(int[], MergeDecisionType)} can be used 
    23  *  to remember a merge decision for a specific row in the model.  
    24  *   
     24 *  to remember a merge decision for a specific row in the model. 
     25 *  
    2526 *  The model notifies {@see PropertyChangeListener}s about updates of the number of 
    2627 *  undecided tags (see {@see #PROP_NUM_UNDECIDED_TAGS}). 
    … …  
    3132 
    3233    static public final String PROP_NUM_UNDECIDED_TAGS = TagMergeModel.class.getName() + ".numUndecidedTags"; 
    33      
     34 
    3435    /** the list of tag merge items */ 
    35     private ArrayList<TagMergeItem> tagMergeItems; 
    36      
     36    private final ArrayList<TagMergeItem> tagMergeItems; 
     37 
    3738    /** the property change listeners */ 
    38     private ArrayList<PropertyChangeListener> listeners; 
    39      
     39    private final ArrayList<PropertyChangeListener> listeners; 
     40 
    4041    private int numUndecidedTags = 0; 
    41      
    42      
     42 
     43 
    4344    public TagMergeModel() { 
    4445        tagMergeItems = new ArrayList<TagMergeItem>(); 
    4546        listeners = new ArrayList<PropertyChangeListener>(); 
    4647    } 
    47      
     48 
    4849    public void addPropertyChangeListener(PropertyChangeListener listener) { 
    4950        synchronized(listeners) { 
    … …  
    5354        } 
    5455    } 
    55      
     56 
    5657    public void removePropertyChangeListener(PropertyChangeListener listener) { 
    5758        synchronized(listeners) { 
    … …  
    6162        } 
    6263    } 
    63      
     64 
    6465    /** 
    6566     * notifies {@see PropertyChangeListener}s about an update of {@see TagMergeModel#PROP_NUM_UNDECIDED_TAGS} 
    6667 
    67      * @param oldValue the old value  
    68      * @param newValue the new value  
     68     * @param oldValue the old value 
     69     * @param newValue the new value 
    6970     */ 
    7071    protected void fireNumUndecidedTagsChanged(int oldValue, int newValue) { 
    … …  
    7677        } 
    7778    } 
    78      
     79 
    7980    /** 
    8081     * refreshes the number of undecided tag conflicts after an update in the list of 
    … …  
    8990            } 
    9091        } 
    91         if (newValue != numUndecidedTags) { 
    92             int oldValue = numUndecidedTags; 
    93             numUndecidedTags = newValue; 
    94             fireNumUndecidedTagsChanged(oldValue, numUndecidedTags); 
    95         } 
    96     } 
    97      
    98     /** 
    99      * Populate the model with conflicts between the tag sets of the two  
     92        int oldValue = numUndecidedTags; 
     93        numUndecidedTags = newValue; 
     94        fireNumUndecidedTagsChanged(oldValue, numUndecidedTags); 
     95 
     96    } 
     97 
     98    /** 
     99     * Populate the model with conflicts between the tag sets of the two 
    100100     * {@see OsmPrimitive} <code>my</code> and <code>their</code>. 
    101101     *  
    102102     * @param my  my primitive (i.e. the primitive from the local dataset) 
    103      * @param their their primitive (i.e. the primitive from the server dataset)  
     103     * @param their their primitive (i.e. the primitive from the server dataset) 
    104104     *  
    105105     */ 
    … …  
    114114            if (myValue == null || theirValue == null || ! myValue.equals(theirValue)) { 
    115115                tagMergeItems.add( 
    116                   new TagMergeItem(key, my, their)       
     116                        new TagMergeItem(key, my, their) 
    117117                ); 
    118118            } 
    … …  
    121121        refreshNumUndecidedTags(); 
    122122    } 
    123      
     123 
    124124    /** 
    125125     * add a {@see TagMergeItem} to the model 
    126126     *  
    127      * @param item the item  
     127     * @param item the item 
    128128     */ 
    129129    public void addItem(TagMergeItem item) { 
    … …  
    134134        } 
    135135    } 
    136      
     136 
    137137    protected void rememberDecision(int row, MergeDecisionType decision) { 
    138138        TagMergeItem item = tagMergeItems.get(row); 
    … …  
    144144     * to <code>decision</code>. 
    145145     *  
    146      * @param row  the row  
    147      * @param decision the decision  
     146     * @param row  the row 
     147     * @param decision the decision 
    148148     */ 
    149149    public void decide(int row, MergeDecisionType decision) { 
    … …  
    157157     * to <code>decision</code>. 
    158158     *  
    159      * @param row  the array of row indices   
    160      * @param decision the decision  
     159     * @param row  the array of row indices 
     160     * @param decision the decision 
    161161     */ 
    162162 
    163163    public void decide(int [] rows, MergeDecisionType decision) { 
    164         if (rows == null || rows.length == 0) { 
     164        if (rows == null || rows.length == 0) 
    165165            return; 
    166         } 
    167166        for (int row : rows) { 
    168167            rememberDecision(row, decision); 
    … …  
    182181        // return the tagMergeItem for both columns. The cell 
    183182        // renderer will dispatch on the column index and get 
    184         // the key or the value from the TagMergeItem  
     183        // the key or the value from the TagMergeItem 
    185184        // 
    186185        return tagMergeItems.get(row); 
    … …  
    191190        return false; 
    192191    } 
    193      
    194      
     192 
    195193    public TagConflictResolveCommand buildResolveCommand(OsmPrimitive my, OsmPrimitive their) { 
    196194        return new TagConflictResolveCommand(my,  their, tagMergeItems); 
    197195    } 
    198      
     196 
    199197    public boolean isResolvedCompletely() { 
    200198        for (TagMergeItem item: tagMergeItems) { 
    201             if (item.getMergeDecision().equals(MergeDecisionType.UNDECIDED)) { 
    202                 return false;  
    203             } 
    204         } 
    205         return true;  
     199            if (item.getMergeDecision().equals(MergeDecisionType.UNDECIDED)) 
     200                return false; 
     201        } 
     202        return true; 
     203    } 
     204 
     205    public int getNumResolvedConflicts() { 
     206        int n = 0; 
     207        for (TagMergeItem item: tagMergeItems) { 
     208            if (!item.getMergeDecision().equals(MergeDecisionType.UNDECIDED)) { 
     209                n++; 
     210            } 
     211        } 
     212        return n; 
     213 
    206214    } 
    207215} 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TagMerger.java

    r1642 r1654  
    2626import javax.swing.event.ListSelectionListener; 
    2727 
     28import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    2829import org.openstreetmap.josm.tools.ImageProvider; 
    2930/** 

  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/TheirTableCellRenderer.java

    r1622 r1654  
    55 
    66import java.awt.Color; 
     7 
     8import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    79 
    810public class TheirTableCellRenderer extends TagMergeTableCellRenderer { 

  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictResolutionDialog.java

    r1642 r1654  
    169169 
    170170        public void actionPerformed(ActionEvent arg0) { 
    171             if (! resolver.isCompletelyResolved()) { 
     171            if (! resolver.isResolvedCompletely()) { 
    172172                Object[] options = { 
    173173                        tr("Apply partial resolutions"), 

  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/tags/TagMergeItemTest.java

    r1622 r1654  
    44import org.junit.*; 
    55import org.openstreetmap.josm.data.osm.Node; 
    6 import org.openstreetmap.josm.gui.conflict.tags.MergeDecisionType; 
     6import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    77import org.openstreetmap.josm.gui.conflict.tags.TagMergeItem; 
    88 

  • trunk/test/unit/org/openstreetmap/josm/gui/conflict/tags/TagMergeModelTest.java

    r1631 r1654  
    1212import org.junit.Test; 
    1313import org.openstreetmap.josm.data.osm.Node; 
     14import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    1415 
    1516public class TagMergeModelTest { 
Note: See TracChangeset for help on using the changeset viewer.