Changeset 1690 in josm


Ignore:
Timestamp:
Jun 23, 2009 10:03:37 PM (4 years ago)
Author:
Gubaer
Message:

new: MultiFetchServerObjectReader using APIs Multi Fetch method
update: now uses Multi Fetch to check for deleted primitives on the server
update: now uses Multi Fetch to update the selected primitives with the state from the server
fixed: cleaned up merging in MergeVisitor
new: conflict resolution dialog; now resolves conflicts due to different visibilities
new: replacement for realEqual() on OsmPrimitive and derived classes; realEqual now @deprecated
fixed: cleaning up OsmReader
fixed: progress indication in OsmApi

Location:
trunk/src/org/openstreetmap/josm
Files:
2 added
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/actions/UpdateSelectionAction.java

    r1670 r1690  
    66import java.awt.event.ActionEvent; 
    77import java.awt.event.KeyEvent; 
    8 import java.io.IOException; 
    9 import java.net.HttpURLConnection; 
    10 import java.util.ArrayList; 
    118import java.util.Collection; 
     9import java.util.HashSet; 
     10import java.util.Set; 
    1211 
    1312import javax.swing.JOptionPane; 
    … …  
    1514import org.openstreetmap.josm.Main; 
    1615import org.openstreetmap.josm.command.PurgePrimitivesCommand; 
    17 import org.openstreetmap.josm.command.UndeletePrimitivesCommand; 
    1816import org.openstreetmap.josm.data.osm.DataSet; 
    19 import org.openstreetmap.josm.data.osm.Node; 
    2017import org.openstreetmap.josm.data.osm.OsmPrimitive; 
    21 import org.openstreetmap.josm.data.osm.OsmPrimitiveType; 
    22 import org.openstreetmap.josm.data.osm.Relation; 
    23 import org.openstreetmap.josm.data.osm.RelationMember; 
    24 import org.openstreetmap.josm.data.osm.Way; 
    25 import org.openstreetmap.josm.gui.PleaseWaitRunnable; 
    26 import org.openstreetmap.josm.io.OsmApi; 
    27 import org.openstreetmap.josm.io.OsmApiException; 
    28 import org.openstreetmap.josm.io.OsmServerObjectReader; 
    29 import org.openstreetmap.josm.io.OsmTransferException; 
     18import org.openstreetmap.josm.io.MultiFetchServerObjectReader; 
    3019import org.openstreetmap.josm.tools.Shortcut; 
    31 import org.xml.sax.SAXException; 
    3220 
    3321/** 
    … …  
    4129 
    4230    /** 
    43      * Undelete a node which is already deleted on the server. The API 
    44      * doesn't offer a call for "undeleting" a node. We therefore create 
    45      * a clone of the node which we flag as new. On the next upload the 
    46      * server will assign the node a new id. 
    47      *  
    48      * @param node the node to undelete 
    49      */ 
    50     protected void  undeleteNode(Node node) { 
    51         UndeletePrimitivesCommand cmd = new UndeletePrimitivesCommand(node); 
    52         Main.main.undoRedo.add(cmd); 
    53     } 
    54  
    55     /** 
    56      * Undelete a way which is already deleted on the server. 
    57      *  
    58      * This method also checks whether there are additional nodes referred to by 
    59      * this way which are deleted on the server too. 
    60      *  
    61      * @param way the way to undelete 
    62      * @see #undeleteNode(Node) 
    63      */ 
    64     protected void undeleteWay(final Way way) { 
    65         class NodeGoneChecker extends PleaseWaitRunnable { 
    66  
    67             UndeletePrimitivesCommand cmd = null; 
    68  
    69             public NodeGoneChecker() { 
    70                 super(tr("Undeleting Way..."), false); 
    71             } 
    72  
    73             @Override 
    74             protected void cancel() { 
    75                 OsmApi.getOsmApi().cancel(); 
    76             } 
    77  
    78             @Override 
    79             protected void finish() { 
    80                 if (cmd != null) { 
    81                     Main.main.undoRedo.add(cmd); 
    82                 } 
    83             } 
    84  
    85             /** 
    86              * replies the subset of the node list which already 
    87              * have an assigned id 
    88              *  
    89              * @param way  the way 
    90              * @return the node list 
    91              */ 
    92             protected ArrayList<Node> getCandidateNodes(Way way) { 
    93                 ArrayList<Node> candidates = new ArrayList<Node>(); 
    94                 for (Node n : way.nodes) { 
    95                     if (n.id > 0 && ! candidates.contains(n)) { 
    96                         candidates.add(n); 
    97                     } 
    98                 } 
    99                 return candidates; 
    100             } 
    101  
    102             /** 
    103              * checks whether a specific node is deleted on the server 
    104              *  
    105              * @param n the node 
    106              * @return true, if the node is deleted; false, otherwise 
    107              * @throws OsmTransferException thrown, if an error occurs while communicating with the API 
    108              */ 
    109             protected boolean isGone(Node n) throws OsmTransferException { 
    110                 OsmServerObjectReader reader = new OsmServerObjectReader(n.id, OsmPrimitiveType.from(n), true); 
    111                 try { 
    112                     reader.parseOsm(); 
    113                 } catch(OsmApiException e) { 
    114                     if (e.getResponseCode() == HttpURLConnection.HTTP_GONE) 
    115                         return true; 
    116                     throw e; 
    117                 } catch(OsmTransferException e) { 
    118                     throw e; 
    119                 } 
    120                 return false; 
    121             } 
    122  
    123             /** 
    124              * displays a confirmation message. The user has to confirm that additional dependent 
    125              * nodes should be undeleted too. 
    126              *  
    127              * @param way  the way 
    128              * @param dependent a list of dependent nodes which have to be undelete too 
    129              * @return true, if the user confirms; false, otherwise 
    130              */ 
    131             protected boolean confirmUndeleteDependentPrimitives(Way way, ArrayList<OsmPrimitive> dependent) { 
    132                 String [] options = { 
    133                         tr("Yes, undelete them too"), 
    134                         tr("No, cancel operation") 
    135                 }; 
    136                 int ret = JOptionPane.showOptionDialog( 
    137                         Main.parent, 
    138                         tr("<html>There are {0} additional nodes used by way {1}<br>" 
    139                                 + "which are deleted on the server.<br>" 
    140                                 + "<br>" 
    141                                 + "Do you want to undelete these nodes too?</html>", 
    142                                 Long.toString(dependent.size()), Long.toString(way.id)), 
    143                                 tr("Undelete additional nodes?"), 
    144                                 JOptionPane.YES_NO_OPTION, 
    145                                 JOptionPane.QUESTION_MESSAGE, 
    146                                 null, 
    147                                 options, 
    148                                 options[0] 
    149                 ); 
    150  
    151                 switch(ret) { 
    152                 case JOptionPane.CLOSED_OPTION: return false; 
    153                 case JOptionPane.YES_OPTION: return true; 
    154                 case JOptionPane.NO_OPTION: return false; 
    155                 } 
    156                 return false; 
    157  
    158             } 
    159  
    160             @Override 
    161             protected void realRun() throws SAXException, IOException, OsmTransferException { 
    162                 ArrayList<Node> candidate = getCandidateNodes(way); 
    163                 ArrayList<OsmPrimitive> toDelete = new ArrayList<OsmPrimitive>(); 
    164                 Main.pleaseWaitDlg.progress.setMinimum(0); 
    165                 Main.pleaseWaitDlg.progress.setMaximum(candidate.size()); 
    166  
    167                 for (int i=0; i<candidate.size();i++) { 
    168                     Node n = candidate.get(i); 
    169                     Main.pleaseWaitDlg.progress.setValue(i); 
    170                     Main.pleaseWaitDlg.currentAction.setText(tr("Checking whether node {0} is gone ...", n.id)); 
    171                     if (isGone(n)) { 
    172                         toDelete.add(n); 
    173                     } 
    174                 } 
    175                 if (toDelete.size() > 0) { 
    176                     if (!confirmUndeleteDependentPrimitives(way, toDelete)) 
    177                         return; 
    178                 } 
    179  
    180                 toDelete.add(way); 
    181                 cmd = new UndeletePrimitivesCommand(toDelete); 
    182             } 
    183         } 
    184  
    185         Main.worker.submit(new NodeGoneChecker()); 
    186     } 
    187  
    188     /** 
    189      * Undelete a relation which is already deleted on the server. 
    190      *  
    191      * This method  checks whether there are additional primitives referred to by 
    192      * this relation which are already deleted on the server. 
    193      *  
    194      * @param r the relation 
    195      * @see #undeleteNode(Node) 
    196      */ 
    197     protected void undeleteRelation(final Relation r) { 
    198         class RelationMemberGoneChecker extends PleaseWaitRunnable { 
    199  
    200             UndeletePrimitivesCommand cmd = null; 
    201  
    202             public RelationMemberGoneChecker() { 
    203                 super(tr("Undeleting relation..."), false); 
    204             } 
    205  
    206             @Override 
    207             protected void cancel() { 
    208                 OsmApi.getOsmApi().cancel(); 
    209             } 
    210  
    211             @Override 
    212             protected void finish() { 
    213                 if (cmd != null) { 
    214                     Main.main.undoRedo.add(cmd); 
    215                 } 
    216             } 
    217  
    218             protected ArrayList<OsmPrimitive> getCandidateRelationMembers(Relation r) { 
    219                 ArrayList<OsmPrimitive> candidates = new ArrayList<OsmPrimitive>(); 
    220                 for (RelationMember m : r.members) { 
    221                     if (m.member.id > 0 && !candidates.contains(m.member)) { 
    222                         candidates.add(m.member); 
    223                     } 
    224                 } 
    225                 return candidates; 
    226             } 
    227  
    228             protected boolean isGone(OsmPrimitive primitive) throws OsmTransferException { 
    229                 OsmServerObjectReader reader = new OsmServerObjectReader( 
    230                         primitive.id, 
    231                         OsmPrimitiveType.from(primitive), 
    232                         true); 
    233                 try { 
    234                     reader.parseOsm(); 
    235                 } catch(OsmApiException e) { 
    236                     if (e.getResponseCode() == HttpURLConnection.HTTP_GONE) 
    237                         return true; 
    238                     throw e; 
    239                 } catch(OsmTransferException e) { 
    240                     throw e; 
    241                 } 
    242                 return false; 
    243             } 
    244  
    245             protected boolean confirmUndeleteDependentPrimitives(Relation r, ArrayList<OsmPrimitive> dependent) { 
    246                 String [] options = { 
    247                         tr("Yes, undelete them too"), 
    248                         tr("No, cancel operation") 
    249                 }; 
    250                 int ret = JOptionPane.showOptionDialog( 
    251                         Main.parent, 
    252                         tr("<html>There are {0} additional primitives referred to by relation {1}<br>" 
    253                                 + "which are deleted on the server.<br>" 
    254                                 + "<br>" 
    255                                 + "Do you want to undelete them too?</html>", 
    256                                 Long.toString(dependent.size()), Long.toString(r.id)), 
    257                                 tr("Undelete dependent primitives?"), 
    258                                 JOptionPane.YES_NO_OPTION, 
    259                                 JOptionPane.QUESTION_MESSAGE, 
    260                                 null, 
    261                                 options, 
    262                                 options[0] 
    263                 ); 
    264  
    265                 switch(ret) { 
    266                 case JOptionPane.CLOSED_OPTION: return false; 
    267                 case JOptionPane.YES_OPTION: return true; 
    268                 case JOptionPane.NO_OPTION: return false; 
    269                 } 
    270                 return false; 
    271  
    272             } 
    273  
    274             @Override 
    275             protected void realRun() throws SAXException, IOException, OsmTransferException { 
    276                 ArrayList<OsmPrimitive> candidate = getCandidateRelationMembers(r); 
    277                 ArrayList<OsmPrimitive> toDelete = new ArrayList<OsmPrimitive>(); 
    278                 Main.pleaseWaitDlg.progress.setMinimum(0); 
    279                 Main.pleaseWaitDlg.progress.setMaximum(candidate.size()); 
    280  
    281                 for (int i=0; i<candidate.size();i++) { 
    282                     OsmPrimitive primitive = candidate.get(i); 
    283                     Main.pleaseWaitDlg.progress.setValue(i); 
    284                     Main.pleaseWaitDlg.currentAction.setText(tr("Checking whether primitive {0} is gone ...", primitive.id)); 
    285                     if (isGone(primitive)) { 
    286                         toDelete.add(primitive); 
    287                     } 
    288                 } 
    289                 if (toDelete.size() > 0) { 
    290                     if (!confirmUndeleteDependentPrimitives(r, toDelete)) 
    291                         return; 
    292                 } 
    293  
    294                 toDelete.add(r); 
    295                 cmd = new UndeletePrimitivesCommand(toDelete); 
    296             } 
    297         } 
    298  
    299         Main.worker.submit(new RelationMemberGoneChecker()); 
    300     } 
    301  
    302     /** 
    303      * User has decided to keep his local version of a primitive which had been deleted 
    304      * on the server 
    305      *  
    306      * @param id the primitive id 
    307      */ 
    308     protected void handlePrimitiveGoneKeepMine(long id) { 
    309         OsmPrimitive primitive = Main.main.editLayer().data.getPrimitiveById(id); 
    310         if (primitive instanceof Node) { 
    311             undeleteNode((Node)primitive); 
    312         } else if (primitive instanceof Way) { 
    313             undeleteWay((Way)primitive); 
    314         } else if (primitive instanceof Relation) { 
    315             undeleteRelation((Relation)primitive); 
    316         } 
    317     } 
    318  
    319     /** 
    320      * User has decided to delete his local version of a primitive which had been deleted 
    321      * on the server 
    322      *  
    323      * @param id the primitive id 
    324      */ 
    325     protected void handlePrimitiveGoneDeleteMine(long id) { 
    326         OsmPrimitive primitive = Main.main.editLayer().data.getPrimitiveById(id); 
    327         PurgePrimitivesCommand cmd = new PurgePrimitivesCommand(primitive); 
    328         Main.main.undoRedo.add(cmd); 
    329         Main.map.mapView.repaint(); 
    330     } 
    331  
    332     /** 
    33331     * handle an exception thrown because a primitive was deleted on the server 
    33432     *  
    … …  
    33634     */ 
    33735    protected void handlePrimitiveGoneException(long id) { 
    338         Object[] options = new Object[] { 
    339                 tr("Keep mine"), 
    340                 tr("Delete mine"), 
    341                 tr("Cancel") 
    342         }; 
    343         Object defaultOption = options[0]; 
    344         String msg =  tr("<html>The OSM primitive with id <strong>{0}</strong> has been deleted<br>" 
    345                 + "on the server by another mapper.<br>" 
    346                 + "<br>" 
    347                 + "Click <strong>{1}</strong> to keep your primitive and ignore the deleted state.<br>" 
    348                 + "Your primitive will be assigend a new id.<br>" 
    349                 + "Click <strong>{2}</strong> to accept the state on the server and to delete your primitive.<br>" 
    350                 + "Click <strong>{3}</strong> to cancel.<br>", 
    351                 id, options[0], options[1], options[2] 
    352         ); 
    353         int ret = JOptionPane.showOptionDialog( 
    354                 null, 
    355                 msg, 
    356                 tr("Primitive deleted on the server"), 
    357                 JOptionPane.YES_NO_CANCEL_OPTION, 
    358                 JOptionPane.ERROR_MESSAGE, 
    359                 null, 
    360                 options, 
    361                 defaultOption 
    362         ); 
    363         switch(ret) { 
    364         case JOptionPane.CLOSED_OPTION: return; 
    365         case JOptionPane.CANCEL_OPTION: return; 
    366         case 0: handlePrimitiveGoneKeepMine(id); break; 
    367         case 1: handlePrimitiveGoneDeleteMine(id); break; 
    368         default: 
    369             // should not happen 
    370             throw new IllegalStateException(tr("unexpected return value. Got {0}", ret)); 
     36        MultiFetchServerObjectReader reader = new MultiFetchServerObjectReader(); 
     37        reader.append(Main.main.editLayer().data,id); 
     38        DataSet ds = null; 
     39        try { 
     40            ds = reader.parseOsm(); 
     41        } catch(Exception e) { 
     42            handleUpdateException(e); 
     43            return; 
    37144        } 
     45        Main.main.editLayer().mergeFrom(ds); 
    37246    } 
    37347 
    … …  
    37852     * @param e the exception 
    37953     */ 
    380     protected void handleUpdateException(long id, Exception e) { 
    381         if (e instanceof OsmApiException) { 
    382             OsmApiException ex = (OsmApiException)e; 
    383             // if the primitive was deleted on the server ask the user 
    384             // whether he wants to undelete it 
    385             // 
    386             if (ex.getResponseCode() == HttpURLConnection.HTTP_GONE) { 
    387                 handlePrimitiveGoneException(id); 
    388                 return; 
    389             } 
    390         } 
    391  
     54    protected void handleUpdateException(Exception e) { 
    39255        e.printStackTrace(); 
    39356        JOptionPane.showMessageDialog( 
    … …  
    40669        JOptionPane.showMessageDialog( 
    40770                Main.parent, 
    408                 tr("Could not find primitive with id {0} in the current dataset", id), 
     71                tr("Could not find primitive with id {0} in the current dataset", new Long(id).toString()), 
    40972                tr("Missing primitive"), 
    41073                JOptionPane.ERROR_MESSAGE 
    … …  
    41376 
    41477    /** 
    415      * Updates the primitive with id <code>id</code> with the current state kept on the server. 
    41678     *  
    417      * @param id 
     79     *  
     80     *  
    41881     */ 
    419     public void updatePrimitive(long id) { 
    420         OsmPrimitive primitive = Main.main.editLayer().data.getPrimitiveById(id); 
    421         if (primitive == null) { 
    422             handleMissingPrimitive(id); 
    423             return; 
    424         } 
    425         OsmServerObjectReader reader = new OsmServerObjectReader( 
    426                 id, 
    427                 OsmPrimitiveType.from(primitive), 
    428                 true); 
     82    public void updatePrimitives(Collection<OsmPrimitive> selection) { 
     83        MultiFetchServerObjectReader reader = new MultiFetchServerObjectReader(); 
     84        reader.append(selection); 
    42985        DataSet ds = null; 
    43086        try { 
    43187            ds = reader.parseOsm(); 
    43288        } catch(Exception e) { 
    433             handleUpdateException(id, e); 
     89            handleUpdateException(e); 
    43490            return; 
    43591        } 
    … …  
    43793    } 
    43894 
     95    public void updatePrimitive(long id) { 
     96        OsmPrimitive primitive = Main.main.editLayer().data.getPrimitiveById(id); 
     97        Set<OsmPrimitive> s = new HashSet<OsmPrimitive>(); 
     98        s.add(primitive); 
     99        updatePrimitives(s); 
     100    } 
    439101 
    440102    public UpdateSelectionAction() { 
    … …  
    461123            return; 
    462124        } 
    463  
    464         // check whether the current selection has an acceptable range. 
    465         // We don't want to hammer the API with hundreds of individual 
    466         // GET requests. 
    467         // 
    468         if (selection.size() > DEFAULT_MAX_SIZE_UPDATE_SELECTION) { 
    469             JOptionPane.showMessageDialog( 
    470                     Main.parent, 
    471                     tr("<html>There are  <strong>{0}</strong> primitives <br>" 
    472                             + "selected for individual update. Please reduce the selection<br>" 
    473                             + "to max. {1} primitives.</html>", 
    474                             selection.size(), DEFAULT_MAX_SIZE_UPDATE_SELECTION 
    475                     ), 
    476                     tr("Selection too big"), 
    477                     JOptionPane.WARNING_MESSAGE 
    478             ); 
    479             return; 
    480         } 
    481         for(OsmPrimitive primitive : selection) { 
    482             // FIXME: users should be able to abort this loop 
    483             // 
    484             updatePrimitive(primitive.id); 
    485         } 
     125        updatePrimitives(selection); 
    486126    } 
    487127} 

  • trunk/src/org/openstreetmap/josm/actions/downloadtasks/DownloadOsmTaskList.java

    r1682 r1690  
    128128    protected void handlePotentiallyDeletedPrimitives(Set<Long> potentiallyDeleted) { 
    129129        String [] options = { 
    130                 "Check individually", 
     130                "Check on the server", 
    131131                "Ignore" 
    132132        }; 
    … …  
    138138                + "conflict.<br>" 
    139139                + "<br>" 
    140                 + "Click <strong>{1}</strong> to check these primitives individually.<br>" 
     140                + "Click <strong>{1}</strong> to check the state of these primitives<br>" 
     141                + "on the server.<br>" 
    141142                + "Click <strong>{2}</strong> to ignore.<br>" 
    142143                + "</html>", 

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

    r1654 r1690  
    6666 
    6767        if (decision.equals(MergeDecisionType.KEEP_MINE)) { 
    68             // do nothing 
     68            if (my.deleted) { 
     69                // because my was involved in a conflict it my still be referred 
     70                // to from a way or a relation. Fix this now. 
     71                // 
     72                Main.main.editLayer().data.unlinkReferencesToPrimitive(my); 
     73            } 
    6974        } else if (decision.equals(MergeDecisionType.KEEP_THEIR)) { 
    70             my.deleted = their.deleted; 
     75            if (their.deleted) { 
     76                Main.main.editLayer().data.unlinkReferencesToPrimitive(my); 
     77                my.delete(true); 
     78            } else { 
     79                my.deleted = their.deleted; 
     80            } 
    7181        } else 
    7282            // should not happen 

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

    r1670 r1690  
    66import java.util.ArrayList; 
    77import java.util.Collection; 
     8import java.util.HashMap; 
    89import java.util.List; 
     10import java.util.Map; 
    911 
    1012import javax.swing.JLabel; 
    … …  
    3335 */ 
    3436public class PurgePrimitivesCommand extends Command{ 
     37 
    3538 
    3639    /** 
    … …  
    141144    private ArrayList<OsmParentChildPair> pairs; 
    142145 
     146    private Map<OsmPrimitive, OsmPrimitive> resolvedConflicts; 
     147 
    143148    /** 
    144149     * constructor 
    … …  
    149154        purgedPrimitives = new ArrayList<OsmPrimitive>(); 
    150155        pairs = new ArrayList<OsmParentChildPair>(); 
     156        resolvedConflicts = new HashMap<OsmPrimitive, OsmPrimitive>(); 
    151157    } 
    152158 
    … …  
    180186            if (pair.getParent() instanceof Way) { 
    181187                Way w = (Way)pair.getParent(); 
    182                 System.out.println("removing reference from way " + w.id); 
     188                System.out.println(tr("removing reference from way {0}",w.id)); 
    183189                w.nodes.remove(primitive); 
    184190                // if a way ends up with less than two node we 
    … …  
    194200            } else if (pair.getParent() instanceof Relation) { 
    195201                Relation r = (Relation)pair.getParent(); 
    196                 System.out.println("removing reference from relation " + r.id); 
     202                System.out.println(tr("removing reference from relation {0}",r.id)); 
    197203                r.removeMembersFor(primitive); 
    198204            } 
    … …  
    220226            } 
    221227            purgedPrimitives.add(toPurge); 
     228            if (Main.map.conflictDialog.conflicts.containsKey(toPurge)) { 
     229                resolvedConflicts.put(toPurge, Main.map.conflictDialog.conflicts.get(toPurge)); 
     230                Main.map.conflictDialog.removeConflictForPrimitive(toPurge); 
     231            } 
    222232        } 
    223233        return super.executeCommand(); 
    … …  
    236246    @Override 
    237247    public void undoCommand() { 
     248 
     249        // restore purged primitives 
     250        // 
    238251        for (OsmPrimitive purged : purgedPrimitives) { 
    239252            Main.ds.addPrimitive(purged); 
     253        } 
     254 
     255        // restore conflicts 
     256        // 
     257        for (OsmPrimitive primitive : resolvedConflicts.keySet()) { 
     258            Main.map.conflictDialog.addConflict(primitive, resolvedConflicts.get(primitive)); 
    240259        } 
    241260 

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

    r1670 r1690  
    66import java.util.ArrayList; 
    77import java.util.Collection; 
     8import java.util.HashMap; 
     9import java.util.Map; 
    810 
    911import javax.swing.JLabel; 
    … …  
    1113import javax.swing.tree.MutableTreeNode; 
    1214 
     15import org.openstreetmap.josm.Main; 
    1316import org.openstreetmap.josm.data.osm.OsmPrimitive; 
    1417import org.openstreetmap.josm.tools.ImageProvider; 
    … …  
    2427    /** the node to undelete */ 
    2528    private ArrayList<OsmPrimitive> toUndelete; 
     29    private Map<OsmPrimitive,OsmPrimitive> resolvedConflicts; 
    2630 
     31    protected UndeletePrimitivesCommand() { 
     32        toUndelete = new ArrayList<OsmPrimitive>(); 
     33        resolvedConflicts = new HashMap<OsmPrimitive, OsmPrimitive>(); 
     34    } 
    2735    /** 
    2836     * constructor 
    … …  
    3038     */ 
    3139    public UndeletePrimitivesCommand(OsmPrimitive node) { 
    32         toUndelete = new ArrayList<OsmPrimitive>(); 
     40        this(); 
    3341        toUndelete.add(node); 
    3442    } 
    … …  
    3947     */ 
    4048    public UndeletePrimitivesCommand(OsmPrimitive ... toUndelete) { 
    41         this.toUndelete = new ArrayList<OsmPrimitive>(); 
     49        this(); 
    4250        for (int i=0; i < toUndelete.length; i++) { 
    4351            this.toUndelete.add(toUndelete[i]); 
    … …  
    5058     */ 
    5159    public UndeletePrimitivesCommand(Collection<OsmPrimitive> toUndelete) { 
    52         this.toUndelete = new ArrayList<OsmPrimitive>(); 
     60        this(); 
    5361        this.toUndelete.addAll(toUndelete); 
    5462    } 
    … …  
    7078        super.executeCommand(); 
    7179        for(OsmPrimitive primitive: toUndelete) { 
     80            if (Main.map.conflictDialog.conflicts.containsKey(primitive)) { 
     81                resolvedConflicts.put(primitive, Main.map.conflictDialog.conflicts.get(primitive)); 
     82                Main.map.conflictDialog.removeConflictForPrimitive(primitive); 
     83            } 
    7284            primitive.id = 0; 
    7385        } 
    … …  
    8092        modified.addAll(toUndelete); 
    8193    } 
     94    @Override 
     95    public void undoCommand() { 
     96        super.undoCommand(); 
     97 
     98        for (OsmPrimitive my: resolvedConflicts.keySet()) { 
     99            if (!Main.map.conflictDialog.conflicts.containsKey(my)) { 
     100                Main.map.conflictDialog.addConflict(my, resolvedConflicts.get(my)); 
     101            } 
     102        } 
     103    } 
    82104} 

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

    r1670 r1690  
    1111 
    1212import org.openstreetmap.josm.Main; 
    13 import org.openstreetmap.josm.data.osm.Node; 
    1413import org.openstreetmap.josm.data.osm.OsmPrimitive; 
    1514import org.openstreetmap.josm.data.osm.OsmPrimitiveType; 
    16 import org.openstreetmap.josm.data.osm.Relation; 
    17 import org.openstreetmap.josm.data.osm.Way; 
    1815import org.openstreetmap.josm.tools.ImageProvider; 
    1916 

  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r1677 r1690  
    88import java.util.HashSet; 
    99import java.util.HashMap; 
     10import java.util.Iterator; 
    1011import java.util.LinkedList; 
    1112import java.util.List; 
    … …  
    8081        Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>(); 
    8182        for (OsmPrimitive osm : allPrimitives()) 
    82             if (!osm.deleted) { 
     83            if (osm.visible && !osm.deleted) { 
    8384                o.add(osm); 
    8485            } 
    … …  
    8990        Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>(); 
    9091        for (OsmPrimitive osm : allPrimitives()) 
    91             if (!osm.deleted && !osm.incomplete) { 
     92            if (osm.visible && !osm.deleted && !osm.incomplete) { 
    9293                o.add(osm); 
    9394            } 
    … …  
    9899        Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>(); 
    99100        for (OsmPrimitive osm : allPrimitives()) 
    100             if (!osm.deleted && !osm.incomplete && !(osm instanceof Relation)) { 
     101            if (osm.visible && !osm.deleted && !osm.incomplete && !(osm instanceof Relation)) { 
    101102                o.add(osm); 
    102103            } 
    … …  
    311312        return ret; 
    312313    } 
     314 
     315    protected void deleteWay(Way way) { 
     316        way.nodes.clear(); 
     317        way.delete(true); 
     318    } 
     319 
     320    /** 
     321     * removes all references from ways in this dataset to a particular node 
     322     *  
     323     * @param node the node 
     324     */ 
     325    public void unlinkNodeFromWays(Node node) { 
     326        for (Way way: ways) { 
     327            if (way.nodes.contains(node)) { 
     328                way.nodes.remove(node); 
     329                if (way.nodes.size() < 2) { 
     330                    deleteWay(way); 
     331                } 
     332            } 
     333        } 
     334    } 
     335 
     336    /** 
     337     * removes all references from relations in this dataset  to this primitive 
     338     *  
     339     * @param primitive the primitive 
     340     */ 
     341    public void unlinkPrimitiveFromRelations(OsmPrimitive primitive) { 
     342        for (Relation relation : relations) { 
     343            Iterator<RelationMember> it = relation.members.iterator(); 
     344            while(it.hasNext()) { 
     345                RelationMember member = it.next(); 
     346                if (member.member.equals(primitive)) { 
     347                    it.remove(); 
     348                } 
     349            } 
     350        } 
     351    } 
     352 
     353    /** 
     354     * removes all references from from other primitives  to the 
     355     * referenced primitive 
     356     *  
     357     * @param referencedPrimitive the referenced primitive 
     358     */ 
     359    public void unlinkReferencesToPrimitive(OsmPrimitive referencedPrimitive) { 
     360        if (referencedPrimitive instanceof Node) { 
     361            unlinkNodeFromWays((Node)referencedPrimitive); 
     362            unlinkPrimitiveFromRelations(referencedPrimitive); 
     363        } else { 
     364            unlinkPrimitiveFromRelations(referencedPrimitive); 
     365        } 
     366    } 
    313367} 

  • trunk/src/org/openstreetmap/josm/data/osm/Node.java

    r1640 r1690  
    3131 
    3232    public final void setEastNorth(EastNorth eastNorth) { 
    33        this.eastNorth = eastNorth; 
    34        this.coor = Main.proj.eastNorth2latlon(eastNorth); 
     33        this.eastNorth = eastNorth; 
     34        this.coor = Main.proj.eastNorth2latlon(eastNorth); 
    3535    } 
    3636 
    … …  
    8787    } 
    8888 
     89    /** 
     90     * @deprecated 
     91     * @see #hasEqualSemanticAttributes(OsmPrimitive) 
     92     * @see #hasEqualTechnicalAttributes(OsmPrimitive) 
     93     */ 
     94    @Deprecated 
    8995    @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) { 
    9096        if (osm instanceof Node) { 
    … …  
    99105    } 
    100106 
     107    @Override 
     108    public boolean hasEqualSemanticAttributes(OsmPrimitive other) { 
     109        if (other == null || ! (other instanceof Node) ) 
     110            return false; 
     111        if (! super.hasEqualSemanticAttributes(other)) 
     112            return false; 
     113        Node n = (Node)other; 
     114        if (coor == null && n.coor == null) 
     115            return true; 
     116        else if (coor != null && n.coor != null) 
     117            return coor.equals(n.coor); 
     118        else 
     119            return false; 
     120    } 
     121 
    101122    public int compareTo(OsmPrimitive o) { 
    102123        return o instanceof Node ? Long.valueOf(id).compareTo(o.id) : 1; 
    103124    } 
    104125 
     126    @Override 
    105127    public String getName() { 
    106128        String name; 
    … …  
    109131        } else { 
    110132            name = get("name"); 
    111             if (name == null) 
     133            if (name == null) { 
    112134                name = id == 0 ? tr("node") : ""+id; 
     135            } 
    113136            name += " (" + coor.latToString(mCord) + ", " + coor.lonToString(mCord) + ")"; 
    114137        } 

  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r1530 r1690  
    4343    public void putError(String text, Boolean isError) 
    4444    { 
    45         if(errors == null) 
     45        if(errors == null) { 
    4646            errors = new ArrayList<String>(); 
     47        } 
    4748        String s = isError ? tr("Error: {0}", text) : tr("Warning: {0}", text); 
    4849        errors.add(s); 
    … …  
    9192     * Visibility status as specified by the server. The visible attribute was 
    9293     * introduced with the 0.4 API to be able to communicate deleted objects 
    93      * (they will have visible=false). Currently JOSM does never deal with 
    94      * these, so this is really for future use only. 
     94     * (they will have visible=false). 
    9595     */ 
    9696    public boolean visible = true; 
    … …  
    195195    @Override public boolean equals(Object obj) { 
    196196        if (id == 0) return obj == this; 
    197         if (obj instanceof OsmPrimitive) { // not null too 
     197        if (obj instanceof OsmPrimitive) 
    198198            return ((OsmPrimitive)obj).id == id && obj.getClass() == getClass(); 
    199         } 
    200199        return false; 
    201200    } 
    … …  
    226225     */ 
    227226    public final void put(String key, String value) { 
    228         if (value == null) 
     227        if (value == null) { 
    229228            remove(key); 
    230         else { 
    231             if (keys == null) 
     229        } else { 
     230            if (keys == null) { 
    232231                keys = new HashMap<String, String>(); 
     232            } 
    233233            keys.put(key, value); 
    234234        } 
    … …  
    241241        if (keys != null) { 
    242242            keys.remove(key); 
    243             if (keys.isEmpty()) 
     243            if (keys.isEmpty()) { 
    244244                keys = null; 
     245            } 
    245246        } 
    246247        mappaintStyle = null; 
    … …  
    280281        version = osm.version; 
    281282        incomplete = osm.incomplete; 
     283        visible = osm.visible; 
    282284        clearCached(); 
    283285        clearErrors(); 
    … …  
    288290     * but for the whole object (for conflict resolving) 
    289291     * @param semanticOnly if <code>true</code>, modified flag and timestamp are not compared 
    290      */ 
     292     *  
     293     * @deprecated 
     294     * @see #hasEqualSemanticAttributes(OsmPrimitive) 
     295     * @see #hasEqualTechnicalAttributes(OsmPrimitive) 
     296     */ 
     297    @Deprecated 
    291298    public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) { 
    292299        return id == osm.id 
    293300        && incomplete == osm.incomplete 
    294301        && deleted == osm.deleted 
    295         && (semanticOnly || (modified == osm.modified 
    296          && timestamp == osm.timestamp 
    297          && version == osm.version 
    298          && visible == osm.visible 
    299          && (user == null ? osm.user==null : user==osm.user))) 
     302        && (semanticOnly || ( 
     303                modified == osm.modified 
     304                && timestamp == osm.timestamp 
     305                && version == osm.version 
     306                && visible == osm.visible 
     307                && (user == null ? osm.user==null : user==osm.user)) 
     308        ) 
    300309        && (keys == null ? osm.keys==null : keys.equals(osm.keys)); 
     310    } 
     311 
     312    /** 
     313     * Replies true if this primitive and other are equal with respect to their 
     314     * semantic attributes. 
     315     * <ol> 
     316     *   <li>equal id</ol> 
     317     *   <li>both are complete or both are incomplete</li> 
     318     *   <li>both have the same tags</li> 
     319     * </ol> 
     320     * @param other 
     321     * @return true if this primitive and other are equal with respect to their 
     322     * semantic attributes. 
     323     */ 
     324    public boolean hasEqualSemanticAttributes(OsmPrimitive other) { 
     325        if (id != other.id) 
     326            return false; 
     327        if (incomplete && ! other.incomplete || !incomplete  && other.incomplete) 
     328            return false; 
     329        return (keys == null ? other.keys==null : keys.equals(other.keys)); 
     330    } 
     331 
     332    /** 
     333     * Replies true if this primitive and other are equal with respect to their 
     334     * technical attributes. The attributes: 
     335     * <ol> 
     336     *   <li>deleted</ol> 
     337     *   <li>modified</ol> 
     338     *   <li>timestamp</ol> 
     339     *   <li>version</ol> 
     340     *   <li>visible</ol> 
     341     *   <li>user</ol> 
     342     * </ol> 
     343     * have to be equal 
     344     * @param other the other primitive 
     345     * @return true if this primitive and other are equal with respect to their 
     346     * technical attributes 
     347     */ 
     348    public boolean hasEqualTechnicalAttributes(OsmPrimitive other) { 
     349        if (other == null) return false; 
     350 
     351        return 
     352        deleted == other.deleted 
     353        && modified == other.modified 
     354        && timestamp == other.timestamp 
     355        && version == other.version 
     356        && visible == other.visible 
     357        && (user == null ? other.user==null : user==other.user); 
    301358    } 
    302359 
    … …  
    312369        if (keys != null) { 
    313370            for (Entry<String,String> e : keys.entrySet()) { 
    314                 if (!uninteresting.contains(e.getKey())) { 
     371                if (!uninteresting.contains(e.getKey())) 
    315372                    return true; 
    316                 } 
    317373            } 
    318374        } 
    … …  
    327383        if (keys != null) { 
    328384            for (Entry<String,String> e : keys.entrySet()) { 
    329                 if (directionKeys.contains(e.getKey())) { 
     385                if (directionKeys.contains(e.getKey())) 
    330386                    return true; 
    331                 } 
    332387            } 
    333388        } 

  • trunk/src/org/openstreetmap/josm/data/osm/Relation.java

    r1677 r1690  
    7070    } 
    7171 
     72    @Deprecated 
    7273    @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) { 
    7374        return osm instanceof Relation ? super.realEqual(osm, semanticOnly) && members.equals(((Relation)osm).members) : false; 
     75    } 
     76 
     77    @Override 
     78    public boolean hasEqualSemanticAttributes(OsmPrimitive other) { 
     79        if (other == null || ! (other instanceof Relation) ) 
     80            return false; 
     81        if (! super.hasEqualSemanticAttributes(other)) 
     82            return false; 
     83        Relation r = (Relation)other; 
     84        return members.equals(r.members); 
    7485    } 
    7586 

  • trunk/src/org/openstreetmap/josm/data/osm/RelationMember.java

    r1169 r1690  
    3333 
    3434    @Override public boolean equals(Object other) { 
    35         if (!(other instanceof RelationMember)) return false; 
     35        if (other == null || !(other instanceof RelationMember)) return false; 
    3636        RelationMember otherMember = (RelationMember) other; 
    3737        return otherMember.role.equals(role) && otherMember.member.equals(member); 

  • trunk/src/org/openstreetmap/josm/data/osm/Way.java

    r1677 r1690  
    3939    public void visitNodes(Visitor v) { 
    4040        if (incomplete) return; 
    41         for (Node n : this.nodes) 
     41        for (Node n : this.nodes) { 
    4242            v.visit(n); 
     43        } 
    4344    } 
    4445 
    … …  
    100101    } 
    101102 
     103    @Deprecated 
    102104    @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) { 
    103105        return osm instanceof Way ? super.realEqual(osm, semanticOnly) && nodes.equals(((Way)osm).nodes) : false; 
     106    } 
     107 
     108    @Override 
     109    public boolean hasEqualSemanticAttributes(OsmPrimitive other) { 
     110        if (other == null || ! (other instanceof Way) ) 
     111            return false; 
     112        if (! super.hasEqualSemanticAttributes(other)) 
     113            return false; 
     114        Way w = (Way)other; 
     115        return nodes.equals(w.nodes); 
    104116    } 
    105117 
    … …  
    110122    } 
    111123 
     124    @Override 
    112125    public String getName() { 
    113126        String name; 
    … …  
    116129        } else { 
    117130            name = get("name"); 
    118             if (name == null) name = get("ref"); 
     131            if (name == null) { 
     132                name = get("ref"); 
     133            } 
    119134            if (name == null) { 
    120135                name = 
    121136                    (get("highway") != null) ? tr("highway") : 
    122                     (get("railway") != null) ? tr("railway") : 
    123                     (get("waterway") != null) ? tr("waterway") : 
    124                     (get("landuse") != null) ? tr("landuse") : ""; 
     137                        (get("railway") != null) ? tr("railway") : 
     138                            (get("waterway") != null) ? tr("waterway") : 
     139                                (get("landuse") != null) ? tr("landuse") : ""; 
    125140            } 
    126141 
    … …  
    128143            String nodes = trn("{0} node", "{0} nodes", nodesNo, nodesNo); 
    129144            name += (name.length() > 0) ? " ("+nodes+")" : nodes; 
    130             if(errors != null) 
     145            if(errors != null) { 
    131146                name = "*"+name; 
     147            } 
    132148        } 
    133149        return name; 
    … …  
    138154        boolean closed = (lastNode() == n && firstNode() == n); 
    139155        int i; 
    140         while ((i = nodes.indexOf(n)) >= 0) 
     156        while ((i = nodes.indexOf(n)) >= 0) { 
    141157            nodes.remove(i); 
     158        } 
    142159        i = nodes.size(); 
    143         if (closed && i > 2) // close again 
     160        if (closed && i > 2) { 
    144161            addNode(firstNode()); 
    145         // prevent closed ways with less than 3 different nodes 
    146         else if (i >= 2 && i <= 3 && nodes.get(0) == nodes.get(i-1)) 
     162        } else if (i >= 2 && i <= 3 && nodes.get(0) == nodes.get(i-1)) { 
    147163            nodes.remove(i-1); 
     164        } 
    148165    } 
    149166 
    … …  
    151168        if (incomplete) return; 
    152169        for(OsmPrimitive p : selection) { 
    153            if (p instanceof Node) { 
    154                removeNode((Node)p); 
    155            } 
    156        } 
     170            if (p instanceof Node) { 
     171                removeNode((Node)p); 
     172            } 
     173        } 
    157174    } 
    158175 

  • trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

    r1677 r1690  
    22package org.openstreetmap.josm.data.osm.visitor; 
    33 
     4import static org.openstreetmap.josm.tools.I18n.tr; 
     5 
    46import java.util.Collection; 
    5 import java.util.Date; 
    67import java.util.HashMap; 
    78import java.util.Iterator; 
    89import java.util.LinkedList; 
    910import java.util.Map; 
     11import java.util.logging.Logger; 
    1012 
    1113import org.openstreetmap.josm.data.osm.DataSet; 
     14import org.openstreetmap.josm.data.osm.Node; 
     15import org.openstreetmap.josm.data.osm.OsmPrimitive; 
    1216import org.openstreetmap.josm.data.osm.Relation; 
    1317import org.openstreetmap.josm.data.osm.RelationMember; 
    14 import org.openstreetmap.josm.data.osm.Node; 
    15 import org.openstreetmap.josm.data.osm.OsmPrimitive; 
    1618import org.openstreetmap.josm.data.osm.Way; 
    1719 
    1820/** 
    19  * A visitor that get a data set at construction time and merge every visited object 
     21 * A visitor that gets a data set at construction time and merges every visited object 
    2022 * into it. 
    2123 * 
    2224 * @author imi 
     25 * @author Gubaer 
    2326 */ 
    2427public class MergeVisitor extends AbstractVisitor { 
     28    private static Logger logger = Logger.getLogger(MergeVisitor.class.getName()); 
    2529 
    2630    /** 
    … …  
    2832     * round than merged) 
    2933     */ 
    30     public Map<OsmPrimitive, OsmPrimitive> conflicts = new HashMap<OsmPrimitive, OsmPrimitive>(); 
    31  
    32     private final DataSet ds; 
    33     private final DataSet mergeds; 
     34    private Map<OsmPrimitive, OsmPrimitive> conflicts; 
     35 
     36    private final DataSet myDataSet; 
     37    private final DataSet theirDataSet; 
    3438 
    3539    private final HashMap<Long, Node> nodeshash = new HashMap<Long, Node>(); 
    … …  
    4246     * in ds.nodes instead. 
    4347     */ 
    44     private final Map<OsmPrimitive, OsmPrimitive> merged 
    45         = new HashMap<OsmPrimitive, OsmPrimitive>(); 
    46  
    47     public MergeVisitor(DataSet ds, DataSet mergeds) { 
    48         this.ds = ds; 
    49         this.mergeds = mergeds; 
    50  
    51         for (Node n : ds.nodes) if (n.id != 0) nodeshash.put(n.id, n); 
    52         for (Way w : ds.ways) if (w.id != 0) wayshash.put(w.id, w); 
    53         for (Relation r : ds.relations) if (r.id != 0) relshash.put(r.id, r); 
    54     } 
    55  
    56     private <P extends OsmPrimitive> void genMerge(P other, 
    57             Collection<P> myprims, Collection<P> mergeprims, 
    58             HashMap<Long, P> primhash) { 
    59         // 1. Try to find an identical prim with the same id. 
    60         if (mergeById(myprims, primhash, other)) 
    61             return; 
    62  
    63         // 2. Try to find a prim we can merge with the prim from the other ds. 
    64         for (P my : myprims) { 
    65             // LinkedList.contains calls equal, and OsmPrimitive.equal 
    66             // compares just the id. 
    67             if (match(my, other) && !mergeprims.contains(my)) { 
    68                 merged.put(other, my); 
    69                 mergeCommon(my, other); 
     48    private Map<OsmPrimitive, OsmPrimitive> merged; 
     49 
     50    /** 
     51     * constructor 
     52     *  
     53     * The visitor will merge <code>theirDataSet</code> onto <code>myDataSet</code> 
     54     *  
     55     * @param myDataSet  dataset with my primitives 
     56     * @param theirDataSet dataset with their primitives. 
     57     */ 
     58    public MergeVisitor(DataSet myDataSet, DataSet theirDataSet) { 
     59        this.myDataSet = myDataSet; 
     60        this.theirDataSet = theirDataSet; 
     61 
     62        for (Node n : myDataSet.nodes) if (n.id != 0) { 
     63            nodeshash.put(n.id, n); 
     64        } 
     65        for (Way w : myDataSet.ways) if (w.id != 0) { 
     66            wayshash.put(w.id, w); 
     67        } 
     68        for (Relation r : myDataSet.relations) if (r.id != 0) { 
     69            relshash.put(r.id, r); 
     70        } 
     71        conflicts = new HashMap<OsmPrimitive, OsmPrimitive>(); 
     72        merged = new HashMap<OsmPrimitive, OsmPrimitive>(); 
     73    } 
     74 
     75    /** 
     76     * Merges a primitive <code>other</code> of type <P> onto my primitives. 
     77     *  
     78     * If other.id != 0 it tries to merge it with an corresponding primitive from 
     79     * my dataset with the same id. If this is not possible a conflict is remembered 
     80     * in {@see #conflicts}. 
     81     *  
     82     * If other.id == 0 it tries to find a primitive in my dataset with id == 0 which 
     83     * is semantically equal. If it finds one it merges its technical attributes onto 
     84     * my primitive. 
     85     *  
     86     * @param <P>  the type of the other primitive 
     87     * @param other  the other primitive 
     88     * @param myPrimitives the collection of my relevant primitives (i.e. only my 
     89     *    primitives of the same type) 
     90     * @param otherPrimitives  the collection of the other primitives 
     91     * @param primitivesWithDefinedIds the collection of my primitives with an 
     92     *   assigned id (i.e. id != 0) 
     93     */ 
     94    protected <P extends OsmPrimitive> void mergePrimitive(P other, 
     95            Collection<P> myPrimitives, Collection<P> otherPrimitives, 
     96            HashMap<Long, P> primitivesWithDefinedIds) { 
     97 
     98        if (other.id > 0 ) { 
     99            // try to merge onto a matching primitive with the same 
     100            // defined id 
     101            // 
     102            if (mergeById(myPrimitives, primitivesWithDefinedIds, other)) 
    70103                return; 
    71             } 
    72         } 
    73  
    74         // 3. No idea how to merge that.  Simply add it unchanged. 
    75         myprims.add(other); 
     104        } else { 
     105            // try to merge onto a primitive with which has no id assigned 
     106            // yet but which is equal in its semantic attributes 
     107            // 
     108            for (P my : myPrimitives) { 
     109                if (my.id >0 ) { 
     110                    continue; 
     111                } 
     112                if (my.hasEqualSemanticAttributes(other)) { 
     113                    // copy the technical attributes from their 
     114                    // version 
     115                    if (other.deleted) { 
     116                        myDataSet.unlinkReferencesToPrimitive(my); 
     117                        my.delete(true); 
     118                    } 
     119                    my.visible = other.visible; 
     120                    my.user = other.user; 
     121                    my.setTimestamp(other.getTimestamp()); 
     122                    my.modified = other.modified; 
     123                    merged.put(other, my); 
     124                    return; 
     125                } 
     126            } 
     127        } 
     128        // If we get here we didn't find a suitable primitive in 
     129        // my dataset. Just add other to my dataset. 
     130        // 
     131        myPrimitives.add(other); 
    76132    } 
    77133 
    78134    public void visit(Node other) { 
    79         genMerge(other, ds.nodes, mergeds.nodes, nodeshash); 
     135        mergePrimitive(other, myDataSet.nodes, theirDataSet.nodes, nodeshash); 
    80136    } 
    81137 
    82138    public void visit(Way other) { 
    83139        fixWay(other); 
    84         genMerge(other, ds.ways, mergeds.ways, wayshash); 
     140        mergePrimitive(other, myDataSet.ways, theirDataSet.ways, wayshash); 
    85141    } 
    86142 
    87143    public void visit(Relation other) { 
    88144        fixRelation(other); 
    89         genMerge(other, ds.relations, mergeds.relations, relshash); 
     145        mergePrimitive(other, myDataSet.relations, theirDataSet.relations, relshash); 
    90146    } 
    91147 
    … …  
    95151     */ 
    96152    public void fixReferences() { 
    97         for (Way w : ds.ways) fixWay(w); 
    98         for (Relation r : ds.relations) fixRelation(r); 
     153        for (Way w : myDataSet.ways) { 
     154            fixWay(w); 
     155        } 
     156        for (Relation r : myDataSet.relations) { 
     157            fixRelation(r); 
     158        } 
    99159        for (OsmPrimitive osm : conflicts.values()) 
    100             if (osm instanceof Way) 
     160            if (osm instanceof Way) { 
    101161                fixWay((Way)osm); 
    102             else if (osm instanceof Relation) 
     162            } else if (osm instanceof Relation) { 
    103163                fixRelation((Relation) osm); 
     164            } 
    104165    } 
    105166 
    … …  
    110171            Node otherN = (Node) merged.get(n); 
    111172            newNodes.add(otherN == null ? n : otherN); 
    112             if (otherN != null) 
     173            if (otherN != null) { 
    113174                replacedSomething = true; 
     175            } 
    114176        } 
    115177        if (replacedSomething) { 
    … …  
    139201    } 
    140202 
    141     private static <P extends OsmPrimitive> boolean match(P p1, P p2) { 
    142         if ((p1.id == 0 || p2.id == 0) && !p1.incomplete && !p2.incomplete) { 
    143             return realMatch(p1, p2); 
    144         } 
    145         return p1.id == p2.id; 
    146     } 
    147  
    148     /** @return true if the prims have pretty much the same data, i.e. the 
    149      * same position, the same members, ... 
    150      */ 
    151     // Java cannot dispatch on generics... 
    152     private static boolean realMatch(OsmPrimitive p1, OsmPrimitive p2) { 
    153         if (p1 instanceof Node && p2 instanceof Node) { 
    154             return realMatch((Node) p1, (Node) p2); 
    155         } else if (p1 instanceof Way && p2 instanceof Way) { 
    156             return realMatch((Way) p1, (Way) p2); 
    157         } else if (p1 instanceof Relation && p2 instanceof Relation) { 
    158             return realMatch((Relation) p1, (Relation) p2); 
    159         } else { 
    160             throw new RuntimeException("arguments have unknown type"); 
    161         } 
    162     } 
    163  
    164     private static boolean realMatch(Node n1, Node n2) { 
    165         return n1.getCoor().equalsEpsilon(n2.getCoor()); 
    166     } 
    167  
    168     private static boolean realMatch(Way w1, Way w2) { 
    169         if (w1.nodes.size() != w2.nodes.size()) 
    170             return false; 
    171         Iterator<Node> it = w1.nodes.iterator(); 
    172         for (Node n : w2.nodes) 
    173             if (!match(n, it.next())) 
    174                 return false; 
    175         return true; 
    176     } 
    177  
    178     private static boolean realMatch(Relation w1, Relation w2) { 
    179         // FIXME this is not perfect yet... 
    180         if (w1.members.size() != w2.members.size()) 
    181             return false; 
    182         for (RelationMember em : w1.members) { 
    183             if (!w2.members.contains(em)) { 
    184                 return false; 
    185             } 
    186         } 
    187         return true; 
    188     } 
    189  
    190     /** 
    191      * Merge the common parts of an osm primitive. 
    192      * @param my The object, the information gets merged into 
    193      * @param other The object, the information gets merged from 
    194      */ 
    195     private void mergeCommon(OsmPrimitive my, OsmPrimitive other) { 
    196         if (other.deleted) 
    197             my.delete(true); 
    198         if (my.id == 0 || !my.modified || other.modified) { 
    199             if (my.id == 0 && other.id != 0) { 
    200                 my.id = other.id; 
    201                 my.modified = other.modified; // match a new node 
    202                 my.version = other.version; 
    203             } else if (my.id != 0 && other.id != 0 && other.modified) 
    204                 my.modified = true; 
    205         } 
    206         if (other.keys == null) 
    207             return; 
    208         if (my.keySet().containsAll(other.keys.keySet())) 
    209             return; 
    210         if (my.keys == null) 
    211             my.keys = other.keys; 
    212         else 
    213             my.keys.putAll(other.keys); 
    214  
    215         my.modified = true; 
    216     } 
    217  
    218203    /** 
    219204     * Tries to merge a primitive <code>other</code> into an existing primitive with the same id. 
    220205     * 
    221206     * @param myPrimitives the complete set of my primitives (potential merge targets) 
    222      * @param myPrimitivesWithID the map of primitives (potential merge targets) with an id <> 0, for faster lookup 
     207     * @param myPrimitivesWithDefinedIds the map of primitives (potential merge targets) with an id <> 0, for faster lookup 
    223208     *    by id. Key is the id, value the primitive with the given value. myPrimitives.valueSet() is a 
    224209     *    subset of primitives. 
    225      * @param other  the other primitive which is to be merged with a primitive in primitives if possible 
     210     * @param other  the other primitive which is to be merged onto a primitive in my primitives 
    226211     * @return true, if this method was able to merge <code>other</code> with an existing node; false, otherwise 
    227212     */ 
    228213    private <P extends OsmPrimitive> boolean mergeById( 
    229             Collection<P> myPrimitives, HashMap<Long, P> myPrimitivesWithID, P other) { 
     214            Collection<P> myPrimitives, HashMap<Long, P> myPrimitivesWithDefinedIds, P other) { 
    230215 
    231216        // merge other into an existing primitive with the same id, if possible 
    232217        // 
    233         if (myPrimitivesWithID.containsKey(other.id)) { 
    234             P my = myPrimitivesWithID.get(other.id); 
    235             if (my.realEqual(other, true /* compare semantic fields only */)) { 
    236                 // make sure the merge target becomes the higher version number 
    237                 // and the later timestamp 
    238                 // 
    239                 my.version = Math.max(other.version, my.version); 
    240                 if (other.getTimestamp().after(my.getTimestamp())) { 
    241                     my.setTimestamp(other.getTimestamp()); 
     218        if (myPrimitivesWithDefinedIds.containsKey(other.id)) { 
     219            P my = myPrimitivesWithDefinedIds.get(other.id); 
     220            if (my.version <= other.version) { 
     221                if (! my.visible && other.visible) { 
     222                    // should not happen 
     223                    // 
     224                    logger.warning(tr("My primitive with id {0} and version {1} is visible although " 
     225                            + "their primitive with lower version {2} is not visible. " 
     226                            + "Can't deal with this inconsistency. Keeping my primitive. ", 
     227                            Long.toString(my.id),Long.toString(my.version), Long.toString(other.version) 
     228                    )); 
     229                    merged.put(other, my); 
     230                } else if (my.visible && ! other.visible) { 
     231                    // this is always a conflict because the user has to decide whether 
     232                    // he wants to create a clone of its local primitive or whether he 
     233                    // wants to purge my from the local dataset. He can't keep it unchanged 
     234                    // because it was deleted on the server. 
     235                    // 
     236                    conflicts.put(my,other); 
     237                } else if (! my.modified && other.modified) { 
     238                    // my not modified. We can assume that other is the most recent version. 
     239                    // clone it onto my. But check first, whether other is deleted. if so, 
     240                    // make sure that my is not references anymore in myDataSet. 
     241                    // 
     242                    if (other.deleted) { 
     243                        myDataSet.unlinkReferencesToPrimitive(my); 
     244                    } 
     245                    my.cloneFrom(other); 
     246                    merged.put(other, my); 
     247                } else if (! my.modified && !other.modified) { 
     248                    // nothing to merge 
     249                    // 
     250                    merged.put(other,my); 
     251                } else if (my.deleted != other.deleted) { 
     252                    // if we get here my is modified. Differences in deleted state 
     253                    // have to be resolved manually 
     254                    // 
     255                    conflicts.put(my,other); 
     256                } else if (! my.hasEqualSemanticAttributes(other)) { 
     257                    // my is modified and is not semantically equal with other. Can't automatically 
     258                    // resolve the differences 
     259                    // =>  create a conflict 
     260                    conflicts.put(my,other); 
     261                } else { 
     262                    // clone from other, but keep the modified flag. Clone will mainly copy 
     263                    // technical attributes like timestamp or user information. Semantic 
     264                    // attributes should already be equal if we get here. 
     265                    // 
     266                    my.cloneFrom(other); 
     267                    my.modified = true; 
     268                    merged.put(other, my); 
    242269                } 
     270            } else { 
     271                // my.version > other.version => keep my version 
    243272                merged.put(other, my); 
    244                 return true; 
    245             } 
    246         } 
    247  
    248         // try to merge into one of the existing primitives 
    249         // 
    250         for (P my : myPrimitives) { 
    251             if (my.realEqual(other, false /* compare all fields */)) { 
    252                 merged.put(other, my); 
    253                 return true; // no merge needed. 
    254             } 
    255             if (my.realEqual(other, true)) { 
    256                 // they differ in modified/version combination only. Auto-resolve it. 
    257                 merged.put(other, my); 
    258                 if (my.version < other.version) { 
    259                     my.version = other.version; 
    260                     my.modified = other.modified; 
    261                     my.setTimestamp(other.getTimestamp()); 
    262                 } 
    263                 return true; // merge done. 
    264             } 
    265             if (my.id == other.id && my.id != 0) { 
    266                 if (my.incomplete || other.incomplete) { 
    267                     if (my.incomplete) { 
    268                         my.cloneFrom(other); 
    269                     } 
    270                 } else if (my.modified && other.modified) { 
    271                     conflicts.put(my, other); 
    272                 } else if (!my.modified && !other.modified) { 
    273                     if (my.version < other.version) { 
    274                         my.cloneFrom(other); 
    275                     } 
    276                 } else if (other.modified) { 
    277                     if (my.version > other.version) { 
    278                         conflicts.put(my, other); 
    279                     } else { 
    280                         my.cloneFrom(other); 
    281                     } 
    282                 } else if (my.modified) { 
    283                     if (my.version < other.version) { 
    284                         conflicts.put(my, other); 
    285                     } 
    286                 } 
    287                 merged.put(other, my); 
    288                 return true; 
    289             } 
     273            } 
     274            return true; 
    290275        } 
    291276        return false; 
    292277    } 
     278 
     279 
     280    /** 
     281     * Runs the merge operation. Successfully merged {@see OsmPrimitive}s are in 
     282     * {@see #getMyDataSet()}. 
     283     *  
     284     * See {@see #getConflicts()} for a map of conflicts after the merge operation. 
     285     */ 
     286    public void merge() { 
     287        for (final OsmPrimitive primitive : theirDataSet.allPrimitives()) { 
     288            primitive.visit(this); 
     289        } 
     290        fixReferences(); 
     291    } 
     292 
     293    /** 
     294     * replies my dataset 
     295     *  
     296     * @return 
     297     */ 
     298    public DataSet getMyDataSet() { 
     299        return myDataSet; 
     300    } 
     301 
     302 
     303    /** 
     304     * replies the map of conflicts 
     305     *  
     306     * @return the map of conflicts 
     307     */ 
     308    public Map<OsmPrimitive, OsmPrimitive> getConflicts() { 
     309        return conflicts; 
     310    } 
    293311} 

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

    r1654 r1690  
    2323import org.openstreetmap.josm.gui.conflict.nodes.NodeListMergeModel; 
    2424import org.openstreetmap.josm.gui.conflict.nodes.NodeListMerger; 
     25import org.openstreetmap.josm.gui.conflict.properties.OperationCancelledException; 
    2526import org.openstreetmap.josm.gui.conflict.properties.PropertiesMergeModel; 
    2627import org.openstreetmap.josm.gui.conflict.properties.PropertiesMerger; 
    … …  
    145146        this.their =  their; 
    146147        propertiesMerger.getModel().populate(my, their); 
     148        if (propertiesMerger.getModel().hasVisibleStateConflict()) { 
     149            tabbedPane.setEnabledAt(1, false); 
     150            tabbedPane.setEnabledAt(2, false); 
     151            tabbedPane.setEnabledAt(3, false); 
     152            return; 
     153        } 
    147154        tabbedPane.setEnabledAt(0, true); 
    148155        tagMerger.getModel().populate(my, their); 
    … …  
    165172            tabbedPane.setEnabledAt(3, true); 
    166173        } 
     174 
    167175    } 
    168176 
    … …  
    173181     * @return the resolution command 
    174182     */ 
    175     public Command buildResolveCommand() { 
     183    public Command buildResolveCommand() throws OperationCancelledException { 
    176184        ArrayList<Command> commands = new ArrayList<Command>(); 
    177         if (tagMerger.getModel().getNumResolvedConflicts() > 0) { 
    178             commands.add(tagMerger.getModel().buildResolveCommand(my, their)); 
    179         } 
    180         commands.addAll(propertiesMerger.getModel().buildResolveCommand(my, their)); 
    181         if (my instanceof Way && nodeListMerger.getModel().isFrozen()) { 
    182             NodeListMergeModel model  =(NodeListMergeModel)nodeListMerger.getModel(); 
    183             commands.add(model.buildResolveCommand((Way)my, (Way)their)); 
    184         } else if (my instanceof Relation && relationMemberMerger.getModel().isFrozen()) { 
    185             RelationMemberListMergeModel model  =(RelationMemberListMergeModel)relationMemberMerger.getModel(); 
    186             commands.add(model.buildResolveCommand((Relation)my, (Relation)their)); 
    187         } 
    188         if (isResolvedCompletely()) { 
    189             commands.add( 
    190                     new VersionConflictResolveCommand(my, their) 
    191             ); 
     185        if (propertiesMerger.getModel().hasVisibleStateConflict()) { 
     186            if (propertiesMerger.getModel().isDecidedVisibleState()) { 
     187                commands.addAll(propertiesMerger.getModel().buildResolveCommand(my, their)); 
     188            } 
     189        } else { 
     190            if (tagMerger.getModel().getNumResolvedConflicts() > 0) { 
     191                commands.add(tagMerger.getModel().buildResolveCommand(my, their)); 
     192            } 
     193            commands.addAll(propertiesMerger.getModel().buildResolveCommand(my, their)); 
     194            if (my instanceof Way && nodeListMerger.getModel().isFrozen()) { 
     195                NodeListMergeModel model  =(NodeListMergeModel)nodeListMerger.getModel(); 
     196                commands.add(model.buildResolveCommand((Way)my, (Way)their)); 
     197            } else if (my instanceof Relation && relationMemberMerger.getModel().isFrozen()) { 
     198                RelationMemberListMergeModel model  =(RelationMemberListMergeModel)relationMemberMerger.getModel(); 
     199                commands.add(model.buildResolveCommand((Relation)my, (Relation)their)); 
     200            } 
     201            if (isResolvedCompletely()) { 
     202                commands.add( 
     203                        new VersionConflictResolveCommand(my, their) 
     204                ); 
     205            } 
    192206        } 
    193207        return new SequenceCommand(tr("Conflict Resolution"), commands); 

  • trunk/src/org/openstreetmap/josm/gui/conflict/properties/PropertiesMergeModel.java

    r1669 r1690  
    33 
    44import static org.openstreetmap.josm.gui.conflict.MergeDecisionType.UNDECIDED; 
     5import static org.openstreetmap.josm.tools.I18n.tr; 
    56 
    67import java.beans.PropertyChangeListener; 
    78import java.beans.PropertyChangeSupport; 
     9import java.io.IOException; 
     10import java.net.HttpURLConnection; 
    811import java.util.ArrayList; 
     12import java.util.HashMap; 
    913import java.util.List; 
    1014import java.util.Observable; 
    1115 
     16import javax.swing.JOptionPane; 
     17import javax.swing.text.html.HTML; 
     18 
     19import org.openstreetmap.josm.Main; 
    1220import org.openstreetmap.josm.command.Command; 
    1321import org.openstreetmap.josm.command.CoordinateConflictResolveCommand; 
    1422import org.openstreetmap.josm.command.DeletedStateConflictResolveCommand; 
     23import org.openstreetmap.josm.command.PurgePrimitivesCommand; 
     24import org.openstreetmap.josm.command.UndeletePrimitivesCommand; 
    1525import org.openstreetmap.josm.data.coor.LatLon; 
     26import org.openstreetmap.josm.data.osm.DataSet; 
    1627import org.openstreetmap.josm.data.osm.Node; 
    1728import org.openstreetmap.josm.data.osm.OsmPrimitive; 
     29import org.openstreetmap.josm.data.osm.OsmPrimitiveType; 
     30import org.openstreetmap.josm.data.osm.Relation; 
     31import org.openstreetmap.josm.data.osm.RelationMember; 
     32import org.openstreetmap.josm.data.osm.Way; 
     33import org.openstreetmap.josm.gui.PleaseWaitRunnable; 
    1834import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
     35import org.openstreetmap.josm.gui.conflict.properties.PropertiesMerger.KeepMyVisibleStateAction; 
     36import org.openstreetmap.josm.io.MultiFetchServerObjectReader; 
     37import org.openstreetmap.josm.io.OsmApi; 
     38import org.openstreetmap.josm.io.OsmApiException; 
     39import org.openstreetmap.josm.io.OsmServerObjectReader; 
     40import org.openstreetmap.josm.io.OsmTransferException; 
     41import org.xml.sax.SAXException; 
    1942 
    2043/** 
    2144 * This is the model for resolving conflicts in the properties of the 
    2245 * {@see OsmPrimitive}s. In particular, it represents conflicts in the coordiates of {@see Node}s and 
    23  * the deleted state of {@see OsmPrimitive}s. 
     46 * the deleted or visible state of {@see OsmPrimitive}s. 
    2447 * 
    2548 * This model is an {@see Observable}. It notifies registered {@see Observer}s whenever the 
    … …  
    3154 * @see Node#getCoor() 
    3255 * @see OsmPrimitive#deleted 
     56 * @see OsmPrimitive#visible 
    3357 * 
    3458 */ 
    … …  
    3761    static public final String RESOLVED_COMPLETELY_PROP = PropertiesMergeModel.class.getName() + ".resolvedCompletely"; 
    3862 
     63    private OsmPrimitive my; 
     64 
    3965    private LatLon myCoords; 
    4066    private LatLon theirCoords; 
    … …  
    4369    private boolean myDeletedState; 
    4470    private boolean theirDeletedState; 
     71    private boolean myVisibleState; 
     72    private boolean theirVisibleState; 
    4573    private MergeDecisionType deletedMergeDecision; 
     74    private MergeDecisionType visibleMergeDecision; 
    4675    private final PropertyChangeSupport support; 
    4776    private boolean resolvedCompletely; 
    … …  
    91120 
    92121    /** 
     122     * replies true if there is a  conflict in the visible state and if this conflict is 
     123     * resolved 
     124     * 
     125     * @return true if there is a conflict in the visible state and if this conflict is 
     126     * resolved; false, otherwise 
     127     */ 
     128    public boolean isDecidedVisibleState() { 
     129        return ! visibleMergeDecision.equals(UNDECIDED); 
     130    } 
     131 
     132    /** 
    93133     * replies true if the current decision for the coordinate conflict is <code>decision</code> 
    94134     * 
    … …  
    111151 
    112152    /** 
     153     * replies true if the current decision for the visible state conflict is <code>decision</code> 
     154     * 
     155     * @return true if the current decision for the visible state conflict is <code>decision</code>; 
     156     *  false, otherwise 
     157     */ 
     158    public boolean isVisibleStateDecision(MergeDecisionType decision) { 
     159        return visibleMergeDecision.equals(decision); 
     160    } 
     161    /** 
    113162     * populates the model with the differences between my and their version 
    114163     * 
    … …  
    117166     */ 
    118167    public void populate(OsmPrimitive my, OsmPrimitive their) { 
     168        this.my = my; 
    119169        if (my instanceof Node) { 
    120170            myCoords = ((Node)my).getCoor(); 
    … …  
    128178        theirDeletedState = their.deleted; 
    129179 
     180        myVisibleState = my.visible; 
     181        theirVisibleState = their.visible; 
     182 
    130183        coordMergeDecision = UNDECIDED; 
    131184        deletedMergeDecision = UNDECIDED; 
     185        visibleMergeDecision = UNDECIDED; 
    132186        setChanged(); 
    133187        notifyObservers(); 
    … …  
    209263    } 
    210264 
    211     public void decideDeletedStateConflict(MergeDecisionType decision) { 
     265 
     266    /** 
     267     * replies my visible state, 
     268     * @return my visible state 
     269     */ 
     270    public Boolean getMyVisibleState() { 
     271        return myVisibleState; 
     272    } 
     273 
     274    /** 
     275     * replies their visible state, 
     276     * @return their visible state 
     277     */ 
     278    public  Boolean getTheirVisibleState() { 
     279        return theirVisibleState; 
     280    } 
     281 
     282    /** 
     283     * replies the merged visible state; null, if the merge decision is 
     284     * {@see MergeDecisionType#UNDECIDED}. 
     285     *  
     286     * @return the merged visible state 
     287     */ 
     288    public Boolean getMergedVisibleState() { 
     289        switch(visibleMergeDecision) { 
     290        case KEEP_MINE: return myVisibleState; 
     291        case KEEP_THEIR: return theirVisibleState; 
     292        case UNDECIDED: return null; 
     293        } 
     294        // should not happen 
     295        return null; 
     296    } 
     297 
     298    /** 
     299     * decides the conflict between two deleted states 
     300     * @param decision the decision (must not be null) 
     301     *  
     302     * @throws IllegalArgumentException thrown, if decision is null 
     303     */ 
     304    public void decideDeletedStateConflict(MergeDecisionType decision) throws IllegalArgumentException{ 
     305        if (decision == null) 
     306            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "decision")); 
    212307        this.deletedMergeDecision = decision; 
     308        setChanged(); 
     309        notifyObservers(); 
     310        fireCompletelyResolved(); 
     311    } 
     312 
     313    /** 
     314     * decides the conflict between two visible states 
     315     * @param decision the decision (must not be null) 
     316     *  
     317     * @throws IllegalArgumentException thrown, if decision is null 
     318     */ 
     319    public void decideVisibleStateConflict(MergeDecisionType decision) throws IllegalArgumentException { 
     320        if (decision == null) 
     321            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "decision")); 
     322        this.visibleMergeDecision = decision; 
    213323        setChanged(); 
    214324        notifyObservers(); 
    … …  
    242352 
    243353    /** 
     354     * replies true if my and their primitive have a conflict between 
     355     * their visible states 
     356     * 
     357     * @return true if my and their primitive have a conflict between 
     358     * their visible states 
     359     */ 
     360    public boolean hasVisibleStateConflict() { 
     361        return myVisibleState != theirVisibleState; 
     362    } 
     363 
     364    /** 
    244365     * replies true if all conflict in this model are resolved 
    245366     * 
    … …  
    254375            ret = ret && ! deletedMergeDecision.equals(UNDECIDED); 
    255376        } 
     377        if (hasVisibleStateConflict()) { 
     378            ret = ret && ! visibleMergeDecision.equals(UNDECIDED); 
     379        } 
    256380        return ret; 
    257381    } 
    … …  
    264388     * @return the list of commands 
    265389     */ 
    266     public List<Command> buildResolveCommand(OsmPrimitive my, OsmPrimitive their) { 
     390    public List<Command> buildResolveCommand(OsmPrimitive my, OsmPrimitive their) throws OperationCancelledException{ 
    267391        ArrayList<Command> cmds = new ArrayList<Command>(); 
     392        if (hasVisibleStateConflict() && isDecidedVisibleState()) { 
     393            if (isVisibleStateDecision(MergeDecisionType.KEEP_MINE)) { 
     394                try { 
     395                    UndeletePrimitivesCommand cmd = createUndeletePrimitiveCommand(my); 
     396                    if (cmd == null) 
     397                        throw new OperationCancelledException(); 
     398                    cmds.add(cmd); 
     399                } catch(OsmTransferException e) { 
     400                    handleExceptionWhileBuildingCommand(e); 
     401                    throw new OperationCancelledException(e); 
     402                } 
     403            } else if (isVisibleStateDecision(MergeDecisionType.KEEP_THEIR)) { 
     404                cmds.add(new PurgePrimitivesCommand(my)); 
     405            } 
     406        } 
    268407        if (hasCoordConflict() && isDecidedCoord()) { 
    269408            cmds.add(new CoordinateConflictResolveCommand((Node)my, (Node)their, coordMergeDecision)); 
    … …  
    274413        return cmds; 
    275414    } 
     415 
     416    public OsmPrimitive getMyPrimitive() { 
     417        return my; 
     418    } 
     419 
     420    /** 
     421     *  
     422     * @param id 
     423     */ 
     424    protected void handleExceptionWhileBuildingCommand(Exception e) { 
     425        e.printStackTrace(); 
     426        String msg = e.getMessage() != null ? e.getMessage() : e.toString(); 
     427        msg = msg.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"); 
     428        JOptionPane.showMessageDialog( 
     429                Main.parent, 
     430                tr("<html>An error occurred while communicating with the server<br>" 
     431                        + "Details: {0}</html>", 
     432                        msg 
     433                ), 
     434                tr("Communication with server failed"), 
     435                JOptionPane.ERROR_MESSAGE 
     436        ); 
     437    } 
     438 
     439    /** 
     440     * User has decided to keep his local version of a primitive which had been deleted 
     441     * on the server 
     442     *  
     443     * @param id the primitive id 
     444     */ 
     445    protected UndeletePrimitivesCommand createUndeletePrimitiveCommand(OsmPrimitive my) throws OsmTransferException { 
     446        if (my instanceof Node) 
     447            return createUndeleteNodeCommand((Node)my); 
     448        else if (my instanceof Way) 
     449            return createUndeleteWayCommand((Way)my); 
     450        else if (my instanceof Relation) 
     451            return createUndeleteRelationCommand((Relation)my); 
     452        return null; 
     453    } 
     454    /** 
     455     * Undelete a node which is already deleted on the server. The API 
     456     * doesn't offer a call for "undeleting" a node. We therefore create 
     457     * a clone of the node which we flag as new. On the next upload the 
     458     * server will assign the node a new id. 
     459     *  
     460     * @param node the node to undelete 
     461     */ 
     462    protected UndeletePrimitivesCommand  createUndeleteNodeCommand(Node node) { 
     463        return new UndeletePrimitivesCommand(node); 
     464    } 
     465 
     466    /** 
     467     * displays a confirmation message. The user has to confirm that additional dependent 
     468     * nodes should be undeleted too. 
     469     *  
     470     * @param way  the way 
     471     * @param dependent a list of dependent nodes which have to be undelete too 
     472     * @return true, if the user confirms; false, otherwise 
     473     */ 
     474    protected boolean confirmUndeleteDependentPrimitives(Way way, ArrayList<OsmPrimitive> dependent) { 
     475        String [] options = { 
     476                tr("Yes, undelete them too"), 
     477                tr("No, cancel operation") 
     478        }; 
     479        int ret = JOptionPane.showOptionDialog( 
     480                Main.parent, 
     481                tr("<html>There are {0} additional nodes used by way {1}<br>" 
     482                        + "which are deleted on the server.<br>" 
     483                        + "<br>" 
     484                        + "Do you want to undelete these nodes too?</html>", 
     485                        Long.toString(dependent.size()), Long.toString(way.id)), 
     486                        tr("Undelete additional nodes?"), 
     487                        JOptionPane.YES_NO_OPTION, 
     488                        JOptionPane.QUESTION_MESSAGE, 
     489                        null, 
     490                        options, 
     491                        options[0] 
     492        ); 
     493 
     494        switch(ret) { 
     495        case JOptionPane.CLOSED_OPTION: return false; 
     496        case JOptionPane.YES_OPTION: return true; 
     497        case JOptionPane.NO_OPTION: return false; 
     498        } 
     499        return false; 
     500 
     501    } 
     502 
     503    protected boolean confirmUndeleteDependentPrimitives(Relation r, ArrayList<OsmPrimitive> dependent) { 
     504        String [] options = { 
     505                tr("Yes, undelete them too"), 
     506                tr("No, cancel operation") 
     507        }; 
     508        int ret = JOptionPane.showOptionDialog( 
     509                Main.parent, 
     510                tr("<html>There are {0} additional primitives referred to by relation {1}<br>" 
     511                        + "which are deleted on the server.<br>" 
     512                        + "<br>" 
     513                        + "Do you want to undelete them too?</html>", 
     514                        Long.toString(dependent.size()), Long.toString(r.id)), 
     515                        tr("Undelete dependent primitives?"), 
     516                        JOptionPane.YES_NO_OPTION, 
     517                        JOptionPane.QUESTION_MESSAGE, 
     518                        null, 
     519                        options, 
     520                        options[0] 
     521        ); 
     522 
     523        switch(ret) { 
     524        case JOptionPane.CLOSED_OPTION: return false; 
     525        case JOptionPane.YES_OPTION: return true; 
     526        case JOptionPane.NO_OPTION: return false; 
     527        } 
     528        return false; 
     529 
     530    } 
     531 
     532    /** 
     533     * Creates the undelete command for a way which is already deleted on the server. 
     534     *  
     535     * This method also checks whether there are additional nodes referred to by 
     536     * this way which are deleted on the server too. 
     537     *  
     538     * @param way the way to undelete 
     539     * @return the undelete command 
     540     * @see #createUndeleteNodeCommand(Node) 
     541     */ 
     542    protected UndeletePrimitivesCommand createUndeleteWayCommand(final Way way) throws OsmTransferException { 
     543 
     544        HashMap<Long,OsmPrimitive> candidates = new HashMap<Long,OsmPrimitive>(); 
     545        for (Node n : way.nodes) { 
     546            if (n.id > 0 && ! candidates.values().contains(n)) { 
     547                candidates.put(n.id, n); 
     548            } 
     549        } 
     550        MultiFetchServerObjectReader reader = new MultiFetchServerObjectReader(); 
     551        reader.append(candidates.values()); 
     552        DataSet ds = reader.parseOsm(); 
     553 
     554        ArrayList<OsmPrimitive> toDelete = new ArrayList<OsmPrimitive>(); 
     555        for (OsmPrimitive their : ds.allPrimitives()) { 
     556            if (candidates.keySet().contains(their.id) && ! their.visible) { 
     557                toDelete.add(candidates.get(their.id)); 
     558            } 
     559        } 
     560        if (!toDelete.isEmpty()) { 
     561            if (! confirmUndeleteDependentPrimitives(way, toDelete)) 
     562                // FIXME: throw exception ? 
     563                return null; 
     564        } 
     565        toDelete.add(way); 
     566        return new UndeletePrimitivesCommand(toDelete); 
     567    } 
     568 
     569    /** 
     570     * Creates an undelete command for a relation which is already deleted on the server. 
     571     *  
     572     * This method  checks whether there are additional primitives referred to by 
     573     * this relation which are already deleted on the server. 
     574     *  
     575     * @param r the relation 
     576     * @return the undelete command 
     577     * @see #createUndeleteNodeCommand(Node) 
     578     */ 
     579    protected UndeletePrimitivesCommand createUndeleteRelationCommand(final Relation r) throws OsmTransferException { 
     580 
     581        HashMap<Long,OsmPrimitive> candidates = new HashMap<Long, OsmPrimitive>(); 
     582        for (RelationMember m : r.members) { 
     583            if (m.member.id > 0 && !candidates.values().contains(m.member)) { 
     584                candidates.put(m.member.id,m.member); 
     585            } 
     586        } 
     587 
     588        MultiFetchServerObjectReader reader = new MultiFetchServerObjectReader(); 
     589        reader.append(candidates.values()); 
     590        DataSet ds = reader.parseOsm(); 
     591 
     592        ArrayList<OsmPrimitive> toDelete = new ArrayList<OsmPrimitive>(); 
     593        for (OsmPrimitive their : ds.allPrimitives()) { 
     594            if (candidates.keySet().contains(their.id) && ! their.visible) { 
     595                toDelete.add(candidates.get(their.id)); 
     596            } 
     597        } 
     598        if (!toDelete.isEmpty()) { 
     599            if (! confirmUndeleteDependentPrimitives(r, toDelete)) 
     600                // FIXME: throw exception ? 
     601                return null; 
     602        } 
     603        toDelete.add(r); 
     604        return new UndeletePrimitivesCommand(toDelete); 
     605    } 
     606 
    276607} 

  • trunk/src/org/openstreetmap/josm/gui/conflict/properties/PropertiesMerger.java

    r1676 r1690  
    1818import javax.swing.JButton; 
    1919import javax.swing.JLabel; 
     20import javax.swing.JOptionPane; 
    2021import javax.swing.JPanel; 
    21  
     22import javax.swing.SwingUtilities; 
     23 
     24import org.openstreetmap.josm.Main; 
    2225import org.openstreetmap.josm.data.coor.LatLon; 
     26import org.openstreetmap.josm.data.osm.OsmPrimitiveType; 
    2327import org.openstreetmap.josm.gui.conflict.MergeDecisionType; 
    2428import org.openstreetmap.josm.tools.ImageProvider; 
    … …  
    4852    private JLabel lblTheirDeletedState; 
    4953 
     54    private JLabel lblMyVisibleState; 
     55    private JLabel lblMergedVisibleState; 
     56    private JLabel lblTheirVisibleState; 
     57 
    5058    private final PropertiesMergeModel model; 
    5159 
    … …  
    5967    } 
    6068 
    61     protected void build() { 
    62         setLayout(new GridBagLayout()); 
     69    protected void buildHeaderRow() { 
    6370        GridBagConstraints gc = new GridBagConstraints(); 
    6471 
    65         // ------------------ 
    6672        gc.gridx = 1; 
    6773        gc.gridy = 0; 
    … …  
    8894        lblTheirVersion.setToolTipText(tr("Properties in their dataset, i.e. the server dataset")); 
    8995        add(lblTheirVersion, gc); 
    90  
    91         // -------------------------------- 
     96    } 
     97 
     98    protected void buildCoordinateConflictRows() { 
     99        GridBagConstraints gc = new GridBagConstraints(); 
     100 
    92101        gc.gridx = 0; 
    93102        gc.gridy = 1; 
    … …  
    161170        JButton btnUndecideCoordinates = new JButton(actUndecideCoordinates); 
    162171        add(btnUndecideCoordinates, gc); 
    163         // --------------------------------------------------- 
     172    } 
     173 
     174    protected void buildDeletedStateConflictRows() { 
     175        GridBagConstraints gc = new GridBagConstraints(); 
    164176 
    165177        gc.gridx = 0; 
    … …  
    191203        model.addObserver(actKeepMyDeletedState); 
    192204        JButton btnKeepMyDeletedState = new JButton(actKeepMyDeletedState); 
    193         btnKeepMyCoordinates.setName("button.keepmydeletedstate"); 
     205        btnKeepMyDeletedState.setName("button.keepmydeletedstate"); 
    194206        add(btnKeepMyDeletedState, gc); 
    195207 
    … …  
    212224        model.addObserver(actKeepTheirDeletedState); 
    213225        JButton btnKeepTheirDeletedState = new JButton(actKeepTheirDeletedState); 
    214         btnKeepMyCoordinates.setName("button.keeptheirdeletedstate"); 
     226        btnKeepTheirDeletedState.setName("button.keeptheirdeletedstate"); 
    215227        add(btnKeepTheirDeletedState, gc); 
    216228 
    … …  
    233245        model.addObserver(actUndecideDeletedState); 
    234246        JButton btnUndecideDeletedState = new JButton(actUndecideDeletedState); 
    235         btnKeepMyCoordinates.setName("button.undecidedeletedstate"); 
     247        btnUndecideDeletedState.setName("button.undecidedeletedstate"); 
    236248        add(btnUndecideDeletedState, gc); 
    237  
     249    } 
     250 
     251    protected void buildVisibleStateRows() { 
     252        GridBagConstraints gc = new GridBagConstraints(); 
     253 
     254        gc.gridx = 0; 
     255        gc.gridy = 5; 
     256        gc.gridwidth = 1; 
     257        gc.gridheight = 1; 
     258        gc.fill = GridBagConstraints.BOTH; 
     259        gc.anchor = GridBagConstraints.LINE_START; 
     260        gc.weightx = 0.0; 
     261        gc.weighty = 0.0; 
     262        gc.insets = new Insets(0,5,0,5); 
     263        add(new JLabel(tr("Visible State:")), gc); 
     264 
     265        gc.gridx = 1; 
     266        gc.gridy = 5; 
     267        gc.fill = GridBagConstraints.BOTH; 
     268        gc.anchor = GridBagConstraints.CENTER; 
     269        gc.weightx = 0.33; 
     270        gc.weighty = 0.0; 
     271        add(lblMyVisibleState = buildValueLabel("label.myvisiblestate"), gc); 
     272 
     273        gc.gridx = 2; 
     274        gc.gridy = 5; 
     275        gc.fill = GridBagConstraints.NONE; 
     276        gc.anchor = GridBagConstraints.CENTER; 
     277        gc.weightx = 0.0; 
     278        gc.weighty = 0.0; 
     279        KeepMyVisibleStateAction actKeepMyVisibleState = new KeepMyVisibleStateAction(); 
     280        model.addObserver(actKeepMyVisibleState); 
     281        JButton btnKeepMyVisibleState = new JButton(actKeepMyVisibleState); 
     282        btnKeepMyVisibleState.setName("button.keepmyvisiblestate"); 
     283        add(btnKeepMyVisibleState, gc); 
     284 
     285        gc.gridx = 3; 
     286        gc.gridy = 5; 
     287        gc.fill = GridBagConstraints.BOTH; 
     288        gc.anchor = GridBagConstraints.CENTER; 
     289        gc.weightx = 0.33; 
     290        gc.weighty = 0.0; 
     291        add(lblMergedVisibleState = buildValueLabel("label.mergedvisiblestate"), gc); 
     292 
     293        gc.gridx = 4; 
     294        gc.gridy = 5; 
     295        gc.fill = GridBagConstraints.NONE; 
     296        gc.anchor = GridBagConstraints.CENTER; 
     297        gc.weightx = 0.0; 
     298        gc.weighty = 0.0; 
     299        KeepTheirVisibleStateAction actKeepTheirVisibleState = new KeepTheirVisibleStateAction(); 
     300        model.addObserver(actKeepTheirVisibleState); 
     301        JButton btnKeepTheirVisibleState = new JButton(actKeepTheirVisibleState); 
     302        btnKeepTheirVisibleState.setName("button.keeptheirvisiblestate"); 
     303        add(btnKeepTheirVisibleState, gc); 
     304 
     305        gc.gridx = 5; 
     306        gc.gridy = 5; 
     307        gc.fill = GridBagConstraints.BOTH; 
     308        gc.anchor = GridBagConstraints.CENTER; 
     309        gc.weightx = 0.33; 
     310        gc.weighty = 0.0; 
     311        add(lblTheirVisibleState = buildValueLabel("label.theirvisiblestate"), gc); 
     312 
     313        // --------------------------------------------------- 
     314        gc.gridx = 3; 
     315        gc.gridy = 6; 
     316        gc.fill = GridBagConstraints.NONE; 
     317        gc.anchor = GridBagConstraints.CENTER; 
     318        gc.weightx = 0.0; 
     319        gc.weighty = 0.0; 
     320        UndecideVisibleStateConflictAction actUndecideVisibleState = new UndecideVisibleStateConflictAction(); 
     321        model.addObserver(actUndecideVisibleState); 
     322        JButton btnUndecideVisibleState = new JButton(actUndecideVisibleState); 
     323        btnUndecideVisibleState.setName("button.undecidevisiblestate"); 
     324        add(btnUndecideVisibleState, gc); 
     325    } 
     326 
     327    protected void build() { 
     328        setLayout(new GridBagLayout()); 
     329        buildHeaderRow(); 
     330        buildCoordinateConflictRows(); 
     331        buildDeletedStateConflictRows(); 
     332        buildVisibleStateRows(); 
    238333    } 
    239334 
    … …  
    265360    } 
    266361 
    267     protected void updateCoordiates() { 
     362    public String visibleStateToString(Boolean visible) { 
     363        if (visible == null) 
     364            return tr("(none)"); 
     365        if (visible) 
     366            return tr("visible (on the server)"); 
     367        else 
     368            return tr("not visible (on the server)"); 
     369    } 
     370 
     371    public String visibleStateToStringMerged(Boolean visible) { 
     372        if (visible == null) 
     373            return tr("(none)"); 
     374        if (visible) 
     375            return tr("Keep a clone of the local version"); 
     376        else 
     377            return tr("Physically delete from local dataset"); 
     378    } 
     379 
     380    protected void updateCoordinates() { 
    268381        lblMyCoordinates.setText(coordToString(model.getMyCoords())); 
    269382        lblMergedCoordinates.setText(coordToString(model.getMergedCoords())); 
    … …  
    320433    } 
    321434 
     435    protected void updateVisibleState() { 
     436        lblMyVisibleState.setText(visibleStateToString(model.getMyVisibleState())); 
     437        lblMergedVisibleState.setText(visibleStateToStringMerged(model.getMergedVisibleState())); 
     438        lblTheirVisibleState.setText(visibleStateToString(model.getTheirVisibleState())); 
     439 
     440        if (! model.hasVisibleStateConflict()) { 
     441            lblMyVisibleState.setBackground(BGCOLOR_NO_CONFLICT); 
     442            lblMergedVisibleState.setBackground(BGCOLOR_NO_CONFLICT); 
     443            lblTheirVisibleState.setBackground(BGCOLOR_NO_CONFLICT); 
     444        } else { 
     445            if (!model.isDecidedVisibleState()) { 
     446                lblMyVisibleState.setBackground(BGCOLOR_UNDECIDED); 
     447                lblMergedVisibleState.setBackground(BGCOLOR_NO_CONFLICT); 
     448                lblTheirVisibleState.setBackground(BGCOLOR_UNDECIDED); 
     449            } else { 
     450                lblMyVisibleState.setBackground( 
     451                        model.isVisibleStateDecision(MergeDecisionType.KEEP_MINE) 
     452                        ? BGCOLOR_DECIDED : BGCOLOR_NO_CONFLICT 
     453                ); 
     454                lblMergedVisibleState.setBackground(BGCOLOR_DECIDED); 
     455                lblTheirVisibleState.setBackground( 
     456                        model.isVisibleStateDecision(MergeDecisionType.KEEP_THEIR) 
     457                        ? BGCOLOR_DECIDED : BGCOLOR_NO_CONFLICT 
     458                ); 
     459            } 
     460        } 
     461    } 
     462 
    322463    public void update(Observable o, Object arg) { 
    323         updateCoordiates(); 
     464        updateCoordinates(); 
    324465        updateDeletedState(); 
     466        updateVisibleState(); 
    325467    } 
    326468 
    … …  
    418560        } 
    419561    } 
     562 
     563    class KeepMyVisibleStateAction extends AbstractAction implements Observer { 
     564        public KeepMyVisibleStateAction() { 
     565            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeepmine")); 
     566            putValue(Action.SHORT_DESCRIPTION, tr("Keep my visible state")); 
     567        } 
     568 
     569        public void actionPerformed(ActionEvent e) { 
     570            if (confirmKeepMine()) { 
     571                model.decideVisibleStateConflict(MergeDecisionType.KEEP_MINE); 
     572            } 
     573        } 
     574 
     575        public void update(Observable o, Object arg) { 
     576            setEnabled(model.hasVisibleStateConflict() && ! model.isDecidedVisibleState()); 
     577        } 
     578 
     579        protected boolean confirmKeepMine() { 
     580            String [] options = { 
     581                    tr("Yes, reset the id"), 
     582                    tr("No, abort") 
     583            }; 
     584            int ret = JOptionPane.showOptionDialog( 
     585                    null, 
     586                    tr("<html>To keep your local version, JOSM<br>" 
     587                            + "has to reset the id of {0} {1} to 0.<br>" 
     588                            + "On the next upload the server will assign<br>" 
     589                            + "it a new id.<br>" 
     590                            + "Do yo agree?</html>", 
     591                            OsmPrimitiveType.from(model.getMyPrimitive()).getLocalizedDisplayNamePlural(), 
     592                            model.getMyPrimitive().id 
     593                    ), 
     594                    tr("Reset id to 0"), 
     595                    JOptionPane.YES_NO_OPTION, 
     596                    JOptionPane.QUESTION_MESSAGE, 
     597                    null, 
     598                    options, 
     599                    options[1] 
     600            ); 
     601            return ret == JOptionPane.YES_OPTION; 
     602        } 
     603    } 
     604 
     605    class KeepTheirVisibleStateAction extends AbstractAction implements Observer { 
     606        public KeepTheirVisibleStateAction() { 
     607            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeeptheir")); 
     608            putValue(Action.SHORT_DESCRIPTION, tr("Keep their visible state")); 
     609        } 
     610 
     611        public void actionPerformed(ActionEvent e) { 
     612            if (confirmKeepTheir()){ 
     613                model.decideVisibleStateConflict(MergeDecisionType.KEEP_THEIR); 
     614            } 
     615        } 
     616 
     617        public void update(Observable o, Object arg) { 
     618            setEnabled(model.hasVisibleStateConflict() && ! model.isDecidedVisibleState()); 
     619        } 
     620 
     621        protected boolean confirmKeepTheir() { 
     622            String [] options = { 
     623                    tr("Yes, purge it"), 
     624                    tr("No, abort") 
     625            }; 
     626            int ret = JOptionPane.showOptionDialog( 
     627                    null, 
     628                    tr("<html>JOSM will have to remove your local primitive with id {0}<br>" 
     629                            + "from the dataset.<br>" 
     630                            + "Do you agree?</html>", 
     631                            model.getMyPrimitive().id 
     632                    ), 
     633                    tr("Remove from dataset"), 
     634                    JOptionPane.YES_NO_OPTION, 
     635                    JOptionPane.QUESTION_MESSAGE, 
     636                    null, 
     637                    options, 
     638                    options[1] 
     639            ); 
     640            return ret == JOptionPane.YES_OPTION; 
     641        } 
     642    } 
     643 
     644    class UndecideVisibleStateConflictAction extends AbstractAction implements Observer { 
     645        public UndecideVisibleStateConflictAction() { 
     646            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagundecide")); 
     647            putValue(Action.SHORT_DESCRIPTION, tr("Undecide conflict between visible state")); 
     648        } 
     649 
     650        public void actionPerformed(ActionEvent e) { 
     651            model.decideVisibleStateConflict(MergeDecisionType.UNDECIDED); 
     652        } 
     653 
     654        public void update(Observable o, Object arg) { 
     655            setEnabled(model.hasVisibleStateConflict() && model.isDecidedVisibleState()); 
     656        } 
     657    } 
    420658} 

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

    r1677 r1690  
    2323import org.openstreetmap.josm.command.Command; 
    2424import org.openstreetmap.josm.gui.conflict.ConflictResolver; 
     25import org.openstreetmap.josm.gui.conflict.properties.OperationCancelledException; 
    2526import org.openstreetmap.josm.tools.ImageProvider; 
    2627 
    … …  
    190191                    return; 
    191192            } 
    192             Command cmd = resolver.buildResolveCommand(); 
    193             Main.main.undoRedo.add(cmd); 
     193            try { 
     194                Command cmd = resolver.buildResolveCommand(); 
     195                Main.main.undoRedo.add(cmd); 
     196            } catch(OperationCancelledException e) { 
     197                // do nothing. Exception already reported 
     198            } 
    194199            setVisible(false); 
    195200        } 

  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r1670 r1690  
    527527                    final MergeVisitor visitor = new MergeVisitor(Main.main 
    528528                            .editLayer().data, dataSet); 
    529                     for (final OsmPrimitive osm : dataSet.allPrimitives()) { 
    530                         osm.visit(visitor); 
    531                     } 
    532                     visitor.fixReferences(); 
     529                    visitor.merge(); 
    533530 
    534531                    // copy the merged layer's data source info 
    … …  
    538535                    Main.main.editLayer().fireDataChange(); 
    539536 
    540                     if (visitor.conflicts.isEmpty()) 
     537                    if (visitor.getConflicts().isEmpty()) 
    541538                        return; 
    542539                    final ConflictDialog dlg = Main.map.conflictDialog; 
    543                     dlg.add(visitor.conflicts); 
     540                    dlg.add(visitor.getConflicts()); 
    544541                    JOptionPane.showMessageDialog(Main.parent, 
    545542                            tr("There were conflicts during import.")); 

  • trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r1677 r1690  
    245245    public void mergeFrom(final DataSet from) { 
    246246        final MergeVisitor visitor = new MergeVisitor(data,from); 
    247         for (final OsmPrimitive osm : from.allPrimitives()) { 
    248             osm.visit(visitor); 
    249         } 
    250         visitor.fixReferences(); 
     247        visitor.merge(); 
    251248 
    252249        Area a = data.getDataSourceArea(); 
    … …  
    274271        Main.map.mapView.repaint(); 
    275272 
    276         if (visitor.conflicts.isEmpty()) 
     273        if (visitor.getConflicts().isEmpty()) 
    277274            return; 
    278275        final ConflictDialog dlg = Main.map.conflictDialog; 
    279         dlg.add(visitor.conflicts); 
    280         JOptionPane.showMessageDialog(Main.parent,tr("There were {0} conflicts during import.", visitor.conflicts.size())); 
     276        dlg.add(visitor.getConflicts()); 
     277        JOptionPane.showMessageDialog(Main.parent,tr("There were {0} conflicts during import.", visitor.getConflicts().size())); 
    281278        if (!dlg.isVisible()) { 
    282279            dlg.action.actionPerformed(new ActionEvent(this, 0, "")); 

  • trunk/src/org/openstreetmap/josm/io/OsmApi.java

    r1688 r1690  
    44import static org.openstreetmap.josm.tools.I18n.tr; 
    55 
     6import java.awt.EventQueue; 
    67import java.io.BufferedReader; 
    78import java.io.BufferedWriter; 
    … …  
    323324        } 
    324325        notifyStatusMessage(tr("Uploading...")); 
     326        setAutoProgressIndication(true); 
    325327 
    326328        String diff = duv.getDocument(); 
    … …  
    330332        } catch(Exception e) { 
    331333            throw new OsmTransferException(e); 
     334        } finally { 
     335            setAutoProgressIndication(false); 
    332336        } 
    333337 
    … …  
    481485        Main.pleaseWaitDlg.progress.setValue(current + delta); 
    482486    } 
     487 
     488 
     489    protected void setAutoProgressIndication(final boolean enabled) { 
     490        EventQueue.invokeLater( 
     491                new Runnable() { 
     492                    public void run() { 
     493                        Main.pleaseWaitDlg.setIndeterminate(enabled); 
     494                    } 
     495                } 
     496        ); 
     497    } 
    483498} 

  • trunk/src/org/openstreetmap/josm/io/OsmReader.java

    r1677 r1690  
    99import java.util.ArrayList; 
    1010import java.util.Collection; 
     11import java.util.Date; 
    1112import java.util.HashMap; 
     13import java.util.HashSet; 
    1214import java.util.LinkedList; 
    1315import java.util.Map; 
     16import java.util.Set; 
    1417import java.util.Map.Entry; 
    1518 
    … …  
    2932import org.openstreetmap.josm.data.osm.Way; 
    3033import org.openstreetmap.josm.data.osm.visitor.AddVisitor; 
    31 import org.openstreetmap.josm.data.osm.visitor.Visitor; 
    3234import org.openstreetmap.josm.gui.PleaseWaitDialog; 
    3335import org.openstreetmap.josm.tools.DateUtils; 
    … …  
    4951public class OsmReader { 
    5052 
    51 //     static long tagsN = 0; 
    52 //     static long nodesN = 0; 
    53 //     static long waysN = 0; 
    54 //     static long relationsN = 0; 
    55 //     static long membersN = 0; 
    56  
    57      static InputStream currSource; 
    58  
    59      /** 
    60       * This is used as (readonly) source for finding missing references when not transferred in the 
    61       * file. 
    62       */ 
    63      private DataSet references; 
    64  
    65      /** 
    66       * The dataset to add parsed objects to. 
    67       */ 
    68      private DataSet ds = new DataSet(); 
    69      public DataSet getDs() { return ds; } 
    70  
    71      /** 
    72       * Record warnings.  If there were any data inconsistencies, append 
    73       * a newline-terminated string. 
    74       */ 
    75      private String parseNotes = new String(); 
    76      private int parseNotesCount = 0; 
    77      public String getParseNotes() { 
    78          return parseNotes; 
    79      } 
    80  
    81      /** 
    82       * The visitor to use to add the data to the set. 
    83       */ 
    84      private AddVisitor adder = new AddVisitor(ds); 
    85  
    86      /** 
    87       * All read nodes after phase 1. 
    88       */ 
    89      private Map<Long, Node> nodes = new HashMap<Long, Node>(); 
    90  
    91      // TODO: What the hack? Is this really from me? Please, clean this up! 
    92      private static class OsmPrimitiveData extends OsmPrimitive { 
    93           @Override public void visit(Visitor visitor) {} 
    94           public int compareTo(OsmPrimitive o) {return 0;} 
    95  
    96           public void copyTo(OsmPrimitive osm) { 
    97                osm.id = id; 
    98                osm.keys = keys; 
    99                osm.modified = modified; 
    100                osm.selected = selected; 
    101                osm.deleted = deleted; 
    102                osm.setTimestamp(getTimestamp()); 
    103                osm.user = user; 
    104                osm.visible = visible; 
    105                osm.version = version; 
    106                osm.mappaintStyle = null; 
    107           } 
    108      } 
    109  
    110      /** 
    111       * Used as a temporary storage for relation members, before they 
    112       * are resolved into pointers to real objects. 
    113       */ 
    114      private static class RelationMemberData { 
    115           public String type; 
    116           public long id; 
    117           public RelationMember relationMember; 
    118      } 
    119  
    120      /** 
    121       * Data structure for the remaining way objects 
    122       */ 
    123      private Map<OsmPrimitiveData, Collection<Long>> ways = new HashMap<OsmPrimitiveData, Collection<Long>>(); 
    124  
    125      /** 
    126       * Data structure for relation objects 
    127       */ 
    128      private Map<OsmPrimitiveData, Collection<RelationMemberData>> relations = new HashMap<OsmPrimitiveData, Collection<RelationMemberData>>(); 
    129  
    130      private class Parser extends DefaultHandler { 
    131           /** 
    132            * The current osm primitive to be read. 
    133            */ 
    134           private OsmPrimitive current; 
    135           private String generator; 
    136           private Map<String, String> keys = new HashMap<String, String>(); 
    137 //          int n = 0; 
    138  
    139           @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException { 
    140                try { 
    141 //                    if(n%100000 == 0) { 
    142 //                        try { 
    143 //                            FileInputStream fis = (FileInputStream)currSource; 
    144 //                            FileChannel channel = fis.getChannel(); 
    145 //                            double perc = (((double)channel.position()) / ((double)channel.size()) * 100.0); 
    146 //                            System.out.format(" " + (int)perc + "%%"); 
    147 //                        } 
    148 //                        catch(java.lang.ClassCastException cce) { 
    149 //                        } 
    150 //                        catch(IOException e) { 
    151 //                            System.out.format("Error reading file position " + e); 
    152 //                        } 
    153 //                    } 
    154 //                    n++; 
    155  
    156                     if (qName.equals("osm")) { 
    157                          if (atts == null) 
    158                               throw new SAXException(tr("Unknown version")); 
    159                          String v = atts.getValue("version"); 
    160                          if (v == null) 
    161                              throw new SAXException(tr("Version number missing from OSM data")); 
    162                          if (!(v.equals("0.5") || v.equals("0.6"))) 
    163                              throw new SAXException(tr("Unknown version: {0}", v)); 
    164                          // save generator attribute for later use when creating DataSource objects 
    165                          generator = atts.getValue("generator"); 
    166                          ds.version = v; 
    167  
    168                     } else if (qName.equals("bounds")) { 
    169                          // new style bounds. 
    170                          String minlon = atts.getValue("minlon"); 
    171                          String minlat = atts.getValue("minlat"); 
    172                          String maxlon = atts.getValue("maxlon"); 
    173                          String maxlat = atts.getValue("maxlat"); 
    174                          String origin = atts.getValue("origin"); 
    175                          if (minlon != null && maxlon != null && minlat != null && maxlat != null) { 
    176                               if (origin == null) origin = generator; 
    177                               Bounds bounds = new Bounds( 
    178                                   new LatLon(Double.parseDouble(minlat), Double.parseDouble(minlon)), 
    179                                   new LatLon(Double.parseDouble(maxlat), Double.parseDouble(maxlon))); 
    180                               DataSource src = new DataSource(bounds, origin); 
    181                               ds.dataSources.add(src); 
    182                          } 
     53    /** 
     54     * This is used as (readonly) source for finding missing references when not transferred in the 
     55     * file. 
     56     */ 
     57    private DataSet references; 
     58 
     59    /** 
     60     * The dataset to add parsed objects to. 
     61     */ 
     62    private DataSet ds = new DataSet(); 
     63    public DataSet getDs() { return ds; } 
     64 
     65    /** 
     66     * Record warnings.  If there were any data inconsistencies, append 
     67     * a newline-terminated string. 
     68     */ 
     69    private String parseNotes = new String(); 
     70    private int parseNotesCount = 0; 
     71    public String getParseNotes() { 
     72        return parseNotes; 
     73    } 
     74 
     75    /** the list of ids of skipped {@see Way}s, i.e. ways which referred to nodes 
     76     * not included in the parsed data 
     77     */ 
     78    private Set<Long> skippedWayIds = new HashSet<Long>(); 
     79 
     80    /** 
     81     * The visitor to use to add the data to the set. 
     82     */ 
     83    private AddVisitor adder = new AddVisitor(ds); 
     84 
     85    /** 
     86     * All read nodes after phase 1. 
     87     */ 
     88    private Map<Long, Node> nodes = new HashMap<Long, Node>(); 
     89 
     90 
     91    private static class OsmPrimitiveData { 
     92        public long id = 0; 
     93        public Map<String,String> keys = new HashMap<String, String>(); 
     94        public boolean modified = false; 
     95        public boolean selected = false; 
     96        public boolean deleted = false; 
     97        public Date timestamp = new Date(); 
     98        public User user = null; 
     99        public boolean visible = true; 
     100        public int version = -1; 
     101        public LatLon latlon = new LatLon(0,0); 
     102 
     103        public void copyTo(OsmPrimitive osm) { 
     104            osm.id = id; 
     105            osm.keys = keys; 
     106            osm.modified = modified; 
     107            osm.selected = selected; 
     108            osm.deleted = deleted; 
     109            osm.setTimestamp(timestamp); 
     110            osm.user = user; 
     111            osm.visible = visible; 
     112            osm.version = version; 
     113            osm.mappaintStyle = null; 
     114        } 
     115 
     116        public Node createNode() { 
     117            Node node = new Node(latlon); 
     118            copyTo(node); 
     119            return node; 
     120        } 
     121 
     122        public Way createWay() { 
     123            Way way = new Way(id); 
     124            copyTo(way); 
     125            return way; 
     126        } 
     127 
     128        public Relation createRelation() { 
     129            Relation rel = new Relation(id); 
     130            copyTo(rel); 
     131            return rel; 
     132        } 
     133    } 
     134 
     135    /** 
     136     * Used as a temporary storage for relation members, before they 
     137     * are resolved into pointers to real objects. 
     138     */ 
     139    private static class RelationMemberData { 
     140        public String type; 
     141        public long id; 
     142        public RelationMember relationMember; 
     143    } 
     144 
     145    /** 
     146     * Data structure for the remaining way objects 
     147     */ 
     148    private Map<OsmPrimitiveData, Collection<Long>> ways = new HashMap<OsmPrimitiveData, Collection<Long>>(); 
     149 
     150    /** 
     151     * Data structure for relation objects 
     152     */ 
     153    private Map<OsmPrimitiveData, Collection<RelationMemberData>> relations = new HashMap<OsmPrimitiveData, Collection<RelationMemberData>>(); 
     154 
     155    private class Parser extends DefaultHandler { 
     156        /** 
     157         * The current osm primitive to be read. 
     158         */ 
     159        private OsmPrimitiveData current; 
     160        private String generator; 
     161 
     162        @Override public void startElement(String namespaceURI, String localName, String qName, Attributes atts) throws SAXException { 
     163            try { 
     164                if (qName.equals("osm")) { 
     165                    if (atts == null) 
     166                        throw new SAXException(tr("Unknown version")); 
     167                    String v = atts.getValue("version"); 
     168                    if (v == null) 
     169                        throw new SAXException(tr("Version number missing from OSM data")); 
     170                    if (!(v.equals("0.5") || v.equals("0.6"))) 
     171                        throw new SAXException(tr("Unknown version: {0}", v)); 
     172                    // save generator attribute for later use when creating DataSource objects 
     173                    generator = atts.getValue("generator"); 
     174                    ds.version = v; 
     175 
     176                } else if (qName.equals("bounds")) { 
     177                    // new style bounds. 
     178                    String minlon = atts.getValue("minlon"); 
     179                    String minlat = atts.getValue("minlat"); 
     180                    String maxlon = atts.getValue("maxlon"); 
     181                    String maxlat = atts.getValue("maxlat"); 
     182                    String origin = atts.getValue("origin"); 
     183                    if (minlon != null && maxlon != null && minlat != null && maxlat != null) { 
     184                        if (origin == null) { 
     185                            origin = generator; 
     186                        } 
     187                        Bounds bounds = new Bounds( 
     188                                new LatLon(Double.parseDouble(minlat), Double.parseDouble(minlon)), 
     189                                new LatLon(Double.parseDouble(maxlat), Double.parseDouble(maxlon))); 
     190                        DataSource src = new DataSource(bounds, origin); 
     191                        ds.dataSources.add(src); 
     192                    } 
    183193 
    184194                    // ---- PARSING NODES AND WAYS ---- 
    185195 
    186                     } else if (qName.equals("node")) { 
    187 //                         nodesN++; 
    188                          current = new Node(new LatLon(getDouble(atts, "lat"), getDouble(atts, "lon"))); 
    189                          readCommon(atts, current); 
    190                          nodes.put(current.id, (Node)current); 
    191                     } else if (qName.equals("way")) { 
    192 //                         waysN++; 
    193                          current = new OsmPrimitiveData(); 
    194                          readCommon(atts, current); 
    195                          ways.put((OsmPrimitiveData)current, new ArrayList<Long>()); 
    196                     } else if (qName.equals("nd")) { 
    197                          Collection<Long> list = ways.get(current); 
    198                          if (list == null) 
    199                               throw new SAXException(tr("Found <nd> element in non-way.")); 
    200                          long id = getLong(atts, "ref"); 
    201                          if (id == 0) 
    202                               throw new SAXException(tr("<nd> has zero ref")); 
    203                          list.add(id); 
     196                } else if (qName.equals("node")) { 
     197                    current = new OsmPrimitiveData(); 
     198                    current.latlon = new LatLon(getDouble(atts, "lat"), getDouble(atts, "lon")); 
     199                    readCommon(atts, current); 
     200                } else if (qName.equals("way")) { 
     201                    current = new OsmPrimitiveData(); 
     202                    readCommon(atts, current); 
     203                    ways.put(current, new ArrayList<Long>()); 
     204                } else if (qName.equals("nd")) { 
     205                    Collection<Long> list = ways.get(current); 
     206                    if (list == null) 
     207                        throw new SAXException(tr("Found <nd> element in non-way.")); 
     208                    long id = getLong(atts, "ref"); 
     209                    if (id == 0) 
     210                        throw new SAXException(tr("<nd> has zero ref")); 
     211                    list.add(id); 
    204212 
    205213                    // ---- PARSING RELATIONS ---- 
    206214 
    207                     } else if (qName.equals("relation")) { 
    208                          current = new OsmPrimitiveData(); 
    209                          readCommon(atts, current); 
    210                          relations.put((OsmPrimitiveData)current, new LinkedList<RelationMemberData>()); 
    211                     } else if (qName.equals("member")) { 
    212                          Collection<RelationMemberData> list = relations.get(current); 
    213                          if (list == null) 
    214                               throw new SAXException(tr("Found <member> element in non-relation.")); 
    215                          RelationMemberData emd = new RelationMemberData(); 
    216                          emd.relationMember = new RelationMember(); 
    217                          String value = atts.getValue("ref"); 
    218                          if (value == null) { 
    219                              throw new SAXException(tr("Missing attribute \"ref\" on member in relation {0}",current.id)); 
    220                          } 
    221                          try { 
    222                              emd.id = Long.parseLong(value); 
    223                          } catch(NumberFormatException e) { 
    224                              throw new SAXException(tr("Illegal value for attribute \"ref\" on member in relation {0}, got {1}", Long.toString(current.id),value)); 
    225                          } 
    226                          value = atts.getValue("type"); 
    227                          if (value == null) { 
    228                              throw new SAXException(tr("Missing attribute \"type\" on member {0} in relation {1}", Long.toString(emd.id), Long.toString(current.id))); 
    229                          } 
    230                          if (! (value.equals("way") || value.equals("node") || value.equals("relation"))) { 
    231                              throw new SAXException(tr("Unexpected \"type\" on member {0} in relation {1}, got {2}.", Long.toString(emd.id), Long.toString(current.id), value)); 
    232                          } 
    233                          emd.type= value; 
    234                          value = atts.getValue("role"); 
    235                          emd.relationMember.role = value; 
    236  
    237                          if (emd.id == 0) 
    238                               throw new SAXException(tr("Incomplete <member> specification with ref=0")); 
    239  
    240                          list.add(emd); 
     215                } else if (qName.equals("relation")) { 
     216                    current = new OsmPrimitiveData(); 
     217                    readCommon(atts, current); 
     218                    relations.put(current, new LinkedList<RelationMemberData>()); 
     219                } else if (qName.equals("member")) { 
     220                    Collection<RelationMemberData> list = relations.get(current); 
     221                    if (list == null) 
     222                        throw new SAXException(tr("Found <member> element in non-relation.")); 
     223                    RelationMemberData emd = new RelationMemberData(); 
     224                    emd.relationMember = new RelationMember(); 
     225                    String value = atts.getValue("ref"); 
     226                    if (value == null) 
     227                        throw new SAXException(tr("Missing attribute \"ref\" on member in relation {0}",current.id)); 
     228                    try { 
     229                        emd.id = Long.parseLong(value); 
     230                    } catch(NumberFormatException e) { 
     231                        throw new SAXException(tr("Illegal value for attribute \"ref\" on member in relation {0}, got {1}", Long.toString(current.id),value)); 
     232                    } 
     233                    value = atts.getValue("type"); 
     234                    if (value == null) 
     235                        throw new SAXException(tr("Missing attribute \"type\" on member {0} in relation {1}", Long.toString(emd.id), Long.toString(current.id))); 
     236                    if (! (value.equals("way") || value.equals("node") || value.equals("relation"))) 
     237                        throw new SAXException(tr("Unexpected \"type\" on member {0} in relation {1}, got {2}.", Long.toString(emd.id), Long.toString(current.id), value)); 
     238                    emd.type= value; 
     239                    value = atts.getValue("role"); 
     240                    emd.relationMember.role = value; 
     241 
     242                    if (emd.id == 0) 
     243                        throw new SAXException(tr("Incomplete <member> specification with ref=0")); 
     244 
     245                    list.add(emd); 
    241246 
    242247                    // ---- PARSING TAGS (applicable to all objects) ---- 
    243248 
    244                     } else if (qName.equals("tag")) { 
    245 //                         tagsN++; 
    246                         String key = atts.getValue("k"); 
    247                         String internedKey = keys.get(key); 
    248                         if (internedKey == null) { 
    249                             internedKey = key; 
    250                             keys.put(key, key); 
    251                         } 
    252                          current.put(internedKey, atts.getValue("v")); 
    253                     } 
    254                } catch (NumberFormatException x) { 
    255                     x.printStackTrace(); // SAXException does not chain correctly 
    256                     throw new SAXException(x.getMessage(), x); 
    257                } catch (NullPointerException x) { 
    258                     x.printStackTrace(); // SAXException does not chain correctly 
    259                     throw new SAXException(tr("NullPointerException, possibly some missing tags."), x); 
    260                } 
    261           } 
    262  
    263           private double getDouble(Attributes atts, String value) { 
    264                return Double.parseDouble(atts.getValue(value)); 
    265           } 
    266      } 
    267  
    268      /** 
    269       * Read out the common attributes from atts and put them into this.current. 
    270       */ 
    271      void readCommon(Attributes atts, OsmPrimitive current) throws SAXException { 
    272           current.id = getLong(atts, "id"); 
    273           if (current.id == 0) 
    274                throw new SAXException(tr("Illegal object with id=0")); 
    275  
    276           String time = atts.getValue("timestamp"); 
    277           if (time != null && time.length() != 0) { 
    278                current.setTimestamp(DateUtils.fromString(time)); 
    279           } 
    280  
    281           // user attribute added in 0.4 API 
    282           String user = atts.getValue("user"); 
    283           if (user != null) { 
    284                // do not store literally; get object reference for string 
    285                current.user = User.get(user); 
    286           } 
    287  
    288           // uid attribute added in 0.6 API 
    289           String uid = atts.getValue("uid"); 
    290           if (uid != null) { 
    291               if (current.user != null) { 
    292                   current.user.uid = uid; 
    293               } 
    294          } 
    295  
    296           // visible attribute added in 0.4 API 
    297           String visible = atts.getValue("visible"); 
    298           if (visible != null) { 
    299                current.visible = Boolean.parseBoolean(visible); 
    300           } 
    301  
    302           String version = atts.getValue("version"); 
    303           current.version = 0; 
    304           if (version != null) { 
    305               try { 
    306                   current.version = Integer.parseInt(version); 
    307               } catch(NumberFormatException e) { 
    308                   throw new SAXException(tr("Illegal value for attribute \"version\" on OSM primitive with id {0}, got {1}", Long.toString(current.id), version)); 
    309               } 
    310           } else { 
    311               // version expected for OSM primitives with an id assigned by the server (id > 0), since API 0.6 
    312               // 
    313               if (current.id > 0 && ds.version != null && ds.version.equals("0.6")) { 
    314                   throw new SAXException(tr("Missing attribute \"version\" on OSM primitive with id {0}", Long.toString(current.id))); 
    315               } 
    316           } 
    317  
    318           String action = atts.getValue("action"); 
    319           if (action == null) 
    320                return; 
    321           if (action.equals("delete")) 
    322                current.delete(true); 
    323           else if (action.startsWith("modify")) 
    324                current.modified = true; 
    325      } 
    326      private long getLong(Attributes atts, String value) throws SAXException { 
    327           String s = atts.getValue(value); 
    328           if (s == null) 
    329                throw new SAXException(tr("Missing required attribute \"{0}\".",value)); 
    330           return Long.parseLong(s); 
    331      } 
    332  
    333      private Node findNode(long id) { 
    334          Node n = nodes.get(id); 
    335          if (n != null) 
    336               return n; 
    337          for (Node node : references.nodes) 
    338               if (node.id == id) 
    339                    return node; 
    340          // TODO: This has to be changed to support multiple layers. 
    341          for (Node node : Main.ds.nodes) 
    342               if (node.id == id) 
    343                    return new Node(node); 
    344          return null; 
    345     } 
    346  
    347      private void createWays() { 
    348           for (Entry<OsmPrimitiveData, Collection<Long>> e : ways.entrySet()) { 
    349                Way w = new Way(); 
    350                boolean failed = false; 
    351                for (long id : e.getValue()) { 
    352                     Node n = findNode(id); 
    353                     if (n == null) { 
    354                          /* don't report ALL of them, just a few */ 
    355                          if (parseNotesCount++ < 6) { 
    356                              parseNotes += tr("Skipping a way because it includes a node that doesn''t exist: {0}\n", id); 
    357                          } else if (parseNotesCount == 6) { 
    358                              parseNotes += "...\n"; 
    359                          } 
    360                          failed = true; 
    361                          break; 
    362                     } 
    363                     w.nodes.add(n); 
    364                } 
    365                if (failed) continue; 
    366                e.getKey().copyTo(w); 
    367                adder.visit(w); 
    368           } 
    369  
    370      } 
    371  
    372      /** 
    373       * Return the Way object with the given id, or null if it doesn't 
    374       * exist yet. This method only looks at ways stored in the data set. 
    375       * 
    376       * @param id 
    377       * @return way object or null 
    378       */ 
    379      private Way findWay(long id) { 
    380           for (Way wy : Main.ds.ways) 
    381                if (wy.id == id) 
    382                     return wy; 
    383           return null; 
    384      } 
    385  
    386      /** 
    387       * Return the Relation object with the given id, or null if it doesn't 
    388       * exist yet. This method only looks at relations stored in the data set. 
    389       * 
    390       * @param id 
    391       * @return relation object or null 
    392       */ 
    393      private Relation findRelation(long id) { 
    394           for (Relation e : ds.relations) 
    395                if (e.id == id) 
    396                     return e; 
    397           for (Relation e : Main.ds.relations) 
    398                if (e.id == id) 
    399                     return e; 
    400           return null; 
    401      } 
    402  
    403      /** 
    404       * Create relations. This is slightly different than n/s/w because 
    405       * unlike other objects, relations may reference other relations; it 
    406       * is not guaranteed that a referenced relation will have been created 
    407       * before it is referenced. So we have to create all relations first, 
    408       * and populate them later. 
    409       */ 
    410      private void createRelations() { 
    411  
    412           // pass 1 - create all relations 
    413           for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) { 
    414                Relation en = new Relation(); 
    415                e.getKey().copyTo(en); 
    416                adder.visit(en); 
    417           } 
    418  
    419           // Cache the ways here for much better search performance 
    420           HashMap<Long, Way> hm = new HashMap<Long, Way>(10000); 
    421           for (Way wy : ds.ways) 
     249                } else if (qName.equals("tag")) { 
     250                    String key = atts.getValue("k"); 
     251                    String value = atts.getValue("v"); 
     252                    current.keys.put(key,value); 
     253                } 
     254            } catch (NumberFormatException x) { 
     255                x.printStackTrace(); // SAXException does not chain correctly 
     256                throw new SAXException(x.getMessage(), x); 
     257            } catch (NullPointerException x) { 
     258                x.printStackTrace(); // SAXException does not chain correctly 
     259                throw new SAXException(tr("NullPointerException, possibly some missing tags."), x); 
     260            } 
     261        } 
     262 
     263        @Override 
     264        public void endElement(String uri, String localName, String qName) throws SAXException { 
     265            if (qName.equals("node")) { 
     266                nodes.put(current.id, current.createNode()); 
     267            } 
     268        } 
     269 
     270        private double getDouble(Attributes atts, String value) { 
     271            return Double.parseDouble(atts.getValue(value)); 
     272        } 
     273    } 
     274 
     275    /** 
     276     * Read out the common attributes from atts and put them into this.current. 
     277     */ 
     278    void readCommon(Attributes atts, OsmPrimitiveData current) throws SAXException { 
     279        current.id = getLong(atts, "id"); 
     280        if (current.id == 0) 
     281            throw new SAXException(tr("Illegal object with id=0")); 
     282 
     283        String time = atts.getValue("timestamp"); 
     284        if (time != null && time.length() != 0) { 
     285            current.timestamp =  DateUtils.fromString(time); 
     286        } 
     287 
     288        // user attribute added in 0.4 API 
     289        String user = atts.getValue("user"); 
     290        if (user != null) { 
     291            // do not store literally; get object reference for string 
     292            current.user = User.get(user); 
     293        } 
     294 
     295        // uid attribute added in 0.6 API 
     296        String uid = atts.getValue("uid"); 
     297        if (uid != null) { 
     298            if (current.user != null) { 
     299                current.user.uid = uid; 
     300            } 
     301        } 
     302 
     303        // visible attribute added in 0.4 API 
     304        String visible = atts.getValue("visible"); 
     305        if (visible != null) { 
     306            current.visible = Boolean.parseBoolean(visible); 
     307        } 
     308 
     309        String version = atts.getValue("version"); 
     310        current.version = 0; 
     311        if (version != null) { 
     312            try { 
     313                current.version = Integer.parseInt(version); 
     314            } catch(NumberFormatException e) { 
     315                throw new SAXException(tr("Illegal value for attribute \"version\" on OSM primitive with id {0}, got {1}", Long.toString(current.id), version)); 
     316            } 
     317        } else { 
     318            // version expected for OSM primitives with an id assigned by the server (id > 0), since API 0.6 
     319            // 
     320            if (current.id > 0 && ds.version != null && ds.version.equals("0.6")) 
     321                throw new SAXException(tr("Missing attribute \"version\" on OSM primitive with id {0}", Long.toString(current.id))); 
     322        } 
     323 
     324        String action = atts.getValue("action"); 
     325        if (action == null) 
     326            return; 
     327        if (action.equals("delete")) { 
     328            current.deleted = true; 
     329        } else if (action.startsWith("modify")) { 
     330            current.modified = true; 
     331        } 
     332    } 
     333    private long getLong(Attributes atts, String value) throws SAXException { 
     334        String s = atts.getValue(value); 
     335        if (s == null) 
     336            throw new SAXException(tr("Missing required attribute \"{0}\".",value)); 
     337        return Long.parseLong(s); 
     338    } 
     339 
     340    private Node findNode(long id) { 
     341        Node n = nodes.get(id); 
     342        if (n != null) 
     343            return n; 
     344        for (Node node : references.nodes) 
     345            if (node.id == id) 
     346                return node; 
     347        // TODO: This has to be changed to support multiple layers. 
     348        for (Node node : Main.ds.nodes) 
     349            if (node.id == id) 
     350                return new Node(node); 
     351        return null; 
     352    } 
     353 
     354    protected void createWays() { 
     355        for (Entry<OsmPrimitiveData, Collection<Long>> e : ways.entrySet()) { 
     356            Way w = new Way(); 
     357            boolean failed = false; 
     358            for (long id : e.getValue()) { 
     359                Node n = findNode(id); 
     360                if (n == null) { 
     361                    /* don't report ALL of them, just a few */ 
     362                    if (parseNotesCount++ < 6) { 
     363                        parseNotes += tr("Skipping a way because it includes a node that doesn''t exist: {0}\n", id); 
     364                    } else if (parseNotesCount == 6) { 
     365                        parseNotes += "...\n"; 
     366                    } 
     367                    failed = true; 
     368                    break; 
     369                } 
     370                w.nodes.add(n); 
     371            } 
     372            if (failed) { 
     373                skippedWayIds.add(e.getKey().id); 
     374                continue; 
     375            } 
     376            e.getKey().copyTo(w); 
     377            adder.visit(w); 
     378        } 
     379 
     380    } 
     381 
     382    /** 
     383     * Return the Way object with the given id, or null if it doesn't 
     384     * exist yet. This method only looks at ways stored in the data set. 
     385     * 
     386     * @param id 
     387     * @return way object or null 
     388     */ 
     389    private Way findWay(long id) { 
     390        for (Way wy : Main.ds.ways) 
     391            if (wy.id == id) 
     392                return wy; 
     393        return null; 
     394    } 
     395 
     396    /** 
     397     * Return the Relation object with the given id, or null if it doesn't 
     398     * exist yet. This method only looks at relations stored in the data set. 
     399     * 
     400     * @param id 
     401     * @return relation object or null 
     402     */ 
     403    private Relation findRelation(long id) { 
     404        for (Relation e : ds.relations) 
     405            if (e.id == id) 
     406                return e; 
     407        for (Relation e : Main.ds.relations) 
     408            if (e.id == id) 
     409                return e; 
     410        return null; 
     411    } 
     412 
     413    /** 
     414     * Create relations. This is slightly different than n/s/w because 
     415     * unlike other objects, relations may reference other relations; it 
     416     * is not guaranteed that a referenced relation will have been created 
     417     * before it is referenced. So we have to create all relations first, 
     418     * and populate them later. 
     419     */ 
     420    private void createRelations() { 
     421 
     422        // pass 1 - create all relations 
     423        for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) { 
     424            Relation en = new Relation(); 
     425            e.getKey().copyTo(en); 
     426            adder.visit(en); 
     427        } 
     428 
     429        // Cache the ways here for much better search performance 
     430        HashMap<Long, Way> hm = new HashMap<Long, Way>(10000); 
     431        for (Way wy : ds.ways) { 
    422432            hm.put(wy.id, wy); 
    423  
    424           // pass 2 - sort out members 
    425           for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) { 
    426                Relation en = findRelation(e.getKey().id); 
    427                if (en == null) throw new Error("Failed to create relation " + e.getKey().id); 
    428  
    429                for (RelationMemberData emd : e.getValue()) { 
    430                     RelationMember em = emd.relationMember; 
    431                     if (emd.type.equals("node")) { 
    432                          em.member = findNode(emd.id); 
    433                          if (em.member == null) { 
    434                               em.member = new Node(emd.id); 
    435                               adder.visit((Node)em.member); 
    436                          } 
    437                     } else if (emd.type.equals("way")) { 
    438                          em.member = hm.get(emd.id); 
    439                          if (em.member == null) 
    440                             em.member = findWay(emd.id); 
    441                          if (em.member == null) { 
    442                               em.member = new Way(emd.id); 
    443                               adder.visit((Way)em.member); 
    444                          } 
    445                     } else if (emd.type.equals("relation")) { 
    446                          em.member = findRelation(emd.id); 
    447                          if (em.member == null) { 
    448                               em.member = new Relation(emd.id); 
    449                               adder.visit((Relation)em.member); 
    450                          } 
    451                     } else { 
    452                          // this is an error. 
    453                     } 
    454                     en.members.add(em); 
    455                } 
    456           } 
    457           hm = null; 
    458      } 
    459  
    460      /** 
    461       * Parse the given input source and return the dataset. 
    462       * @param ref The dataset that is search in for references first. If 
    463       *      the Reference is not found here, Main.ds is searched and a copy of the 
    464       *  element found there is returned. 
    465       */ 
    466      public static DataSet parseDataSet(InputStream source, DataSet ref, PleaseWaitDialog pleaseWaitDlg) throws SAXException, IOException { 
    467           return parseDataSetOsm(source, ref, pleaseWaitDlg).ds; 
    468      } 
    469  
    470      public static OsmReader parseDataSetOsm(InputStream source, DataSet ref, PleaseWaitDialog pleaseWaitDlg) throws SAXException, IOException { 
    471           OsmReader osm = new OsmReader(); 
    472           osm.references = ref == null ? new DataSet() : ref; 
    473  
    474           currSource = source; 
    475  
    476           // phase 1: Parse nodes and read in raw ways 
    477           InputSource inputSource = new InputSource(new InputStreamReader(source, "UTF-8")); 
    478           try { 
    479              SAXParserFactory.newInstance().newSAXParser().parse(inputSource, osm.new Parser()); 
    480           } catch (ParserConfigurationException e1) { 
    481              e1.printStackTrace(); // broken SAXException chaining 
    482              throw new SAXException(e1); 
    483           } 
    484  
    485           Main.pleaseWaitDlg.currentAction.setText(tr("Prepare OSM data...")); 
    486           Main.pleaseWaitDlg.setIndeterminate(true); 
    487  
    488 //          System.out.println("Parser finished: Tags " + tagsN + " Nodes " + nodesN + " Ways " + waysN + 
    489 //            " Relations " + relationsN + " Members " + membersN); 
    490  
    491           for (Node n : osm.nodes.values()) 
    492                osm.adder.visit(n); 
    493  
    494           try { 
    495                osm.createWays(); 
    496                osm.createRelations(); 
    497           } catch (NumberFormatException e) { 
    498                e.printStackTrace(); 
    499                throw new SAXException(tr("Ill-formed node id")); 
    500           } 
    501  
    502           // clear all negative ids (new to this file) 
    503           for (OsmPrimitive o : osm.ds.allPrimitives()) 
    504                if (o.id < 0) 
    505                     o.id = 0; 
    506  
    507 //          System.out.println("Data loaded!"); 
    508           Main.pleaseWaitDlg.setIndeterminate(false); 
    509           Main.pleaseWaitDlg.progress.setValue(0); 
    510  
    511           return osm; 
    512      } 
     433        } 
     434 
     435        // pass 2 - sort out members 
     436        for (Entry<OsmPrimitiveData, Collection<RelationMemberData>> e : relations.entrySet()) { 
     437            Relation en = findRelation(e.getKey().id); 
     438            if (en == null) throw new Error("Failed to create relation " + e.getKey().id); 
     439 
     440            for (RelationMemberData emd : e.getValue()) { 
     441                RelationMember em = emd.relationMember; 
     442                if (emd.type.equals("node")) { 
     443                    em.member = findNode(emd.id); 
     444                    if (em.member == null) { 
     445                        em.member = new Node(emd.id); 
     446                        adder.visit((Node)em.member); 
     447                    } 
     448                } else if (emd.type.equals("way")) { 
     449                    em.member = hm.get(emd.id); 
     450                    if (em.member == null) { 
     451                        em.member = findWay(emd.id); 
     452                    } 
     453                    if (em.member == null) { 
     454                        em.member = new Way(emd.id); 
     455                        adder.visit((Way)em.member); 
     456                    } 
     457                } else if (emd.type.equals("relation")) { 
     458                    em.member = findRelation(emd.id); 
     459                    if (em.member == null) { 
     460                        em.member = new Relation(emd.id); 
     461                        adder.visit((Relation)em.member); 
     462                    } 
     463                } else { 
     464                    // this is an error. 
     465                } 
     466                en.members.add(em); 
     467            } 
     468        } 
     469        hm = null; 
     470    } 
     471 
     472    /** 
     473     * Parse the given input source and return the dataset. 
     474     * @param ref The dataset that is search in for references first. If 
     475     *      the Reference is not found here, Main.ds is searched and a copy of the 
     476     *  element found there is returned. 
     477     */ 
     478    public static DataSet parseDataSet(InputStream source, DataSet ref, PleaseWaitDialog pleaseWaitDlg) throws SAXException, IOException { 
     479        return parseDataSetOsm(source, ref, pleaseWaitDlg).ds; 
     480    } 
     481 
     482    public static OsmReader parseDataSetOsm(InputStream source, DataSet ref, PleaseWaitDialog pleaseWaitDlg) throws SAXException, IOException { 
     483        OsmReader osm = new OsmReader(); 
     484        osm.references = ref == null ? new DataSet() : ref; 
     485 
     486        // phase 1: Parse nodes and read in raw ways 
     487        InputSource inputSource = new InputSource(new InputStreamReader(source, "UTF-8")); 
     488        try { 
     489            SAXParserFactory.newInstance().newSAXParser().parse(inputSource, osm.new Parser()); 
     490        } catch (ParserConfigurationException e1) { 
     491            e1.printStackTrace(); // broken SAXException chaining 
     492            throw new SAXException(e1); 
     493        } 
     494 
     495        Main.pleaseWaitDlg.currentAction.setText(tr("Prepare OSM data...")); 
     496        Main.pleaseWaitDlg.setIndeterminate(true); 
     497 
     498        for (Node n : osm.nodes.values()) { 
     499            osm.adder.visit(n); 
     500        } 
     501 
     502        try { 
     503            osm.createWays(); 
     504            osm.createRelations(); 
     505        } catch (NumberFormatException e) { 
     506            e.printStackTrace(); 
     507            throw new SAXException(tr("Ill-formed node id")); 
     508        } 
     509 
     510        // clear all negative ids (new to this file) 
     511        for (OsmPrimitive o : osm.ds.allPrimitives()) 
     512            if (o.id < 0) { 
     513                o.id = 0; 
     514            } 
     515 
     516        Main.pleaseWaitDlg.setIndeterminate(false); 
     517        Main.pleaseWaitDlg.progress.setValue(0); 
     518 
     519        return osm; 
     520    } 
     521 
     522    /** 
     523     * replies a set of ids of skipped {@see Way}s, i.e. ways which were included in the downloaded 
     524     * data but which referred to nodes <strong>not</strong>  available in the downloaded data 
     525     *  
     526     * @return the set of ids 
     527     */ 
     528    public Set<Long> getSkippedWayIds() { 
     529        return skippedWayIds; 
     530    } 
    513531} 
Note: See TracChangeset for help on using the changeset viewer.