Changeset 1690 in josm for trunk/src/org/openstreetmap/josm/gui/conflict/properties/PropertiesMerger.java

Timestamp:

23.06.2009 22:03:37 (3 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

File:

• trunk/src/org/openstreetmap/josm/gui/conflict/properties/PropertiesMerger.java (modified) (11 diffs)

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

@@ -18 +18 @@
 import javax.swing.JButton;
 import javax.swing.JLabel;
+import javax.swing.JOptionPane;
 import javax.swing.JPanel;
-
+import javax.swing.SwingUtilities;
+
+import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.data.coor.LatLon;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
 import org.openstreetmap.josm.gui.conflict.MergeDecisionType;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -48 +52 @@
     private JLabel lblTheirDeletedState;
 
+    private JLabel lblMyVisibleState;
+    private JLabel lblMergedVisibleState;
+    private JLabel lblTheirVisibleState;
+
     private final PropertiesMergeModel model;
 
@@ -59 +67 @@
     }
 
-    protected void build() {
-        setLayout(new GridBagLayout());
+    protected void buildHeaderRow() {
         GridBagConstraints gc = new GridBagConstraints();
 
-        // ------------------
         gc.gridx = 1;
         gc.gridy = 0;
@@ -88 +94 @@
         lblTheirVersion.setToolTipText(tr("Properties in their dataset, i.e. the server dataset"));
         add(lblTheirVersion, gc);
-
-        // --------------------------------
+    }
+
+    protected void buildCoordinateConflictRows() {
+        GridBagConstraints gc = new GridBagConstraints();
+
         gc.gridx = 0;
         gc.gridy = 1;
@@ -161 +170 @@
         JButton btnUndecideCoordinates = new JButton(actUndecideCoordinates);
         add(btnUndecideCoordinates, gc);
-        // ---------------------------------------------------
+    }
+
+    protected void buildDeletedStateConflictRows() {
+        GridBagConstraints gc = new GridBagConstraints();
 
         gc.gridx = 0;
@@ -191 +203 @@
         model.addObserver(actKeepMyDeletedState);
         JButton btnKeepMyDeletedState = new JButton(actKeepMyDeletedState);
-        btnKeepMyCoordinates.setName("button.keepmydeletedstate");
+        btnKeepMyDeletedState.setName("button.keepmydeletedstate");
         add(btnKeepMyDeletedState, gc);
 
@@ -212 +224 @@
         model.addObserver(actKeepTheirDeletedState);
         JButton btnKeepTheirDeletedState = new JButton(actKeepTheirDeletedState);
-        btnKeepMyCoordinates.setName("button.keeptheirdeletedstate");
+        btnKeepTheirDeletedState.setName("button.keeptheirdeletedstate");
         add(btnKeepTheirDeletedState, gc);
 
@@ -233 +245 @@
         model.addObserver(actUndecideDeletedState);
         JButton btnUndecideDeletedState = new JButton(actUndecideDeletedState);
-        btnKeepMyCoordinates.setName("button.undecidedeletedstate");
+        btnUndecideDeletedState.setName("button.undecidedeletedstate");
         add(btnUndecideDeletedState, gc);
-
+    }
+
+    protected void buildVisibleStateRows() {
+        GridBagConstraints gc = new GridBagConstraints();
+
+        gc.gridx = 0;
+        gc.gridy = 5;
+        gc.gridwidth = 1;
+        gc.gridheight = 1;
+        gc.fill = GridBagConstraints.BOTH;
+        gc.anchor = GridBagConstraints.LINE_START;
+        gc.weightx = 0.0;
+        gc.weighty = 0.0;
+        gc.insets = new Insets(0,5,0,5);
+        add(new JLabel(tr("Visible State:")), gc);
+
+        gc.gridx = 1;
+        gc.gridy = 5;
+        gc.fill = GridBagConstraints.BOTH;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.33;
+        gc.weighty = 0.0;
+        add(lblMyVisibleState = buildValueLabel("label.myvisiblestate"), gc);
+
+        gc.gridx = 2;
+        gc.gridy = 5;
+        gc.fill = GridBagConstraints.NONE;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.0;
+        gc.weighty = 0.0;
+        KeepMyVisibleStateAction actKeepMyVisibleState = new KeepMyVisibleStateAction();
+        model.addObserver(actKeepMyVisibleState);
+        JButton btnKeepMyVisibleState = new JButton(actKeepMyVisibleState);
+        btnKeepMyVisibleState.setName("button.keepmyvisiblestate");
+        add(btnKeepMyVisibleState, gc);
+
+        gc.gridx = 3;
+        gc.gridy = 5;
+        gc.fill = GridBagConstraints.BOTH;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.33;
+        gc.weighty = 0.0;
+        add(lblMergedVisibleState = buildValueLabel("label.mergedvisiblestate"), gc);
+
+        gc.gridx = 4;
+        gc.gridy = 5;
+        gc.fill = GridBagConstraints.NONE;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.0;
+        gc.weighty = 0.0;
+        KeepTheirVisibleStateAction actKeepTheirVisibleState = new KeepTheirVisibleStateAction();
+        model.addObserver(actKeepTheirVisibleState);
+        JButton btnKeepTheirVisibleState = new JButton(actKeepTheirVisibleState);
+        btnKeepTheirVisibleState.setName("button.keeptheirvisiblestate");
+        add(btnKeepTheirVisibleState, gc);
+
+        gc.gridx = 5;
+        gc.gridy = 5;
+        gc.fill = GridBagConstraints.BOTH;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.33;
+        gc.weighty = 0.0;
+        add(lblTheirVisibleState = buildValueLabel("label.theirvisiblestate"), gc);
+
+        // ---------------------------------------------------
+        gc.gridx = 3;
+        gc.gridy = 6;
+        gc.fill = GridBagConstraints.NONE;
+        gc.anchor = GridBagConstraints.CENTER;
+        gc.weightx = 0.0;
+        gc.weighty = 0.0;
+        UndecideVisibleStateConflictAction actUndecideVisibleState = new UndecideVisibleStateConflictAction();
+        model.addObserver(actUndecideVisibleState);
+        JButton btnUndecideVisibleState = new JButton(actUndecideVisibleState);
+        btnUndecideVisibleState.setName("button.undecidevisiblestate");
+        add(btnUndecideVisibleState, gc);
+    }
+
+    protected void build() {
+        setLayout(new GridBagLayout());
+        buildHeaderRow();
+        buildCoordinateConflictRows();
+        buildDeletedStateConflictRows();
+        buildVisibleStateRows();
     }
 
@@ -265 +360 @@
     }
 
