();
+ for (Way w: ways) {
+ ret.addAll(getParentRelations(w));
+ }
+ return ret;
+ }
+
+ /** Enable this action only if something is selected */
+ @Override
+ protected void updateEnabledState() {
+ if (getCurrentDataSet() == null) {
+ setEnabled(false);
+ } else {
+ updateEnabledState(getCurrentDataSet().getSelected());
+ }
+ }
+
+ /** Enable this action only if something is selected */
+ @Override
+ protected void updateEnabledState(
+ Collection selection) {
+ if (selection == null) {
+ setEnabled(false);
+ return;
+ }
+ for (OsmPrimitive primitive: selection) {
+ if (!(primitive instanceof Way) || primitive.isDeleted()) {
+ setEnabled(false);
+ return;
+ }
+ }
+ setEnabled(selection.size() >= 2);
+ }
+}
Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java (revision 26575)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MergeOverlapPlugin.java (revision 26575)
@@ -0,0 +1,40 @@
+package mergeoverlap;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+
+import javax.swing.JMenu;
+import javax.swing.JMenuItem;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.plugins.Plugin;
+import org.openstreetmap.josm.plugins.PluginInformation;
+
+/**
+ * A plugin merge overlapping part of selected ways to fix warns
+ */
+public class MergeOverlapPlugin extends Plugin {
+
+ protected String name;
+
+ public MergeOverlapPlugin(PluginInformation info) {
+ super(info);
+ name = tr("Merge overlap");
+ JMenu toolsMenu = null;
+ for (int i = 0; i < Main.main.menu.getMenuCount() && toolsMenu == null; i++) {
+ JMenu menu = Main.main.menu.getMenu(i);
+ String name = menu.getText();
+ if (name != null && name.equals(tr("Tools"))) {
+ toolsMenu = menu;
+ }
+ }
+
+ if (toolsMenu == null) {
+ toolsMenu = new JMenu(name);
+ toolsMenu.add(new JMenuItem(new MergeOverlapAction()));
+ Main.main.menu.add(toolsMenu, 2);
+ } else {
+ toolsMenu.addSeparator();
+ toolsMenu.add(new JMenuItem(new MergeOverlapAction()));
+ }
+ }
+}
Index: /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java
===================================================================
--- /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java (revision 26575)
+++ /applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/MyCombinePrimitiveResolverDialog.java (revision 26575)
@@ -0,0 +1,1436 @@
+// License: GPL. For details, see LICENSE file.
+package mergeoverlap;
+
+import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
+import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trc;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.Insets;
+import java.awt.event.ActionEvent;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.HierarchyBoundsListener;
+import java.awt.event.HierarchyEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.swing.AbstractAction;
+import javax.swing.AbstractButton;
+import javax.swing.Action;
+import javax.swing.BorderFactory;
+import javax.swing.BoxLayout;
+import javax.swing.ButtonModel;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JComboBox;
+import javax.swing.JComponent;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JSplitPane;
+import javax.swing.JTable;
+import javax.swing.KeyStroke;
+import javax.swing.ListSelectionModel;
+import javax.swing.UIManager;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import javax.swing.table.DefaultTableModel;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.command.ChangePropertyCommand;
+import org.openstreetmap.josm.command.Command;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.data.osm.RelationMember;
+import org.openstreetmap.josm.data.osm.RelationToChildReference;
+import org.openstreetmap.josm.data.osm.TagCollection;
+import org.openstreetmap.josm.data.osm.Way;
+import org.openstreetmap.josm.gui.DefaultNameFormatter;
+import org.openstreetmap.josm.gui.JMultilineLabel;
+import org.openstreetmap.josm.gui.SideButton;
+import org.openstreetmap.josm.gui.conflict.tags.MultiValueCellEditor;
+import org.openstreetmap.josm.gui.conflict.tags.MultiValueDecisionType;
+import org.openstreetmap.josm.gui.conflict.tags.MultiValueResolutionDecision;
+import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecision;
+import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecisionType;
+import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictResolverColumnModel;
+import org.openstreetmap.josm.gui.conflict.tags.TagConflictResolverColumnModel;
+import org.openstreetmap.josm.gui.help.ContextSensitiveHelpAction;
+import org.openstreetmap.josm.gui.help.HelpUtil;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
+import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
+import org.openstreetmap.josm.tools.CheckParameterUtil;
+import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.WindowGeometry;
+
+/**
+ * This dialog helps to resolve conflicts occurring when ways are combined or
+ * nodes are merged.
+ *
+ * There is a singleton instance of this dialog which can be retrieved using
+ * {@see #getInstance()}.
+ *
+ * The dialog uses two models: one for resolving tag conflicts, the other
+ * for resolving conflicts in relation memberships. For both models there are accessors,
+ * i.e {@see #getTagConflictResolverModel()} and {@see #getRelationMemberConflictResolverModel()}.
+ *
+ * Models have to be populated before the dialog is launched. Example:
+ *
+ * CombinePrimitiveResolverDialog dialog = CombinePrimitiveResolverDialog.getInstance();
+ * dialog.getTagConflictResolverModel().populate(aTagCollection);
+ * dialog.getRelationMemberConflictResolverModel().populate(aRelationLinkCollection);
+ * dialog.prepareDefaultDecisions();
+ *
+ *
+ * You should also set the target primitive which other primitives (ways or nodes) are
+ * merged to, see {@see #setTargetPrimitive(OsmPrimitive)}.
+ *
+ * After the dialog is closed use {@see #isCancelled()} to check whether the user canceled
+ * the dialog. If it wasn't canceled you may build a collection of {@see Command} objects
+ * which reflect the conflict resolution decisions the user made in the dialog:
+ * see {@see #buildResolutionCommands()}
+ *
+ *
+ */
+public class MyCombinePrimitiveResolverDialog extends JDialog {
+
+ /** the unique instance of the dialog */
+ static private MyCombinePrimitiveResolverDialog instance;
+
+ /**
+ * Replies the unique instance of the dialog
+ *
+ * @return the unique instance of the dialog
+ */
+ public static MyCombinePrimitiveResolverDialog getInstance() {
+ if (instance == null) {
+ instance = new MyCombinePrimitiveResolverDialog(Main.parent);
+ }
+ return instance;
+ }
+
+ private AutoAdjustingSplitPane spTagConflictTypes;
+ private MyTagConflictResolver pnlTagConflictResolver;
+ private MyRelationMemberConflictResolver pnlRelationMemberConflictResolver;
+ private boolean cancelled;
+ private JPanel pnlButtons;
+ private OsmPrimitive targetPrimitive;
+
+ /** the private help action */
+ private ContextSensitiveHelpAction helpAction;
+ /** the apply button */
+ private SideButton btnApply;
+
+ /**
+ * Replies the target primitive the collection of primitives is merged
+ * or combined to.
+ *
+ * @return the target primitive
+ */
+ public OsmPrimitive getTargetPrimitmive() {
+ return targetPrimitive;
+ }
+
+ /**
+ * Sets the primitive the collection of primitives is merged or combined
+ * to.
+ *
+ * @param primitive the target primitive
+ */
+ public void setTargetPrimitive(OsmPrimitive primitive) {
+ this.targetPrimitive = primitive;
+ updateTitle();
+ if (primitive instanceof Way) {
+ pnlRelationMemberConflictResolver.initForWayCombining();
+ } else if (primitive instanceof Node) {
+ pnlRelationMemberConflictResolver.initForNodeMerging();
+ }
+ }
+
+ protected void updateTitle() {
+ if (targetPrimitive == null) {
+ setTitle(tr("Conflicts when combining primitives"));
+ return;
+ }
+ if (targetPrimitive instanceof Way) {
+ setTitle(tr("Conflicts when combining ways - combined way is ''{0}''", targetPrimitive
+ .getDisplayName(DefaultNameFormatter.getInstance())));
+ helpAction.setHelpTopic(ht("/Action/CombineWay#ResolvingConflicts"));
+ getRootPane().putClientProperty("help", ht("/Action/CombineWay#ResolvingConflicts"));
+ } else if (targetPrimitive instanceof Node) {
+ setTitle(tr("Conflicts when merging nodes - target node is ''{0}''", targetPrimitive
+ .getDisplayName(DefaultNameFormatter.getInstance())));
+ helpAction.setHelpTopic(ht("/Action/MergeNodes#ResolvingConflicts"));
+ getRootPane().putClientProperty("help", ht("/Action/MergeNodes#ResolvingConflicts"));
+ }
+ }
+
+ protected void build() {
+ getContentPane().setLayout(new BorderLayout());
+ updateTitle();
+ spTagConflictTypes = new AutoAdjustingSplitPane(JSplitPane.VERTICAL_SPLIT);
+ spTagConflictTypes.setTopComponent(buildTagConflictResolverPanel());
+ spTagConflictTypes.setBottomComponent(buildRelationMemberConflictResolverPanel());
+ getContentPane().add(pnlButtons = buildButtonPanel(), BorderLayout.SOUTH);
+ addWindowListener(new AdjustDividerLocationAction());
+ HelpUtil.setHelpContext(getRootPane(), ht("/"));
+ }
+
+ protected JPanel buildTagConflictResolverPanel() {
+ pnlTagConflictResolver = new MyTagConflictResolver();
+ return pnlTagConflictResolver;
+ }
+
+ protected JPanel buildRelationMemberConflictResolverPanel() {
+ pnlRelationMemberConflictResolver = new MyRelationMemberConflictResolver();
+ return pnlRelationMemberConflictResolver;
+ }
+
+ protected JPanel buildButtonPanel() {
+ JPanel pnl = new JPanel();
+ pnl.setLayout(new FlowLayout(FlowLayout.CENTER));
+
+ // -- apply button
+ ApplyAction applyAction = new ApplyAction();
+ pnlTagConflictResolver.getModel().addPropertyChangeListener(applyAction);
+ pnlRelationMemberConflictResolver.getModel().addPropertyChangeListener(applyAction);
+ btnApply = new SideButton(applyAction);
+ btnApply.setFocusable(true);
+ pnl.add(btnApply);
+
+ // -- cancel button
+ CancelAction cancelAction = new CancelAction();
+ pnl.add(new SideButton(cancelAction));
+
+ // -- help button
+ helpAction = new ContextSensitiveHelpAction();
+ pnl.add(new SideButton(helpAction));
+
+ return pnl;
+ }
+
+ public MyCombinePrimitiveResolverDialog(Component owner) {
+ super(JOptionPane.getFrameForComponent(owner), ModalityType.DOCUMENT_MODAL);
+ build();
+ }
+
+ public MyTagConflictResolverModel getTagConflictResolverModel() {
+ return pnlTagConflictResolver.getModel();
+ }
+
+ public MyRelationMemberConflictResolverModel getRelationMemberConflictResolverModel() {
+ return pnlRelationMemberConflictResolver.getModel();
+ }
+
+ protected List buildTagChangeCommand(OsmPrimitive primitive, TagCollection tc) {
+ LinkedList cmds = new LinkedList();
+ for (String key : tc.getKeys()) {
+ if (tc.hasUniqueEmptyValue(key)) {
+ if (primitive.get(key) != null) {
+ cmds.add(new ChangePropertyCommand(primitive, key, null));
+ }
+ } else {
+ String value = tc.getJoinedValues(key);
+ if (!value.equals(primitive.get(key))) {
+ cmds.add(new ChangePropertyCommand(primitive, key, value));
+ }
+ }
+ }
+ return cmds;
+ }
+
+ public List buildWayResolutionCommands() {
+ List cmds = new LinkedList();
+
+ TagCollection allResolutions = getTagConflictResolverModel().getAllResolutions();
+ if (allResolutions.size() > 0) {
+ cmds.addAll(buildTagChangeCommand(targetPrimitive, allResolutions));
+ }
+ if (targetPrimitive.get("created_by") != null) {
+ cmds.add(new ChangePropertyCommand(targetPrimitive, "created_by", null));
+ }
+
+ Command cmd = pnlRelationMemberConflictResolver.buildTagApplyCommands(getRelationMemberConflictResolverModel()
+ .getModifiedRelations(targetPrimitive));
+ if (cmd != null) {
+ cmds.add(cmd);
+ }
+ return cmds;
+ }
+
+ public void buildRelationCorrespondance(Map newRelations, Map oldWays) {
+ getRelationMemberConflictResolverModel().buildRelationCorrespondance(targetPrimitive, newRelations, oldWays);
+ }
+
+ protected void prepareDefaultTagDecisions() {
+ MyTagConflictResolverModel model = getTagConflictResolverModel();
+ for (int i = 0; i < model.getRowCount(); i++) {
+ MultiValueResolutionDecision decision = model.getDecision(i);
+ List values = decision.getValues();
+ values.remove("");
+ if (values.size() == 1) {
+ decision.keepOne(values.get(0));
+ } else {
+ decision.keepAll();
+ }
+ }
+ model.rebuild();
+ }
+
+ protected void prepareDefaultRelationDecisions() {
+ MyRelationMemberConflictResolverModel model = getRelationMemberConflictResolverModel();
+ Set relations = new HashSet();
+ for (int i = 0; i < model.getNumDecisions(); i++) {
+ RelationMemberConflictDecision decision = model.getDecision(i);
+ if (!relations.contains(decision.getRelation())) {
+ decision.decide(RelationMemberConflictDecisionType.KEEP);
+ relations.add(decision.getRelation());
+ } else {
+ decision.decide(RelationMemberConflictDecisionType.REMOVE);
+ }
+ }
+ model.refresh();
+ }
+
+ public void prepareDefaultDecisions() {
+ prepareDefaultTagDecisions();
+ prepareDefaultRelationDecisions();
+ }
+
+ protected JPanel buildEmptyConflictsPanel() {
+ JPanel pnl = new JPanel();
+ pnl.setLayout(new BorderLayout());
+ pnl.add(new JLabel(tr("No conflicts to resolve")));
+ return pnl;
+ }
+
+ protected void prepareGUIBeforeConflictResolutionStarts() {
+ MyRelationMemberConflictResolverModel relModel = getRelationMemberConflictResolverModel();
+ MyTagConflictResolverModel tagModel = getTagConflictResolverModel();
+ getContentPane().removeAll();
+
+ if (relModel.getNumDecisions() > 0 && tagModel.getNumDecisions() > 0) {
+ // display both, the dialog for resolving relation conflicts and for resolving
+ // tag conflicts
+ spTagConflictTypes.setTopComponent(pnlTagConflictResolver);
+ spTagConflictTypes.setBottomComponent(pnlRelationMemberConflictResolver);
+ getContentPane().add(spTagConflictTypes, BorderLayout.CENTER);
+ } else if (relModel.getNumDecisions() > 0) {
+ // relation conflicts only
+ //
+ getContentPane().add(pnlRelationMemberConflictResolver, BorderLayout.CENTER);
+ } else if (tagModel.getNumDecisions() > 0) {
+ // tag conflicts only
+ //
+ getContentPane().add(pnlTagConflictResolver, BorderLayout.CENTER);
+ } else {
+ getContentPane().add(buildEmptyConflictsPanel(), BorderLayout.CENTER);
+ }
+
+ getContentPane().add(pnlButtons, BorderLayout.SOUTH);
+ validate();
+ int numTagDecisions = getTagConflictResolverModel().getNumDecisions();
+ int numRelationDecisions = getRelationMemberConflictResolverModel().getNumDecisions();
+ if (numTagDecisions > 0 && numRelationDecisions > 0) {
+ spTagConflictTypes.setDividerLocation(0.5);
+ }
+ pnlRelationMemberConflictResolver.prepareForEditing();
+ }
+
+ protected void setCancelled(boolean cancelled) {
+ this.cancelled = cancelled;
+ }
+
+ public boolean isCancelled() {
+ return cancelled;
+ }
+
+ @Override
+ public void setVisible(boolean visible) {
+ if (visible) {
+ prepareGUIBeforeConflictResolutionStarts();
+ new WindowGeometry(getClass().getName() + ".geometry", WindowGeometry.centerInWindow(Main.parent,
+ new Dimension(600, 400))).applySafe(this);
+ setCancelled(false);
+ btnApply.requestFocusInWindow();
+ } else {
+ new WindowGeometry(this).remember(getClass().getName() + ".geometry");
+ }
+ super.setVisible(visible);
+ }
+
+ class CancelAction extends AbstractAction {
+
+ public CancelAction() {
+ putValue(Action.SHORT_DESCRIPTION, tr("Cancel conflict resolution"));
+ putValue(Action.NAME, tr("Cancel"));
+ putValue(Action.SMALL_ICON, ImageProvider.get("", "cancel"));
+ setEnabled(true);
+ }
+
+ public void actionPerformed(ActionEvent arg0) {
+ setCancelled(true);
+ setVisible(false);
+ }
+ }
+
+ class ApplyAction extends AbstractAction implements PropertyChangeListener {
+
+ public ApplyAction() {
+ putValue(Action.SHORT_DESCRIPTION, tr("Apply resolved conflicts"));
+ putValue(Action.NAME, tr("Apply"));
+ putValue(Action.SMALL_ICON, ImageProvider.get("ok"));
+ updateEnabledState();
+ }
+
+ public void actionPerformed(ActionEvent arg0) {
+ setVisible(false);
+ pnlTagConflictResolver.rememberPreferences();
+ }
+
+ protected void updateEnabledState() {
+ setEnabled(pnlTagConflictResolver.getModel().getNumConflicts() == 0
+ && pnlRelationMemberConflictResolver.getModel().getNumConflicts() == 0);
+ }
+
+ public void propertyChange(PropertyChangeEvent evt) {
+ if (evt.getPropertyName().equals(MyTagConflictResolverModel.NUM_CONFLICTS_PROP)) {
+ updateEnabledState();
+ }
+ if (evt.getPropertyName().equals(MyRelationMemberConflictResolverModel.NUM_CONFLICTS_PROP)) {
+ updateEnabledState();
+ }
+ }
+ }
+
+ class AdjustDividerLocationAction extends WindowAdapter {
+ @Override
+ public void windowOpened(WindowEvent e) {
+ int numTagDecisions = getTagConflictResolverModel().getNumDecisions();
+ int numRelationDecisions = getRelationMemberConflictResolverModel().getNumDecisions();
+ if (numTagDecisions > 0 && numRelationDecisions > 0) {
+ spTagConflictTypes.setDividerLocation(0.5);
+ }
+ }
+ }
+
+ static class AutoAdjustingSplitPane extends JSplitPane implements PropertyChangeListener, HierarchyBoundsListener {
+ private double dividerLocation;
+
+ public AutoAdjustingSplitPane(int newOrientation) {
+ super(newOrientation);
+ addPropertyChangeListener(JSplitPane.DIVIDER_LOCATION_PROPERTY, this);
+ addHierarchyBoundsListener(this);
+ }
+
+ public void ancestorResized(HierarchyEvent e) {
+ setDividerLocation((int) (dividerLocation * getHeight()));
+ }
+
+ public void ancestorMoved(HierarchyEvent e) {
+ // do nothing
+ }
+
+ public void propertyChange(PropertyChangeEvent evt) {
+ if (evt.getPropertyName().equals(JSplitPane.DIVIDER_LOCATION_PROPERTY)) {
+ int newVal = (Integer) evt.getNewValue();
+ if (getHeight() != 0) {
+ dividerLocation = (double) newVal / (double) getHeight();
+ }
+ }
+ }
+ }
+
+ /**
+ * This model manages a list of conflicting relation members.
+ *
+ * It can be used as {@see TableModel}.
+ *
+ *
+ */
+ public static class MyRelationMemberConflictResolverModel extends DefaultTableModel {
+ /** the property name for the number conflicts managed by this model */
+ static public final String NUM_CONFLICTS_PROP = MyRelationMemberConflictResolverModel.class.getName() + ".numConflicts";
+
+ /** the list of conflict decisions */
+ private List decisions;
+ /** the collection of relations for which we manage conflicts */
+ private Collection relations;
+ /** the number of conflicts */
+ private int numConflicts;
+ private PropertyChangeSupport support;
+
+ /**
+ * Replies the current number of conflicts
+ *
+ * @return the current number of conflicts
+ */
+ public int getNumConflicts() {
+ return numConflicts;
+ }
+
+ /**
+ * Updates the current number of conflicts from list of decisions and emits
+ * a property change event if necessary.
+ *
+ */
+ protected void updateNumConflicts() {
+ int count = 0;
+ for (RelationMemberConflictDecision decision: decisions) {
+ if (!decision.isDecided()) {
+ count++;
+ }
+ }
+ int oldValue = numConflicts;
+ numConflicts = count;
+ if (numConflicts != oldValue) {
+ support.firePropertyChange(NUM_CONFLICTS_PROP, oldValue, numConflicts);
+ }
+ }
+
+ public void addPropertyChangeListener(PropertyChangeListener l) {
+ support.addPropertyChangeListener(l);
+ }
+
+ public void removePropertyChangeListener(PropertyChangeListener l) {
+ support.removePropertyChangeListener(l);
+ }
+
+ public MyRelationMemberConflictResolverModel() {
+ decisions = new ArrayList();
+ support = new PropertyChangeSupport(this);
+ }
+
+ @Override
+ public int getRowCount() {
+ if (decisions == null) return 0;
+ return decisions.size();
+ }
+
+ @Override
+ public Object getValueAt(int row, int column) {
+ if (decisions == null) return null;
+
+ RelationMemberConflictDecision d = decisions.get(row);
+ switch(column) {
+ case 0: /* relation */ return d.getRelation();
+ case 1: /* pos */ return Integer.toString(d.getPos() + 1); // position in "user space" starting at 1
+ case 2: /* role */ return d.getRole();
+ case 3: /* original */ return d.getOriginalPrimitive();
+ case 4: /* decision */ return d.getDecision();
+ }
+ return null;
+ }
+
+ @Override
+ public void setValueAt(Object value, int row, int column) {
+ RelationMemberConflictDecision d = decisions.get(row);
+ switch(column) {
+ case 2: /* role */
+ d.setRole((String)value);
+ break;
+ case 4: /* decision */
+ d.decide((RelationMemberConflictDecisionType)value);
+ refresh();
+ break;
+ }
+ fireTableDataChanged();
+ }
+
+ /**
+ * Populates the model with the members of the relation relation
+ * referring to primitive.
+ *
+ * @param relation the parent relation
+ * @param primitive the child primitive
+ */
+ protected void populate(Relation relation, OsmPrimitive primitive, Map oldWays) {
+ for (int i = 0; irelations
+ * and referring to one of the primitives in memberPrimitives.
+ *
+ * @param relations the parent relations. Empty list assumed if null.
+ * @param memberPrimitives the child primitives. Empty list assumed if null.
+ */
+ public void populate(Collection relations, Collection memberPrimitives, Map oldWays) {
+ decisions.clear();
+
+ relations = relations == null ? new LinkedList() : relations;
+ memberPrimitives = memberPrimitives == null ? new LinkedList() : memberPrimitives;
+ for (Relation r : relations) {
+ for (OsmPrimitive p: memberPrimitives) {
+ populate(r, p, oldWays);
+ }
+ }
+ this.relations = relations;
+ refresh();
+ }
+
+ /**
+ * Populates the model with the relation members represented as a collection of
+ * {@see RelationToChildReference}s.
+ *
+ * @param references the references. Empty list assumed if null.
+ */
+ public void populate(Collection references) {
+ references = references == null ? new LinkedList() : references;
+ decisions.clear();
+ this.relations = new HashSet(references.size());
+ for (RelationToChildReference reference: references) {
+ decisions.add(new RelationMemberConflictDecision(reference.getParent(), reference.getPosition()));
+ relations.add(reference.getParent());
+ }
+ refresh();
+ }
+
+ /**
+ * Replies the decision at position row
+ *
+ * @param row
+ * @return the decision at position row
+ */
+ public RelationMemberConflictDecision getDecision(int row) {
+ return decisions.get(row);
+ }
+
+ /**
+ * Replies the number of decisions managed by this model
+ *
+ * @return the number of decisions managed by this model
+ */
+ public int getNumDecisions() {
+ return getRowCount();
+ }
+
+ /**
+ * Refreshes the model state. Invoke this method to trigger necessary change
+ * events after an update of the model data.
+ *
+ */
+ public void refresh() {
+ updateNumConflicts();
+ fireTableDataChanged();
+ }
+
+ /**
+ * Apply a role to all member managed by this model.
+ *
+ * @param role the role. Empty string assumed if null.
+ */
+ public void applyRole(String role) {
+ role = role == null ? "" : role;
+ for (RelationMemberConflictDecision decision : decisions) {
+ decision.setRole(role);
+ }
+ refresh();
+ }
+
+ protected RelationMemberConflictDecision getDecision(Relation relation, int pos) {
+ for(RelationMemberConflictDecision decision: decisions) {
+ if (decision.matches(relation, pos)) return decision;
+ }
+ return null;
+ }
+
+ protected void buildResolveCorrespondance(Relation relation, OsmPrimitive newPrimitive, Map newRelations, Map oldWays) {
+
+ List relationsMembers = relation.getMembers();
+ Relation modifiedRelation = MergeOverlapAction.getNew(relation, newRelations);
+ modifiedRelation.setMembers(null);
+// boolean isChanged = false;
+ for (int i=0; i < relationsMembers.size(); i++) {
+ RelationMember rm = relationsMembers.get(i);
+// RelationMember rm = relation.getMember(i);
+// RelationMember rmNew;
+ RelationMemberConflictDecision decision = getDecision(relation, i);
+ if (decision == null) {
+ modifiedRelation.addMember(rm);
+ } else {
+ System.out.println(modifiedRelation);
+ System.out.println(111);
+ switch(decision.getDecision()) {
+ case KEEP:
+// modifiedRelation.removeMembersFor(newPrimitive);
+ System.out.println(222);
+ if (newPrimitive instanceof Way) {
+ modifiedRelation.addMember(new RelationMember(decision.getRole(), MergeOverlapAction.getOld((Way)newPrimitive, oldWays)));
+ }
+ else {
+ modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
+ }
+// modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
+ break;
+ case REMOVE:
+ System.out.println(333);
+// modifiedRelation.removeMembersFor(rm.getMember());
+// isChanged = true;
+ // do nothing
+ break;
+ case UNDECIDED:
+ // FIXME: this is an error
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Builds a collection of commands executing the decisions made in this model.
+ *
+ * @param newPrimitive the primitive which members shall refer to if the
+ * decision is {@see RelationMemberConflictDecisionType#REPLACE}
+ * @return a list of commands
+ */
+ public void buildRelationCorrespondance(OsmPrimitive newPrimitive, Map newRelations, Map oldWays) {
+ for (Relation relation : relations) {
+ buildResolveCorrespondance(relation, newPrimitive, newRelations, oldWays);
+ }
+ }
+
+ protected boolean isChanged(Relation relation, OsmPrimitive newPrimitive) {
+ for (int i=0; i < relation.getMembersCount(); i++) {
+ RelationMemberConflictDecision decision = getDecision(relation, i);
+ if (decision == null) {
+ continue;
+ }
+ switch(decision.getDecision()) {
+ case REMOVE: return true;
+ case KEEP:
+ if (!relation.getMember(i).getRole().equals(decision.getRole()))
+ return true;
+ if (relation.getMember(i).getMember() != newPrimitive)
+ return true;
+ case UNDECIDED:
+ // FIXME: handle error
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Replies the set of relations which have to be modified according
+ * to the decisions managed by this model.
+ *
+ * @param newPrimitive the primitive which members shall refer to if the
+ * decision is {@see RelationMemberConflictDecisionType#REPLACE}
+ *
+ * @return the set of relations which have to be modified according
+ * to the decisions managed by this model
+ */
+ public Set getModifiedRelations(OsmPrimitive newPrimitive) {
+ HashSet ret = new HashSet();
+ for (Relation relation: relations) {
+ if (isChanged(relation, newPrimitive)) {
+ ret.add(relation);
+ }
+ }
+ return ret;
+ }
+ }
+
+ public class MyRelationMemberConflictResolver extends JPanel {
+
+ private AutoCompletingTextField tfRole;
+ private AutoCompletingTextField tfKey;
+ private AutoCompletingTextField tfValue;
+ private JCheckBox cbTagRelations;
+ private MyRelationMemberConflictResolverModel model;
+ private MyRelationMemberConflictResolverTable tblResolver;
+ private JMultilineLabel lblHeader;
+
+ protected void build() {
+ setLayout(new GridBagLayout());
+ JPanel pnl = new JPanel();
+ pnl.setLayout(new BorderLayout());
+ pnl.add(lblHeader = new JMultilineLabel(""));
+ GridBagConstraints gc = new GridBagConstraints();
+ gc.fill = GridBagConstraints.HORIZONTAL;
+ gc.weighty = 0.0;
+ gc.weightx = 1.0;
+ gc.insets = new Insets(5,5,5,5);
+ add(pnl, gc);
+ model = new MyRelationMemberConflictResolverModel();
+
+ gc.gridy = 1;
+ gc.weighty = 1.0;
+ gc.fill = GridBagConstraints.BOTH;
+ gc.insets = new Insets(0,0,0,0);
+ add(new JScrollPane(tblResolver = new MyRelationMemberConflictResolverTable(model)), gc);
+ pnl = new JPanel();
+ pnl.setLayout(new BoxLayout(pnl, BoxLayout.Y_AXIS));
+ pnl.add(buildRoleEditingPanel());
+ pnl.add(buildTagRelationsPanel());
+ gc.gridy = 2;
+ gc.weighty = 0.0;
+ gc.fill = GridBagConstraints.HORIZONTAL;
+ add(pnl,gc);
+ }
+
+ protected JPanel buildRoleEditingPanel() {
+ JPanel pnl = new JPanel();
+ pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
+ pnl.add(new JLabel(tr("Role:")));
+ pnl.add(tfRole = new AutoCompletingTextField(10));
+ tfRole.setToolTipText(tr("Enter a role for all relation memberships"));
+ pnl.add(new JButton(new ApplyRoleAction()));
+ tfRole.addActionListener(new ApplyRoleAction());
+ tfRole.addFocusListener(
+ new FocusAdapter() {
+ @Override
+ public void focusGained(FocusEvent e) {
+ tfRole.selectAll();
+ }
+ }
+ );
+ return pnl;
+ }
+
+ protected JPanel buildTagRelationsPanel() {
+ JPanel pnl = new JPanel();
+ pnl.setLayout(new FlowLayout(FlowLayout.LEFT));
+ cbTagRelations = new JCheckBox(tr("Tag modified relations with "));
+ cbTagRelations.addChangeListener(new ToggleTagRelationsAction());
+ cbTagRelations.setToolTipText(
+ tr("Select to enable entering a tag which will be applied
"
+ + "to all modified relations."));
+ pnl.add(cbTagRelations);
+ pnl.add(new JLabel(trc("tag", "Key:")));
+ pnl.add(tfKey = new AutoCompletingTextField(10));
+ tfKey.setToolTipText(tr("Enter a tag key, i.e. fixme"));
+ pnl.add(new JLabel(tr("Value:")));
+ pnl.add(tfValue = new AutoCompletingTextField(10));
+ tfValue.setToolTipText(tr("Enter a tag value, i.e. check members"));
+ cbTagRelations.setSelected(false);
+ tfKey.setEnabled(false);
+ tfValue.setEnabled(false);
+ return pnl;
+ }
+
+ public MyRelationMemberConflictResolver() {
+ build();
+ }
+
+ public void initForWayCombining() {
+ lblHeader.setText(tr("The combined ways are members in one ore more relations. "
+ + "Please decide whether you want to keep these memberships "
+ + "for the combined way or whether you want to remove them.
"
+ + "The default is to keep the first way and remove "
+ + "the other ways that are members of the same relation: the combined way will "
+ + "take the place of the original way in the relation."
+ + ""));
+ invalidate();
+ }
+
+ public void initForNodeMerging() {
+ lblHeader.setText(tr("The merged nodes are members in one ore more relations. "
+ + "Please decide whether you want to keep these memberships "
+ + "for the target node or whether you want to remove them.
"
+ + "The default is to keep the first node and remove "
+ + "the other nodes that are members of the same relation: the target node will "
+ + "take the place of the original node in the relation."
+ + ""));
+ invalidate();
+ }
+
+ class ApplyRoleAction extends AbstractAction {
+ public ApplyRoleAction() {
+ putValue(NAME, tr("Apply"));
+ putValue(SMALL_ICON, ImageProvider.get("ok"));
+ putValue(SHORT_DESCRIPTION, tr("Apply this role to all members"));
+ }
+
+ public void actionPerformed(ActionEvent e) {
+ model.applyRole(tfRole.getText());
+ }
+ }
+
+ class ToggleTagRelationsAction implements ChangeListener {
+ public void stateChanged(ChangeEvent e) {
+ ButtonModel buttonModel = ((AbstractButton) e.getSource()).getModel();
+ tfKey.setEnabled(buttonModel.isSelected());
+ tfValue.setEnabled(buttonModel.isSelected());
+ tfKey.setBackground(buttonModel.isSelected() ? UIManager.getColor("TextField.background") : UIManager
+ .getColor("Panel.background"));
+ tfValue.setBackground(buttonModel.isSelected() ? UIManager.getColor("TextField.background") : UIManager
+ .getColor("Panel.background"));
+ }
+ }
+
+ public MyRelationMemberConflictResolverModel getModel() {
+ return model;
+ }
+
+ public Command buildTagApplyCommands(Collection primitives) {
+ if (!cbTagRelations.isSelected())
+ return null;
+ if (tfKey.getText().trim().equals(""))
+ return null;
+ if (tfValue.getText().trim().equals(""))
+ return null;
+ if (primitives == null || primitives.isEmpty())
+ return null;
+ return new ChangePropertyCommand(primitives, tfKey.getText(), tfValue.getText());
+ }
+
+ public void prepareForEditing() {
+ AutoCompletionList acList = new AutoCompletionList();
+ Main.main.getEditLayer().data.getAutoCompletionManager().populateWithMemberRoles(acList);
+ tfRole.setAutoCompletionList(acList);
+ AutoCompletingTextField editor = (AutoCompletingTextField) tblResolver.getColumnModel().getColumn(2).getCellEditor();
+ if (editor != null) {
+ editor.setAutoCompletionList(acList);
+ }
+ AutoCompletionList acList2 = new AutoCompletionList();
+ Main.main.getEditLayer().data.getAutoCompletionManager().populateWithKeys(acList2);
+ tfKey.setAutoCompletionList(acList2);
+ }
+ }
+
+
+ public class MyRelationMemberConflictResolverTable extends JTable implements MultiValueCellEditor.NavigationListener {
+
+ private SelectNextColumnCellAction selectNextColumnCellAction;
+ private SelectPreviousColumnCellAction selectPreviousColumnCellAction;
+
+ public MyRelationMemberConflictResolverTable(MyRelationMemberConflictResolverModel model) {
+ super(model, new RelationMemberConflictResolverColumnModel());
+ build();
+ }
+
+ protected void build() {
+ setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+ setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+ putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
+
+ // make ENTER behave like TAB
+ //
+ getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+ KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, false), "selectNextColumnCell");
+
+ // install custom navigation actions
+ //
+ selectNextColumnCellAction = new SelectNextColumnCellAction();
+ selectPreviousColumnCellAction = new SelectPreviousColumnCellAction();
+ getActionMap().put("selectNextColumnCell", selectNextColumnCellAction);
+ getActionMap().put("selectPreviousColumnCell", selectPreviousColumnCellAction);
+
+ setRowHeight((int)new JComboBox().getPreferredSize().getHeight());
+ }
+
+ /**
+ * Action to be run when the user navigates to the next cell in the table, for instance by
+ * pressing TAB or ENTER. The action alters the standard navigation path from cell to cell:
+ * - it jumps over cells in the first column
- it automatically add a new empty row
+ * when the user leaves the last cell in the table
+ *
+ *
+ */
+ class SelectNextColumnCellAction extends AbstractAction {
+ public void actionPerformed(ActionEvent e) {
+ run();
+ }
+
+ public void run() {
+ int col = getSelectedColumn();
+ int row = getSelectedRow();
+ if (getCellEditor() != null) {
+ getCellEditor().stopCellEditing();
+ }
+
+ if (col == 2 && row < getRowCount() - 1) {
+ row++;
+ } else if (row < getRowCount() - 1) {
+ col = 2;
+ row++;
+ }
+ changeSelection(row, col, false, false);
+ editCellAt(getSelectedRow(), getSelectedColumn());
+ getEditorComponent().requestFocusInWindow();
+ }
+ }
+
+ /**
+ * Action to be run when the user navigates to the previous cell in the table, for instance by
+ * pressing Shift-TAB
+ *
+ */
+ class SelectPreviousColumnCellAction extends AbstractAction {
+
+ public void actionPerformed(ActionEvent e) {
+ run();
+ }
+
+ public void run() {
+ int col = getSelectedColumn();
+ int row = getSelectedRow();
+ if (getCellEditor() != null) {
+ getCellEditor().stopCellEditing();
+ }
+
+ if (col <= 0 && row <= 0) {
+ // change nothing
+ } else if (row > 0) {
+ col = 2;
+ row--;
+ }
+ changeSelection(row, col, false, false);
+ editCellAt(getSelectedRow(), getSelectedColumn());
+ getEditorComponent().requestFocusInWindow();
+ }
+ }
+
+ public void gotoNextDecision() {
+ selectNextColumnCellAction.run();
+ }
+
+ public void gotoPreviousDecision() {
+ selectPreviousColumnCellAction.run();
+ }
+ }
+
+
+ public static class MyTagConflictResolverModel extends DefaultTableModel {
+ static public final String NUM_CONFLICTS_PROP = MyTagConflictResolverModel.class.getName() + ".numConflicts";
+
+ private TagCollection tags;
+ private List displayedKeys;
+ private Set keysWithConflicts;
+ private HashMap decisions;
+ private int numConflicts;
+ private PropertyChangeSupport support;
+ private boolean showTagsWithConflictsOnly = false;
+ private boolean showTagsWithMultiValuesOnly = false;
+
+ public MyTagConflictResolverModel() {
+ numConflicts = 0;
+ support = new PropertyChangeSupport(this);
+ }
+
+ public void addPropertyChangeListener(PropertyChangeListener listener) {
+ support.addPropertyChangeListener(listener);
+ }
+
+ public void removePropertyChangeListener(PropertyChangeListener listener) {
+ support.removePropertyChangeListener(listener);
+ }
+
+ protected void setNumConflicts(int numConflicts) {
+ int oldValue = this.numConflicts;
+ this.numConflicts = numConflicts;
+ if (oldValue != this.numConflicts) {
+ support.firePropertyChange(NUM_CONFLICTS_PROP, oldValue, this.numConflicts);
+ }
+ }
+
+ protected void refreshNumConflicts() {
+ int count = 0;
+ for (MultiValueResolutionDecision d : decisions.values()) {
+ if (!d.isDecided()) {
+ count++;
+ }
+ }
+ setNumConflicts(count);
+ }
+
+ protected void sort() {
+ Collections.sort(
+ displayedKeys,
+ new Comparator() {
+ public int compare(String key1, String key2) {
+ if (decisions.get(key1).isDecided() && ! decisions.get(key2).isDecided())
+ return 1;
+ else if (!decisions.get(key1).isDecided() && decisions.get(key2).isDecided())
+ return -1;
+ return key1.compareTo(key2);
+ }
+ }
+ );
+ }
+
+ /**
+ * initializes the model from the current tags
+ *
+ */
+ protected void rebuild() {
+ if (tags == null) return;
+ for(String key: tags.getKeys()) {
+ MultiValueResolutionDecision decision = new MultiValueResolutionDecision(tags.getTagsFor(key));
+ if (decisions.get(key) == null) {
+ decisions.put(key,decision);
+ }
+ }
+ displayedKeys.clear();
+ Set keys = tags.getKeys();
+ if (showTagsWithConflictsOnly) {
+ keys.retainAll(keysWithConflicts);
+ if (showTagsWithMultiValuesOnly) {
+ Set keysWithMultiValues = new HashSet();
+ for (String key: keys) {
+ if (decisions.get(key).canKeepAll()) {
+ keysWithMultiValues.add(key);
+ }
+ }
+ keys.retainAll(keysWithMultiValues);
+ }
+ for (String key: tags.getKeys()) {
+ if (!decisions.get(key).isDecided() && !keys.contains(key)) {
+ keys.add(key);
+ }
+ }
+ }
+ displayedKeys.addAll(keys);
+ refreshNumConflicts();
+ sort();
+ fireTableDataChanged();
+ }
+
+ /**
+ * Populates the model with the tags for which conflicts are to be resolved.
+ *
+ * @param tags the tag collection with the tags. Must not be null.
+ * @param keysWithConflicts the set of tag keys with conflicts
+ * @throws IllegalArgumentException thrown if tags is null
+ */
+ public void populate(TagCollection tags, Set keysWithConflicts) {
+ CheckParameterUtil.ensureParameterNotNull(tags, "tags");
+ this.tags = tags;
+ displayedKeys = new ArrayList();
+ this.keysWithConflicts = keysWithConflicts == null ? new HashSet() : keysWithConflicts;
+ decisions = new HashMap();
+ rebuild();
+ }
+
+ @Override
+ public int getRowCount() {
+ if (displayedKeys == null) return 0;
+ return displayedKeys.size();
+ }
+
+ @Override
+ public Object getValueAt(int row, int column) {
+ return decisions.get(displayedKeys.get(row));
+ }
+
+ @Override
+ public boolean isCellEditable(int row, int column) {
+ return column == 2;
+ }
+
+ @Override
+ public void setValueAt(Object value, int row, int column) {
+ MultiValueResolutionDecision decision = decisions.get(displayedKeys.get(row));
+ if (value instanceof String) {
+ decision.keepOne((String)value);
+ } else if (value instanceof MultiValueDecisionType) {
+ MultiValueDecisionType type = (MultiValueDecisionType)value;
+ switch(type) {
+ case KEEP_NONE:
+ decision.keepNone();
+ break;
+ case KEEP_ALL:
+ decision.keepAll();
+ break;
+ }
+ }
+ fireTableDataChanged();
+ refreshNumConflicts();
+ }
+
+ /**
+ * Replies true if each {@see MultiValueResolutionDecision} is decided.
+ *
+ * @return true if each {@see MultiValueResolutionDecision} is decided; false
+ * otherwise
+ */
+ public boolean isResolvedCompletely() {
+ return numConflicts == 0;
+ }
+
+ public int getNumConflicts() {
+ return numConflicts;
+ }
+
+ public int getNumDecisions() {
+ return getRowCount();
+ }
+
+ //TODO Should this method work with all decisions or only with displayed decisions? For MergeNodes it should be
+ //all decisions, but this method is also used on other places, so I've made new method just for MergeNodes
+ public TagCollection getResolution() {
+ TagCollection tc = new TagCollection();
+ for (String key: displayedKeys) {
+ tc.add(decisions.get(key).getResolution());
+ }
+ return tc;
+ }
+
+ public TagCollection getAllResolutions() {
+ TagCollection tc = new TagCollection();
+ for (MultiValueResolutionDecision value: decisions.values()) {
+ tc.add(value.getResolution());
+ }
+ return tc;
+ }
+
+ public MultiValueResolutionDecision getDecision(int row) {
+ return decisions.get(displayedKeys.get(row));
+ }
+
+ /**
+ * Sets whether all tags or only tags with conflicts are displayed
+ *
+ * @param showTagsWithConflictsOnly if true, only tags with conflicts are displayed
+ */
+ public void setShowTagsWithConflictsOnly(boolean showTagsWithConflictsOnly) {
+ this.showTagsWithConflictsOnly = showTagsWithConflictsOnly;
+ rebuild();
+ }
+
+ /**
+ * Sets whether all conflicts or only conflicts with multiple values are displayed
+ *
+ * @param showTagsWithMultiValuesOnly if true, only tags with multiple values are displayed
+ */
+ public void setShowTagsWithMultiValuesOnly(boolean showTagsWithMultiValuesOnly) {
+ this.showTagsWithMultiValuesOnly = showTagsWithMultiValuesOnly;
+ rebuild();
+ }
+
+ /**
+ * Prepare the default decisions for the current model
+ *
+ */
+ public void prepareDefaultTagDecisions() {
+ for (MultiValueResolutionDecision decision: decisions.values()) {
+ List values = decision.getValues();
+ values.remove("");
+ if (values.size() == 1) {
+ decision.keepOne(values.get(0));
+ } else {
+ decision.keepAll();
+ }
+ }
+ rebuild();
+ }
+
+ }
+
+
+ /**
+ * This is a UI widget for resolving tag conflicts, i.e. differences of the tag values
+ * of multiple {@see OsmPrimitive}s.
+ *
+ *
+ */
+ public class MyTagConflictResolver extends JPanel {
+
+ /** the model for the tag conflict resolver */
+ private MyTagConflictResolverModel model;
+ /** selects wheter only tags with conflicts are displayed */
+ private JCheckBox cbShowTagsWithConflictsOnly;
+ private JCheckBox cbShowTagsWithMultiValuesOnly;
+
+ protected JPanel buildInfoPanel() {
+ JPanel pnl = new JPanel();
+ pnl.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
+ pnl.setLayout(new GridBagLayout());
+ GridBagConstraints gc = new GridBagConstraints();
+ gc.fill = GridBagConstraints.BOTH;
+ gc.weighty = 1.0;
+ gc.weightx = 1.0;
+ gc.anchor = GridBagConstraints.LINE_START;
+ pnl.add(new JLabel(tr("Please select the values to keep for the following tags.")), gc);
+
+ gc.gridy = 1;
+ gc.fill = GridBagConstraints.HORIZONTAL;
+ gc.weighty = 0.0;
+ pnl.add(cbShowTagsWithConflictsOnly = new JCheckBox(tr("Show tags with conflicts only")), gc);
+ pnl.add(cbShowTagsWithMultiValuesOnly = new JCheckBox(tr("Show tags with multiple values only")), gc);
+ cbShowTagsWithConflictsOnly.addChangeListener(
+ new ChangeListener() {
+ public void stateChanged(ChangeEvent e) {
+ model.setShowTagsWithConflictsOnly(cbShowTagsWithConflictsOnly.isSelected());
+ cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
+ }
+ }
+ );
+ cbShowTagsWithConflictsOnly.setSelected(
+ Main.pref.getBoolean(getClass().getName() + ".showTagsWithConflictsOnly", false)
+ );
+ cbShowTagsWithMultiValuesOnly.addChangeListener(
+ new ChangeListener() {
+ public void stateChanged(ChangeEvent e) {
+ model.setShowTagsWithMultiValuesOnly(cbShowTagsWithMultiValuesOnly.isSelected());
+ }
+ }
+ );
+ cbShowTagsWithMultiValuesOnly.setSelected(
+ Main.pref.getBoolean(getClass().getName() + ".showTagsWithMultiValuesOnly", false)
+ );
+ cbShowTagsWithMultiValuesOnly.setEnabled(cbShowTagsWithConflictsOnly.isSelected());
+ return pnl;
+ }
+
+ /**
+ * Remembers the current settings in the global preferences
+ *
+ */
+ public void rememberPreferences() {
+ Main.pref.put(getClass().getName() + ".showTagsWithConflictsOnly", cbShowTagsWithConflictsOnly.isSelected());
+ Main.pref.put(getClass().getName() + ".showTagsWithMultiValuesOnly", cbShowTagsWithMultiValuesOnly.isSelected());
+ }
+
+ protected void build() {
+ setLayout(new BorderLayout());
+ add(buildInfoPanel(), BorderLayout.NORTH);
+ add(new JScrollPane(new MyTagConflictResolverTable(model)), BorderLayout.CENTER);
+ }
+
+ public MyTagConflictResolver() {
+ this.model = new MyTagConflictResolverModel();
+ build();
+ }
+
+ /**
+ * Replies the model used by this dialog
+ *
+ * @return the model
+ */
+ public MyTagConflictResolverModel getModel() {
+ return model;
+ }
+ }
+
+ public class MyTagConflictResolverTable extends JTable implements MultiValueCellEditor.NavigationListener {
+
+ private SelectNextColumnCellAction selectNextColumnCellAction;
+ private SelectPreviousColumnCellAction selectPreviousColumnCellAction;
+
+ public MyTagConflictResolverTable(MyTagConflictResolverModel model) {
+ super(model, new TagConflictResolverColumnModel());
+ build();
+ }
+
+ protected void build() {
+ setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
+ setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+ putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
+
+ // make ENTER behave like TAB
+ //
+ getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
+ KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0, false), "selectNextColumnCell");
+
+ // install custom navigation actions
+ //
+ selectNextColumnCellAction = new SelectNextColumnCellAction();
+ selectPreviousColumnCellAction = new SelectPreviousColumnCellAction();
+ getActionMap().put("selectNextColumnCell", selectNextColumnCellAction);
+ getActionMap().put("selectPreviousColumnCell", selectPreviousColumnCellAction);
+
+ ((MultiValueCellEditor)getColumnModel().getColumn(2).getCellEditor()).addNavigationListeners(this);
+
+ setRowHeight((int)new JComboBox().getPreferredSize().getHeight());
+ }
+
+ /**
+ * Action to be run when the user navigates to the next cell in the table, for instance by
+ * pressing TAB or ENTER. The action alters the standard navigation path from cell to cell:
+ * - it jumps over cells in the first column
- it automatically add a new empty row
+ * when the user leaves the last cell in the table
+ *
+ *
+ */
+ class SelectNextColumnCellAction extends AbstractAction {
+ public void actionPerformed(ActionEvent e) {
+ run();
+ }
+
+ public void run() {
+ int col = getSelectedColumn();
+ int row = getSelectedRow();
+ if (getCellEditor() != null) {
+ getCellEditor().stopCellEditing();
+ }
+
+ if (col == 2 && row < getRowCount() - 1) {
+ row++;
+ } else if (row < getRowCount() - 1) {
+ col = 2;
+ row++;
+ }
+ changeSelection(row, col, false, false);
+ editCellAt(getSelectedRow(), getSelectedColumn());
+ getEditorComponent().requestFocusInWindow();
+ }
+ }
+
+ /**
+ * Action to be run when the user navigates to the previous cell in the table, for instance by
+ * pressing Shift-TAB
+ *
+ */
+ class SelectPreviousColumnCellAction extends AbstractAction {
+
+ public void actionPerformed(ActionEvent e) {
+ run();
+ }
+
+ public void run() {
+ int col = getSelectedColumn();
+ int row = getSelectedRow();
+ if (getCellEditor() != null) {
+ getCellEditor().stopCellEditing();
+ }
+
+ if (col <= 0 && row <= 0) {
+ // change nothing
+ } else if (row > 0) {
+ col = 2;
+ row--;
+ }
+ changeSelection(row, col, false, false);
+ editCellAt(getSelectedRow(), getSelectedColumn());
+ getEditorComponent().requestFocusInWindow();
+ }
+ }
+
+ public void gotoNextDecision() {
+ selectNextColumnCellAction.run();
+ }
+
+ public void gotoPreviousDecision() {
+ selectPreviousColumnCellAction.run();
+ }
+ }
+}