Changeset 30714 in osm for applications/editors/josm


Ignore:
Timestamp:
2014-10-12T12:37:13+02:00 (10 years ago)
Author:
donvip
Message:

[josm_merge_overlap] fix #josm10626 - fix ClassCastException

Location:
applications/editors/josm/plugins/merge-overlap
Files:
3 deleted
6 edited

Legend:

Unmodified
Added
Removed

  • applications/editors/josm/plugins/merge-overlap/.settings/org.eclipse.jdt.core.prefs

    r30416 r30714  
    77org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
    88org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
     9org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
    910org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
    1011org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
    … …  
    6263org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
    6364org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
    64 org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore
    65 org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
     65org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
     66org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=warning
    6667org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
    6768org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore

  • applications/editors/josm/plugins/merge-overlap/build.xml

    r30416 r30714  
    44    <property name="commit.message" value="MergeOverlap: help shortcut parser, rebuild"/>
    55    <!-- enter the *lowest* JOSM version this plugin is currently compatible with -->
    6     <property name="plugin.main.version" value="7001"/>
     6    <property name="plugin.main.version" value="7610"/>
    77   
    88    <!-- Configure these properties (replace "..." accordingly).

  • applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/hack/MyCombinePrimitiveResolverDialog.java

    r30712 r30714  
    4343import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecision;
    4444import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecisionType;
     45import org.openstreetmap.josm.gui.conflict.tags.TagConflictResolver;
     46import org.openstreetmap.josm.gui.conflict.tags.TagConflictResolverModel;
    4547import org.openstreetmap.josm.gui.help.ContextSensitiveHelpAction;
    4648import org.openstreetmap.josm.gui.help.HelpUtil;
    … …  
    9597
    9698    private AutoAdjustingSplitPane spTagConflictTypes;
    97     private MyTagConflictResolver pnlTagConflictResolver;
     99    private TagConflictResolver pnlTagConflictResolver;
    98100    private MyRelationMemberConflictResolver pnlRelationMemberConflictResolver;
    99101    private boolean cancelled;
    … …  
    162164
    163165    protected JPanel buildTagConflictResolverPanel() {
    164         pnlTagConflictResolver = new MyTagConflictResolver();
     166        pnlTagConflictResolver = new TagConflictResolver();
    165167        return pnlTagConflictResolver;
    166168    }
    … …  
    199201    }
    200202
    201     public MyTagConflictResolverModel getTagConflictResolverModel() {
     203    public TagConflictResolverModel getTagConflictResolverModel() {
    202204        return pnlTagConflictResolver.getModel();
    203205    }
    … …  
    208210
    209211    protected List<Command> buildTagChangeCommand(OsmPrimitive primitive, TagCollection tc) {
    210         LinkedList<Command> cmds = new LinkedList<Command>();
     212        LinkedList<Command> cmds = new LinkedList<>();
    211213        for (String key : tc.getKeys()) {
    212214            if (tc.hasUniqueEmptyValue(key)) {
    … …  
    225227
    226228    public List<Command> buildWayResolutionCommands() {
    227         List<Command> cmds = new LinkedList<Command>();
     229        List<Command> cmds = new LinkedList<>();
    228230
    229231        TagCollection allResolutions = getTagConflictResolverModel().getAllResolutions();
    … …  
    248250   
    249251    protected void prepareDefaultTagDecisions() {
    250         MyTagConflictResolverModel model = getTagConflictResolverModel();
     252        TagConflictResolverModel model = getTagConflictResolverModel();
    251253        for (int i = 0; i < model.getRowCount(); i++) {
    252254            MultiValueResolutionDecision decision = model.getDecision(i);
    … …  
    264266    protected void prepareDefaultRelationDecisions() {
    265267        MyRelationMemberConflictResolverModel model = getRelationMemberConflictResolverModel();
    266         Set<Relation> relations = new HashSet<Relation>();
     268        Set<Relation> relations = new HashSet<>();
    267269        for (int i = 0; i < model.getNumDecisions(); i++) {
    268270            RelationMemberConflictDecision decision = model.getDecision(i);
    … …  
    291293    protected void prepareGUIBeforeConflictResolutionStarts() {
    292294        MyRelationMemberConflictResolverModel relModel = getRelationMemberConflictResolverModel();
    293         MyTagConflictResolverModel tagModel = getTagConflictResolverModel();
     295        TagConflictResolverModel tagModel = getTagConflictResolverModel();
    294296        getContentPane().removeAll();
    295297
    … …  
    382384        @Override
    383385        public void propertyChange(PropertyChangeEvent evt) {
    384             if (evt.getPropertyName().equals(MyTagConflictResolverModel.NUM_CONFLICTS_PROP)) {
     386            if (evt.getPropertyName().equals(TagConflictResolverModel.NUM_CONFLICTS_PROP)) {
    385387                updateEnabledState();
    386388            }

  • applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/hack/MyRelationMemberConflictResolver.java

    r30712 r30714  
    3232import org.openstreetmap.josm.command.Command;
    3333import org.openstreetmap.josm.data.osm.OsmPrimitive;
     34import org.openstreetmap.josm.data.osm.Tag;
    3435import org.openstreetmap.josm.gui.tagging.ac.AutoCompletingTextField;
    3536import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionList;
    … …  
    4748    private JMultilineLabel lblHeader;
    4849
    49     protected void build() {
     50    protected final void build() {
    5051        setLayout(new GridBagLayout());
    5152        JPanel pnl = new JPanel();
    … …  
    105106        pnl.add(new JLabel(trc("tag", "Key:")));
    106107        pnl.add(tfKey = new AutoCompletingTextField(10));
    107         tfKey.setToolTipText(tr("<html>Enter a tag key, i.e. <strong><tt>fixme</tt></strong></html>"));
     108        tfKey.setToolTipText(tr("<html>Enter a tag key, e.g. <strong><tt>fixme</tt></strong></html>"));
    108109        pnl.add(new JLabel(tr("Value:")));
    109110        pnl.add(tfValue = new AutoCompletingTextField(10));
    110         tfValue.setToolTipText(tr("<html>Enter a tag value, i.e. <strong><tt>check members</tt></strong></html>"));
     111        tfValue.setToolTipText(tr("<html>Enter a tag value, e.g. <strong><tt>check members</tt></strong></html>"));
    111112        cbTagRelations.setSelected(false);
    112113        tfKey.setEnabled(false);
    … …  
    115116    }
    116117
     118    /**
     119     * Constructs a new {@code MyRelationMemberConflictResolver}.
     120     */
    117121    public MyRelationMemberConflictResolver() {
    118122        build();
    119123    }
    120124
     125    /**
     126     * Initializes for way combining.
     127     */
    121128    public void initForWayCombining() {
    122         lblHeader.setText(tr("<html>The combined ways are members in one ore more relations. "
     129        lblHeader.setText(tr("<html>The combined ways are members in one or more relations. "
    123130                + "Please decide whether you want to <strong>keep</strong> these memberships "
    124131                + "for the combined way or whether you want to <strong>remove</strong> them.<br>"
    … …  
    130137    }
    131138
     139    /**
     140     * Initializes for node merging.
     141     */
    132142    public void initForNodeMerging() {
    133         lblHeader.setText(tr("<html>The merged nodes are members in one ore more relations. "
     143        lblHeader.setText(tr("<html>The merged nodes are members in one or more relations. "
    134144                + "Please decide whether you want to <strong>keep</strong> these memberships "
    135145                + "for the target node or whether you want to <strong>remove</strong> them.<br>"
    … …  
    174184        if (!cbTagRelations.isSelected())
    175185            return null;
    176         if (tfKey.getText().trim().equals(""))
    177             return null;
    178         if (tfValue.getText().trim().equals(""))
     186        if (tfKey.getText().trim().isEmpty())
     187            return null;
     188        if (tfValue.getText().trim().isEmpty())
    179189            return null;
    180190        if (primitives == null || primitives.isEmpty())
    181191            return null;
    182         return new ChangePropertyCommand(primitives, tfKey.getText(), tfValue.getText());
     192        return new ChangePropertyCommand(primitives, Tag.removeWhiteSpaces(tfKey.getText()), Tag.removeWhiteSpaces(tfValue.getText()));
    183193    }
    184194

  • applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/hack/MyRelationMemberConflictResolverModel.java

    r30713 r30714  
    2323import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecision;
    2424import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictDecisionType;
     25import org.openstreetmap.josm.gui.util.GuiHelper;
    2526
    2627/**
    27      * This model manages a list of conflicting relation members.
    28      *
    29      * It can be used as {@see TableModel}.
    30      *
    31      *
    32      */
    33     public class MyRelationMemberConflictResolverModel extends DefaultTableModel {
    34         /** the property name for the number conflicts managed by this model */
    35         static public final String NUM_CONFLICTS_PROP = MyRelationMemberConflictResolverModel.class.getName() + ".numConflicts";
    36 
    37         /** the list of conflict decisions */
    38         private List<RelationMemberConflictDecision> decisions;
    39         /** the collection of relations for which we manage conflicts */
    40         private Collection<Relation> relations;
    41         /** the number of conflicts */
    42         private int numConflicts;
    43         private PropertyChangeSupport support;
    44 
    45         /**
    46          * Replies the current number of conflicts
    47          *
    48          * @return the current number of conflicts
    49          */
    50         public int getNumConflicts() {
    51             return numConflicts;
    52         }
    53 
    54         /**
    55          * Updates the current number of conflicts from list of decisions and emits
    56          * a property change event if necessary.
    57          *
    58          */
    59         protected void updateNumConflicts() {
    60             int count = 0;
    61             for (RelationMemberConflictDecision decision: decisions) {
    62                 if (!decision.isDecided()) {
    63                     count++;
     28 * This model manages a list of conflicting relation members.
     29 *
     30 * It can be used as {@link javax.swing.table.TableModel}.
     31 */
     32public class MyRelationMemberConflictResolverModel extends DefaultTableModel {
     33    /** the property name for the number conflicts managed by this model */
     34    public static final String NUM_CONFLICTS_PROP = MyRelationMemberConflictResolverModel.class.getName() + ".numConflicts";
     35
     36    /** the list of conflict decisions */
     37    private List<RelationMemberConflictDecision> decisions;
     38    /** the collection of relations for which we manage conflicts */
     39    private Collection<Relation> relations;
     40    /** the number of conflicts */
     41    private int numConflicts;
     42    private PropertyChangeSupport support;
     43
     44    /**
     45     * Replies true if each {@link MultiValueResolutionDecision} is decided.
     46     *
     47     * @return true if each {@link MultiValueResolutionDecision} is decided; false
     48     * otherwise
     49     */
     50    public boolean isResolvedCompletely() {
     51        return numConflicts == 0;
     52    }
     53
     54    /**
     55     * Replies the current number of conflicts
     56     *
     57     * @return the current number of conflicts
     58     */
     59    public int getNumConflicts() {
     60        return numConflicts;
     61    }
     62
     63    /**
     64     * Updates the current number of conflicts from list of decisions and emits
     65     * a property change event if necessary.
     66     *
     67     */
     68    protected void updateNumConflicts() {
     69        int count = 0;
     70        for (RelationMemberConflictDecision decision: decisions) {
     71            if (!decision.isDecided()) {
     72                count++;
     73            }
     74        }
     75        int oldValue = numConflicts;
     76        numConflicts = count;
     77        if (numConflicts != oldValue) {
     78            support.firePropertyChange(NUM_CONFLICTS_PROP, oldValue, numConflicts);
     79        }
     80    }
     81
     82    public void addPropertyChangeListener(PropertyChangeListener l) {
     83        support.addPropertyChangeListener(l);
     84    }
     85
     86    public void removePropertyChangeListener(PropertyChangeListener l) {
     87        support.removePropertyChangeListener(l);
     88    }
     89
     90    public MyRelationMemberConflictResolverModel() {
     91        decisions = new ArrayList<>();
     92        support = new PropertyChangeSupport(this);
     93    }
     94
     95    @Override
     96    public int getRowCount() {
     97        return getNumDecisions();
     98    }
     99
     100    @Override
     101    public Object getValueAt(int row, int column) {
     102        if (decisions == null) return null;
     103
     104        RelationMemberConflictDecision d = decisions.get(row);
     105        switch(column) {
     106        case 0: /* relation */ return d.getRelation();
     107        case 1: /* pos */ return Integer.toString(d.getPos() + 1); // position in "user space" starting at 1
     108        case 2: /* role */ return d.getRole();
     109        case 3: /* original */ return d.getOriginalPrimitive();
     110        case 4: /* decision */ return d.getDecision();
     111        }
     112        return null;
     113    }
     114
     115    @Override
     116    public void setValueAt(Object value, int row, int column) {
     117        RelationMemberConflictDecision d = decisions.get(row);
     118        switch(column) {
     119        case 2: /* role */
     120            d.setRole((String)value);
     121            break;
     122        case 4: /* decision */
     123            d.decide((RelationMemberConflictDecisionType)value);
     124            refresh();
     125            break;
     126        }
     127        fireTableDataChanged();
     128    }
     129
     130    /**
     131     * Populates the model with the members of the relation <code>relation</code>
     132     * referring to <code>primitive</code>.
     133     *
     134     * @param relation the parent relation
     135     * @param primitive the child primitive
     136     */
     137    protected void populate(Relation relation, OsmPrimitive primitive, Map<Way, Way> oldWays) {
     138        for (int i =0; i<relation.getMembersCount();i++) {
     139            if (MergeOverlapAction.getOld(relation.getMember(i).getWay(), oldWays) == MergeOverlapAction.getOld((Way)primitive, oldWays)) {
     140                decisions.add(new RelationMemberConflictDecision(relation, i));
     141            }
     142        }
     143    }
     144
     145    /**
     146     * Populates the model with the relation members belonging to one of the relations in <code>relations</code>
     147     * and referring to one of the primitives in <code>memberPrimitives</code>.
     148     *
     149     * @param relations  the parent relations. Empty list assumed if null.
     150     * @param memberPrimitives the child primitives. Empty list assumed if null.
     151     */
     152    public void populate(Collection<Relation> relations, Collection<? extends OsmPrimitive> memberPrimitives, Map<Way, Way> oldWays) {
     153        decisions.clear();
     154        relations = relations == null ? new LinkedList<Relation>() : relations;
     155        memberPrimitives = memberPrimitives == null ? new LinkedList<OsmPrimitive>() : memberPrimitives;
     156        for (Relation r : relations) {
     157            for (OsmPrimitive p: memberPrimitives) {
     158                populate(r, p, oldWays);
     159            }
     160        }
     161        this.relations = relations;
     162        refresh();
     163    }
     164
     165    /**
     166     * Populates the model with the relation members represented as a collection of
     167     * {@link RelationToChildReference}s.
     168     *
     169     * @param references the references. Empty list assumed if null.
     170     */
     171    public void populate(Collection<RelationToChildReference> references) {
     172        references = references == null ? new LinkedList<RelationToChildReference>() : references;
     173        decisions.clear();
     174        this.relations = new HashSet<>(references.size());
     175        for (RelationToChildReference reference: references) {
     176            decisions.add(new RelationMemberConflictDecision(reference.getParent(), reference.getPosition()));
     177            relations.add(reference.getParent());
     178        }
     179        refresh();
     180    }
     181
     182    /**
     183     * Replies the decision at position <code>row</code>
     184     *
     185     * @param row
     186     * @return the decision at position <code>row</code>
     187     */
     188    public RelationMemberConflictDecision getDecision(int row) {
     189        return decisions.get(row);
     190    }
     191
     192    /**
     193     * Replies the number of decisions managed by this model
     194     *
     195     * @return the number of decisions managed by this model
     196     */
     197    public int getNumDecisions() {
     198        return decisions == null ? 0 : decisions.size();
     199    }
     200
     201    /**
     202     * Refreshes the model state. Invoke this method to trigger necessary change
     203     * events after an update of the model data.
     204     *
     205     */
     206    public void refresh() {
     207        updateNumConflicts();
     208        GuiHelper.runInEDTAndWait(new Runnable() {
     209            @Override public void run() {
     210                fireTableDataChanged();
     211            }
     212        });
     213    }
     214
     215    /**
     216     * Apply a role to all member managed by this model.
     217     *
     218     * @param role the role. Empty string assumed if null.
     219     */
     220    public void applyRole(String role) {
     221        role = role == null ? "" : role;
     222        for (RelationMemberConflictDecision decision : decisions) {
     223            decision.setRole(role);
     224        }
     225        refresh();
     226    }
     227
     228    protected RelationMemberConflictDecision getDecision(Relation relation, int pos) {
     229        for(RelationMemberConflictDecision decision: decisions) {
     230            if (decision.matches(relation, pos)) return decision;
     231        }
     232        return null;
     233    }
     234
     235    protected void buildResolveCorrespondance(Relation relation, OsmPrimitive newPrimitive, Map<Relation, Relation> newRelations, Map<Way, Way> oldWays) {
     236
     237        List<RelationMember> relationsMembers = relation.getMembers();
     238        Relation modifiedRelation = MergeOverlapAction.getNew(relation, newRelations);
     239        modifiedRelation.setMembers(null);
     240//      boolean isChanged = false;
     241        for (int i=0; i < relationsMembers.size(); i++) {
     242                RelationMember rm = relationsMembers.get(i);
     243//          RelationMember rm = relation.getMember(i);
     244//          RelationMember rmNew;
     245            RelationMemberConflictDecision decision = getDecision(relation, i);
     246            if (decision == null) {
     247                modifiedRelation.addMember(rm);
     248            } else {
     249                System.out.println(modifiedRelation);
     250                System.out.println(111);
     251                switch(decision.getDecision()) {
     252                case KEEP:
     253//                  modifiedRelation.removeMembersFor(newPrimitive);
     254                        System.out.println(222);
     255                        if (newPrimitive instanceof Way) {
     256                        modifiedRelation.addMember(new RelationMember(decision.getRole(), MergeOverlapAction.getOld((Way)newPrimitive, oldWays)));
     257                        }
     258                        else {
     259                                modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
     260                        }
     261//                  modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
     262                    break;
     263                case REMOVE:
     264                        System.out.println(333);
     265//                  modifiedRelation.removeMembersFor(rm.getMember());
     266//                  isChanged = true;
     267                    // do nothing
     268                    break;
     269                case UNDECIDED:
     270                    // FIXME: this is an error
     271                    break;
    64272                }
    65273            }
    66             int oldValue = numConflicts;
    67             numConflicts = count;
    68             if (numConflicts != oldValue) {
    69                 support.firePropertyChange(NUM_CONFLICTS_PROP, oldValue, numConflicts);
    70             }
    71         }
    72 
    73         public void addPropertyChangeListener(PropertyChangeListener l) {
    74             support.addPropertyChangeListener(l);
    75         }
    76 
    77         public void removePropertyChangeListener(PropertyChangeListener l) {
    78             support.removePropertyChangeListener(l);
    79         }
    80 
    81         public MyRelationMemberConflictResolverModel() {
    82             decisions = new ArrayList<>();
    83             support = new PropertyChangeSupport(this);
    84         }
    85 
    86         @Override
    87         public int getRowCount() {
    88             if (decisions == null) return 0;
    89             return decisions.size();
    90         }
    91 
    92         @Override
    93         public Object getValueAt(int row, int column) {
    94             if (decisions == null) return null;
    95 
    96             RelationMemberConflictDecision d = decisions.get(row);
    97             switch(column) {
    98             case 0: /* relation */ return d.getRelation();
    99             case 1: /* pos */ return Integer.toString(d.getPos() + 1); // position in "user space" starting at 1
    100             case 2: /* role */ return d.getRole();
    101             case 3: /* original */ return d.getOriginalPrimitive();
    102             case 4: /* decision */ return d.getDecision();
    103             }
    104             return null;
    105         }
    106 
    107         @Override
    108         public void setValueAt(Object value, int row, int column) {
    109             RelationMemberConflictDecision d = decisions.get(row);
    110             switch(column) {
    111             case 2: /* role */
    112                 d.setRole((String)value);
    113                 break;
    114             case 4: /* decision */
    115                 d.decide((RelationMemberConflictDecisionType)value);
    116                 refresh();
    117                 break;
    118             }
    119             fireTableDataChanged();
    120         }
    121 
    122         /**
    123          * Populates the model with the members of the relation <code>relation</code>
    124          * referring to <code>primitive</code>.
    125          *
    126          * @param relation the parent relation
    127          * @param primitive the child primitive
    128          */
    129         protected void populate(Relation relation, OsmPrimitive primitive, Map<Way, Way> oldWays) {
    130             for (int i = 0; i<relation.getMembersCount(); i++) {
    131                 if (MergeOverlapAction.getOld(relation.getMember(i).getWay(), oldWays) == MergeOverlapAction.getOld((Way)primitive, oldWays)) {
    132                     decisions.add(new RelationMemberConflictDecision(relation, i));
    133                 }
    134             }
    135         }
    136 
    137         /**
    138          * Populates the model with the relation members belonging to one of the relations in <code>relations</code>
    139          * and referring to one of the primitives in <code>memberPrimitives</code>.
    140          *
    141          * @param relations  the parent relations. Empty list assumed if null.
    142          * @param memberPrimitives the child primitives. Empty list assumed if null.
    143          */
    144         public void populate(Collection<Relation> relations, Collection<? extends OsmPrimitive> memberPrimitives, Map<Way, Way> oldWays) {
    145             decisions.clear();
    146                
    147             relations = relations == null ? new LinkedList<Relation>() : relations;
    148             memberPrimitives = memberPrimitives == null ? new LinkedList<OsmPrimitive>() : memberPrimitives;
    149             for (Relation r : relations) {
    150                 for (OsmPrimitive p: memberPrimitives) {
    151                     populate(r, p, oldWays);
    152                 }
    153             }
    154             this.relations = relations;
    155             refresh();
    156         }
    157 
    158         /**
    159          * Populates the model with the relation members represented as a collection of
    160          * {@see RelationToChildReference}s.
    161          *
    162          * @param references the references. Empty list assumed if null.
    163          */
    164         public void populate(Collection<RelationToChildReference> references) {
    165             references = references == null ? new LinkedList<RelationToChildReference>() : references;
    166             decisions.clear();
    167             this.relations = new HashSet<>(references.size());
    168             for (RelationToChildReference reference: references) {
    169                 decisions.add(new RelationMemberConflictDecision(reference.getParent(), reference.getPosition()));
    170                 relations.add(reference.getParent());
    171             }
    172             refresh();
    173         }
    174 
    175         /**
    176          * Replies the decision at position <code>row</code>
    177          *
    178          * @param row
    179          * @return the decision at position <code>row</code>
    180          */
    181         public RelationMemberConflictDecision getDecision(int row) {
    182             return decisions.get(row);
    183         }
    184 
    185         /**
    186          * Replies the number of decisions managed by this model
    187          *
    188          * @return the number of decisions managed by this model
    189          */
    190         public int getNumDecisions() {
    191             return  getRowCount();
    192         }
    193 
    194         /**
    195          * Refreshes the model state. Invoke this method to trigger necessary change
    196          * events after an update of the model data.
    197          *
    198          */
    199         public void refresh() {
    200             updateNumConflicts();
    201             fireTableDataChanged();
    202         }
    203 
    204         /**
    205          * Apply a role to all member managed by this model.
    206          *
    207          * @param role the role. Empty string assumed if null.
    208          */
    209         public void applyRole(String role) {
    210             role = role == null ? "" : role;
    211             for (RelationMemberConflictDecision decision : decisions) {
    212                 decision.setRole(role);
    213             }
    214             refresh();
    215         }
    216 
    217         protected RelationMemberConflictDecision getDecision(Relation relation, int pos) {
    218             for(RelationMemberConflictDecision decision: decisions) {
    219                 if (decision.matches(relation, pos)) return decision;
    220             }
    221             return null;
    222         }
    223 
    224         protected void buildResolveCorrespondance(Relation relation, OsmPrimitive newPrimitive, Map<Relation, Relation> newRelations, Map<Way, Way> oldWays) {
    225 
    226                 List<RelationMember> relationsMembers = relation.getMembers();
    227                 Relation modifiedRelation = MergeOverlapAction.getNew(relation, newRelations);
    228             modifiedRelation.setMembers(null);
    229 //            boolean isChanged = false;
    230             for (int i=0; i < relationsMembers.size(); i++) {
    231                 RelationMember rm = relationsMembers.get(i);
    232 //                RelationMember rm = relation.getMember(i);
    233 //                RelationMember rmNew;
    234                 RelationMemberConflictDecision decision = getDecision(relation, i);
    235                 if (decision == null) {
    236                     modifiedRelation.addMember(rm);
    237                 } else {
    238                         System.out.println(modifiedRelation);
    239                         System.out.println(111);
    240                     switch(decision.getDecision()) {
    241                     case KEEP:
    242 //                      modifiedRelation.removeMembersFor(newPrimitive);
    243                         System.out.println(222);
    244                         if (newPrimitive instanceof Way) {
    245                                 modifiedRelation.addMember(new RelationMember(decision.getRole(), MergeOverlapAction.getOld((Way)newPrimitive, oldWays)));
    246                         }
    247                         else {
    248                                 modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
    249                         }
    250 //                      modifiedRelation.addMember(new RelationMember(decision.getRole(), newPrimitive));
    251                         break;
    252                     case REMOVE:
    253                         System.out.println(333);
    254 //                      modifiedRelation.removeMembersFor(rm.getMember());
    255 //                        isChanged = true;
    256                         // do nothing
    257                         break;
    258                     case UNDECIDED:
    259                         // FIXME: this is an error
    260                         break;
    261                     }
    262                 }
    263             }
    264         }
    265 
    266         /**
    267          * Builds a collection of commands executing the decisions made in this model.
    268          *
    269          * @param newPrimitive the primitive which members shall refer to if the
    270          * decision is {@see RelationMemberConflictDecisionType#REPLACE}
    271          * @return a list of commands
    272          */
    273         public void buildRelationCorrespondance(OsmPrimitive newPrimitive, Map<Relation, Relation> newRelations, Map<Way, Way> oldWays) {
    274             for (Relation relation : relations) {
    275                 buildResolveCorrespondance(relation, newPrimitive, newRelations, oldWays);
    276             }
    277         }
    278 
    279         protected boolean isChanged(Relation relation, OsmPrimitive newPrimitive) {
    280             for (int i=0; i < relation.getMembersCount(); i++) {
    281                 RelationMemberConflictDecision decision = getDecision(relation, i);
    282                 if (decision == null) {
    283                     continue;
    284                 }
    285                 switch(decision.getDecision()) {
    286                 case REMOVE: return true;
    287                 case KEEP:
    288                     if (!relation.getMember(i).getRole().equals(decision.getRole()))
    289                         return true;
    290                     if (relation.getMember(i).getMember() != newPrimitive)
    291                         return true;
    292                 case UNDECIDED:
    293                     // FIXME: handle error
    294                 }
    295             }
    296             return false;
    297         }
    298 
    299         /**
    300          * Replies the set of relations which have to be modified according
    301          * to the decisions managed by this model.
    302          *
    303          * @param newPrimitive the primitive which members shall refer to if the
    304          * decision is {@see RelationMemberConflictDecisionType#REPLACE}
    305          *
    306          * @return the set of relations which have to be modified according
    307          * to the decisions managed by this model
    308          */
    309         public Set<Relation> getModifiedRelations(OsmPrimitive newPrimitive) {
    310             HashSet<Relation> ret = new HashSet<>();
    311             for (Relation relation: relations) {
    312                 if (isChanged(relation, newPrimitive)) {
    313                     ret.add(relation);
    314                 }
    315             }
    316             return ret;
    317         }
    318     }
     274        }
     275    }
     276
     277    /**
     278     * Builds a collection of commands executing the decisions made in this model.
     279     *
     280     * @param newPrimitive the primitive which members shall refer to if the
     281     * decision is {@see RelationMemberConflictDecisionType#REPLACE}
     282     * @return a list of commands
     283     */
     284    public void buildRelationCorrespondance(OsmPrimitive newPrimitive, Map<Relation, Relation> newRelations, Map<Way, Way> oldWays) {
     285        for (Relation relation : relations) {
     286                buildResolveCorrespondance(relation, newPrimitive, newRelations, oldWays);
     287        }
     288    }
     289
     290    protected boolean isChanged(Relation relation, OsmPrimitive newPrimitive) {
     291        for (int i=0; i < relation.getMembersCount(); i++) {
     292            RelationMemberConflictDecision decision = getDecision(relation, i);
     293            if (decision == null) {
     294                continue;
     295            }
     296            switch(decision.getDecision()) {
     297            case REMOVE: return true;
     298            case KEEP:
     299                if (!relation.getMember(i).getRole().equals(decision.getRole()))
     300                    return true;
     301                if (relation.getMember(i).getMember() != newPrimitive)
     302                    return true;
     303            case UNDECIDED:
     304                // FIXME: handle error
     305            }
     306        }
     307        return false;
     308    }
     309
     310    /**
     311     * Replies the set of relations which have to be modified according
     312     * to the decisions managed by this model.
     313     *
     314     * @param newPrimitive the primitive which members shall refer to if the
     315     * decision is {@see RelationMemberConflictDecisionType#REPLACE}
     316     *
     317     * @return the set of relations which have to be modified according
     318     * to the decisions managed by this model
     319     */
     320    public Set<Relation> getModifiedRelations(OsmPrimitive newPrimitive) {
     321        HashSet<Relation> ret = new HashSet<>();
     322        for (Relation relation: relations) {
     323            if (isChanged(relation, newPrimitive)) {
     324                ret.add(relation);
     325            }
     326        }
     327        return ret;
     328    }
     329}

  • applications/editors/josm/plugins/merge-overlap/src/mergeoverlap/hack/MyRelationMemberConflictResolverTable.java

    r30713 r30714  
    66
    77import javax.swing.AbstractAction;
    8 import javax.swing.JComboBox;
    98import javax.swing.JComponent;
    109import javax.swing.JTable;
    … …  
    1413import org.openstreetmap.josm.gui.conflict.tags.MultiValueCellEditor;
    1514import org.openstreetmap.josm.gui.conflict.tags.RelationMemberConflictResolverColumnModel;
     15import org.openstreetmap.josm.gui.widgets.JosmComboBox;
    1616
    1717public class MyRelationMemberConflictResolverTable extends JTable implements MultiValueCellEditor.NavigationListener {
    … …  
    2525    }
    2626
    27     protected void build() {
     27    protected final void build() {
    2828        setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
    2929        setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    … …  
    4242        getActionMap().put("selectPreviousColumnCell", selectPreviousColumnCellAction);
    4343
    44         setRowHeight((int)new JComboBox<>().getPreferredSize().getHeight());
     44        setRowHeight((int)new JosmComboBox<String>().getPreferredSize().getHeight());
    4545    }
    4646
    … …  
    4949     * pressing TAB or ENTER. The action alters the standard navigation path from cell to cell: <ul>
    5050     * <li>it jumps over cells in the first column</li> <li>it automatically add a new empty row
    51      * when the user leaves the last cell in the table</li> <ul>
     51     * when the user leaves the last cell in the table</li></ul>
    5252     *
    5353     *
Note: See TracChangeset for help on using the changeset viewer.