-    protected void updateCoordiates() {
+    public String visibleStateToString(Boolean visible) {
+        if (visible == null)
+            return tr("(none)");
+        if (visible)
+            return tr("visible (on the server)");
+        else
+            return tr("not visible (on the server)");
+    }
+
+    public String visibleStateToStringMerged(Boolean visible) {
+        if (visible == null)
+            return tr("(none)");
+        if (visible)
+            return tr("Keep a clone of the local version");
+        else
+            return tr("Physically delete from local dataset");
+    }
+
+    protected void updateCoordinates() {
         lblMyCoordinates.setText(coordToString(model.getMyCoords()));
         lblMergedCoordinates.setText(coordToString(model.getMergedCoords()));
@@ -320 +433 @@
     }
 
+    protected void updateVisibleState() {
+        lblMyVisibleState.setText(visibleStateToString(model.getMyVisibleState()));
+        lblMergedVisibleState.setText(visibleStateToStringMerged(model.getMergedVisibleState()));
+        lblTheirVisibleState.setText(visibleStateToString(model.getTheirVisibleState()));
+
+        if (! model.hasVisibleStateConflict()) {
+            lblMyVisibleState.setBackground(BGCOLOR_NO_CONFLICT);
+            lblMergedVisibleState.setBackground(BGCOLOR_NO_CONFLICT);
+            lblTheirVisibleState.setBackground(BGCOLOR_NO_CONFLICT);
+        } else {
+            if (!model.isDecidedVisibleState()) {
+                lblMyVisibleState.setBackground(BGCOLOR_UNDECIDED);
+                lblMergedVisibleState.setBackground(BGCOLOR_NO_CONFLICT);
+                lblTheirVisibleState.setBackground(BGCOLOR_UNDECIDED);
+            } else {
+                lblMyVisibleState.setBackground(
+                        model.isVisibleStateDecision(MergeDecisionType.KEEP_MINE)
+                        ? BGCOLOR_DECIDED : BGCOLOR_NO_CONFLICT
+                );
+                lblMergedVisibleState.setBackground(BGCOLOR_DECIDED);
+                lblTheirVisibleState.setBackground(
+                        model.isVisibleStateDecision(MergeDecisionType.KEEP_THEIR)
+                        ? BGCOLOR_DECIDED : BGCOLOR_NO_CONFLICT
+                );
+            }
+        }
+    }
+
     public void update(Observable o, Object arg) {
-        updateCoordiates();
+        updateCoordinates();
         updateDeletedState();
+        updateVisibleState();
     }
 
@@ -418 +560 @@
         }
     }
+
+    class KeepMyVisibleStateAction extends AbstractAction implements Observer {
+        public KeepMyVisibleStateAction() {
+            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeepmine"));
+            putValue(Action.SHORT_DESCRIPTION, tr("Keep my visible state"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            if (confirmKeepMine()) {
+                model.decideVisibleStateConflict(MergeDecisionType.KEEP_MINE);
+            }
+        }
+
+        public void update(Observable o, Object arg) {
+            setEnabled(model.hasVisibleStateConflict() && ! model.isDecidedVisibleState());
+        }
+
+        protected boolean confirmKeepMine() {
+            String [] options = {
+                    tr("Yes, reset the id"),
+                    tr("No, abort")
+            };
+            int ret = JOptionPane.showOptionDialog(
+                    null,
+                    tr("<html>To keep your local version, JOSM<br>"
+                            + "has to reset the id of {0} {1} to 0.<br>"
+                            + "On the next upload the server will assign<br>"
+                            + "it a new id.<br>"
+                            + "Do yo agree?</html>",
+                            OsmPrimitiveType.from(model.getMyPrimitive()).getLocalizedDisplayNamePlural(),
+                            model.getMyPrimitive().id
+                    ),
+                    tr("Reset id to 0"),
+                    JOptionPane.YES_NO_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    null,
+                    options,
+                    options[1]
+            );
+            return ret == JOptionPane.YES_OPTION;
+        }
+    }
+
+    class KeepTheirVisibleStateAction extends AbstractAction implements Observer {
+        public KeepTheirVisibleStateAction() {
+            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagkeeptheir"));
+            putValue(Action.SHORT_DESCRIPTION, tr("Keep their visible state"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            if (confirmKeepTheir()){
+                model.decideVisibleStateConflict(MergeDecisionType.KEEP_THEIR);
+            }
+        }
+
+        public void update(Observable o, Object arg) {
+            setEnabled(model.hasVisibleStateConflict() && ! model.isDecidedVisibleState());
+        }
+
+        protected boolean confirmKeepTheir() {
+            String [] options = {
+                    tr("Yes, purge it"),
+                    tr("No, abort")
+            };
+            int ret = JOptionPane.showOptionDialog(
+                    null,
+                    tr("<html>JOSM will have to remove your local primitive with id {0}<br>"
+                            + "from the dataset.<br>"
+                            + "Do you agree?</html>",
+                            model.getMyPrimitive().id
+                    ),
+                    tr("Remove from dataset"),
+                    JOptionPane.YES_NO_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    null,
+                    options,
+                    options[1]
+            );
+            return ret == JOptionPane.YES_OPTION;
+        }
+    }
+
+    class UndecideVisibleStateConflictAction extends AbstractAction implements Observer {
+        public UndecideVisibleStateConflictAction() {
+            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs/conflict", "tagundecide"));
+            putValue(Action.SHORT_DESCRIPTION, tr("Undecide conflict between visible state"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            model.decideVisibleStateConflict(MergeDecisionType.UNDECIDED);
+        }
+
+        public void update(Observable o, Object arg) {
+            setEnabled(model.hasVisibleStateConflict() && model.isDecidedVisibleState());
+        }
+    }
 }