Changeset 2655 in josm


Ignore:
Timestamp:
2009-12-19T10:47:49+01:00 (11 years ago)
Author:
jttt
Message:

Fixed #4161 Major slowdown in recent versions, used correct pattern for listeners realized using CopyOnWriteArrayList

Location:
trunk/src/org/openstreetmap/josm
Files:
1 added
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r2558 r2655  
    3030import java.util.Map;
    3131import java.util.Set;
    32 import java.util.logging.Logger;
    3332
    3433import javax.swing.JComponent;
     
    6261 */
    6362public class DrawAction extends MapMode implements MapViewPaintable, SelectionChangedListener, AWTEventListener {
    64     static private final Logger logger = Logger.getLogger(DrawAction.class.getName());
     63    //static private final Logger logger = Logger.getLogger(DrawAction.class.getName());
    6564
    6665    final private Cursor cursorCrosshair;
     
    7069    private Cursors currCursor = Cursors.crosshair;
    7170
    72     private static Node lastUsedNode = null;
     71    private Node lastUsedNode = null;
    7372    private double PHI=Math.toRadians(90);
    7473
     
    119118        if(currCursor.equals(c) || (!drawTargetCursor && currCursor.equals(Cursors.crosshair)))
    120119            return;
    121         try {
    122             // We invoke this to prevent strange things from happening
    123             EventQueue.invokeLater(new Runnable() {
    124                 public void run() {
    125                     // Don't change cursor when mode has changed already
    126                     if(!(Main.map.mapMode instanceof DrawAction))
    127                         return;
    128                     switch(c) {
    129                     case way:
    130                         Main.map.mapView.setCursor(cursorJoinWay);
    131                         break;
    132                     case node:
    133                         Main.map.mapView.setCursor(cursorJoinNode);
    134                         break;
    135                     default:
    136                         Main.map.mapView.setCursor(cursorCrosshair);
    137                         break;
    138                     }
    139                 }
    140             });
    141             currCursor = c;
    142         } catch(Exception e) {}
     120        // We invoke this to prevent strange things from happening
     121        EventQueue.invokeLater(new Runnable() {
     122            public void run() {
     123                // Don't change cursor when mode has changed already
     124                if(!(Main.map.mapMode instanceof DrawAction))
     125                    return;
     126                switch(c) {
     127                case way:
     128                    Main.map.mapView.setCursor(cursorJoinWay);
     129                    break;
     130                case node:
     131                    Main.map.mapView.setCursor(cursorJoinNode);
     132                    break;
     133                default:
     134                    Main.map.mapView.setCursor(cursorCrosshair);
     135                    break;
     136                }
     137            }
     138        });
     139        currCursor = c;
    143140    }
    144141
     
    975972         */
    976973        if (getCurrentDataSet() != null && getCurrentDataSet().getSelectedWays().size() > 0 && !wayIsFinished && !alt) {
    977             Way w = (Way) getCurrentDataSet().getSelectedWays().iterator().next();
     974            Way w = getCurrentDataSet().getSelectedWays().iterator().next();
    978975            for (Node m : w.getNodes()) {
    979976                if (m.equals(mouseOnExistingNode) || mouseOnExistingWays.contains(w)) {
  • trunk/src/org/openstreetmap/josm/data/Preferences.java

    r2645 r2655  
    2626import java.util.Map.Entry;
    2727import java.util.concurrent.CopyOnWriteArrayList;
    28 import java.util.logging.Logger;
    2928import java.util.regex.Matcher;
    3029import java.util.regex.Pattern;
     
    4443 */
    4544public class Preferences {
    46     static private final Logger logger = Logger.getLogger(Preferences.class.getName());
     45    //static private final Logger logger = Logger.getLogger(Preferences.class.getName());
    4746
    4847    /**
     
    131130
    132131    public void addPreferenceChangeListener(PreferenceChangedListener listener) {
    133         if (listener != null && ! listeners.contains(listener)) {
    134             listeners.add(listener);
     132        if (listener != null) {
     133            listeners.addIfAbsent(listener);
    135134        }
    136135    }
    137136
    138137    public void removePreferenceChangeListener(PreferenceChangedListener listener) {
    139         if (listener != null && listeners.contains(listener)) {
    140             listeners.remove(listener);
    141         }
     138        listeners.remove(listener);
    142139    }
    143140
  • trunk/src/org/openstreetmap/josm/data/conflict/ConflictCollection.java

    r2512 r2655  
    4242
    4343    public void addConflictListener(IConflictListener listener) {
    44         if (listener != null && ! listeners.contains(listener)) {
    45             listeners.add(listener);
     44        if (listener != null) {
     45            listeners.addIfAbsent(listener);
    4646        }
    4747    }
    4848
    4949    public void removeConflictListener(IConflictListener listener) {
    50         if (listener != null) {
    51             listeners.remove(listener);
    52         }
     50        listeners.remove(listener);
    5351    }
    5452
  • trunk/src/org/openstreetmap/josm/data/osm/ChangesetCache.java

    r2618 r2655  
    88import java.util.Map;
    99import java.util.concurrent.CopyOnWriteArrayList;
    10 import java.util.logging.Logger;
    1110
    1211import org.openstreetmap.josm.Main;
     
    1514
    1615public class ChangesetCache implements PreferenceChangedListener{
    17     static private final Logger logger = Logger.getLogger(ChangesetCache.class.getName());
     16    //static private final Logger logger = Logger.getLogger(ChangesetCache.class.getName());
    1817    static private final ChangesetCache instance = new ChangesetCache();
    1918
     
    3231
    3332    public void addChangesetCacheListener(ChangesetCacheListener listener) {
    34         synchronized(listeners) {
    35             if (listener != null && ! listeners.contains(listener)) {
    36                 listeners.add(listener);
    37             }
     33        if (listener != null) {
     34            listeners.addIfAbsent(listener);
    3835        }
    3936    }
    4037
    4138    public void removeChangesetCacheListener(ChangesetCacheListener listener) {
    42         synchronized(listeners) {
    43             if (listener != null && listeners.contains(listener)) {
    44                 listeners.remove(listener);
    45             }
    46         }
     39        listeners.remove(listener);
    4740    }
    4841
  • trunk/src/org/openstreetmap/josm/data/osm/DataSet.java

    r2623 r2655  
    2121import org.openstreetmap.josm.data.SelectionChangedListener;
    2222import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
     23import org.openstreetmap.josm.data.osm.event.ChangesetIdChangedEvent;
    2324import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
    2425import org.openstreetmap.josm.data.osm.event.DataSetListener;
     
    863864    }
    864865
     866    void fireChangesetIdChanged(OsmPrimitive primitive, int oldChangesetId, int newChangesetId) {
     867        fireEvent(new ChangesetIdChangedEvent(this, Collections.singletonList(primitive), oldChangesetId, newChangesetId));
     868    }
     869
    865870    public void clenupDeletedPrimitives() {
    866871        if (cleanupDeleted(nodes.iterator())
  • trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r2651 r2655  
    649649     */
    650650    public void setChangesetId(int changesetId) throws IllegalStateException, IllegalArgumentException {
     651        if (this.changesetId == changesetId)
     652            return;
    651653        if (changesetId < 0)
    652654            throw new IllegalArgumentException(tr("Parameter ''{0}'' >= 0 expected, got {1}", "changesetId", changesetId));
    653655        if (isNew() && changesetId > 0)
    654656            throw new IllegalStateException(tr("Can''t assign a changesetId > 0 to a new primitive. Value of changesetId is {0}", changesetId));
     657        int old = this.changesetId;
    655658        this.changesetId = changesetId;
     659        if (dataSet != null) {
     660            dataSet.fireChangesetIdChanged(this, old, changesetId);
     661        }
    656662    }
    657663
     
    10031009        flags = other.flags;
    10041010        user= other.user;
    1005         changesetId = other.changesetId;
     1011        setChangesetId(other.changesetId);
    10061012        clearCached();
    10071013    }
     
    10311037        flags = other.flags;
    10321038        user= other.user;
    1033         changesetId = other.changesetId;
     1039        setChangesetId(other.changesetId);
    10341040    }
    10351041
     
    11781184        timestamp = data.getTimestamp();
    11791185        user = data.getUser();
    1180         changesetId = data.getChangesetId();
     1186        setChangesetId(data.getChangesetId());
    11811187        setDeleted(data.isDeleted());
    11821188        setModified(data.isModified());
  • trunk/src/org/openstreetmap/josm/data/osm/event/AbstractDatasetChangedEvent.java

    r2645 r2655  
    1111
    1212    public enum DatasetEventType {DATA_CHANGED, NODE_MOVED, PRIMITIVES_ADDED, PRIMITIVES_REMOVED,
    13         RELATION_MEMBERS_CHANGED, TAGS_CHANGED, WAY_NODES_CHANGED}
     13        RELATION_MEMBERS_CHANGED, TAGS_CHANGED, WAY_NODES_CHANGED, CHANGESET_ID_CHANGED}
    1414
    1515    protected final DataSet dataSet;
  • trunk/src/org/openstreetmap/josm/data/osm/event/DataSetListener.java

    r2622 r2655  
    7373
    7474    /**
     75     * Minor dataset change, currently only changeset id changed is supported, but can
     76     * be extended in future.
     77     * @param event
     78     */
     79    void otherDatasetChange(AbstractDatasetChangedEvent event);
     80
     81    /**
    7582     * Called after big changes in dataset. Usually other events are stopped using Dataset.beginUpdate() and
    7683     * after operation is completed (Dataset.endUpdate()), {@link #dataChanged()} is called.
    7784     */
    7885    void dataChanged(DataChangedEvent event);
    79 
    8086}
  • trunk/src/org/openstreetmap/josm/data/osm/event/DataSetListenerAdapter.java

    r2645 r2655  
    4848    }
    4949
     50    public void otherDatasetChange(AbstractDatasetChangedEvent event) {
     51        listener.processDatasetEvent(event);
     52    }
     53
    5054}
  • trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java

    r2512 r2655  
    77import java.util.HashMap;
    88import java.util.concurrent.CopyOnWriteArrayList;
    9 import java.util.logging.Logger;
    109
    1110import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     
    1918 */
    2019public class HistoryDataSet {
    21     private final static Logger logger = Logger.getLogger(HistoryDataSet.class.getName());
     20    //private final static Logger logger = Logger.getLogger(HistoryDataSet.class.getName());
    2221
    2322    /** the unique instance */
     
    4645
    4746    public void addHistoryDataSetListener(HistoryDataSetListener listener) {
    48         synchronized(listeners) {
    49             if (!listeners.contains(listener)) {
    50                 listeners.add(listener);
    51             }
     47        if (listener != null) {
     48            listeners.addIfAbsent(listener);
    5249        }
    5350    }
    5451
    5552    public void removeHistoryDataSetListener(HistoryDataSetListener listener) {
    56         synchronized(listeners) {
    57             if (listeners.contains(listener)) {
    58                 listeners.remove(listener);
    59             }
    60         }
     53        listeners.remove(listener);
    6154    }
    6255
  • trunk/src/org/openstreetmap/josm/gui/MapFrame.java

    r2629 r2655  
    99import java.awt.event.MouseWheelListener;
    1010import java.util.ArrayList;
    11 import java.util.Collection;
    1211import java.util.List;
    1312import java.util.concurrent.CopyOnWriteArrayList;
     
    334333     * the mapMode listeners
    335334     */
    336     private static final Collection<MapModeChangeListener> mapModeChangeListeners = new CopyOnWriteArrayList<MapModeChangeListener>();
    337      /**
     335    private static final CopyOnWriteArrayList<MapModeChangeListener> mapModeChangeListeners = new CopyOnWriteArrayList<MapModeChangeListener>();
     336    /**
    338337     * Adds a mapMode change listener
    339338     *
     
    341340     */
    342341    public static void addMapModeChangeListener(MapModeChangeListener listener) {
    343         if (listener != null && ! mapModeChangeListeners.contains(listener)) {
    344             mapModeChangeListeners.add(listener);
     342        if (listener != null) {
     343            mapModeChangeListeners.addIfAbsent(listener);
    345344        }
    346345    }
     
    351350     */
    352351    public static void removeMapModeChangeListener(MapModeChangeListener listener) {
    353         if (listener != null && mapModeChangeListeners.contains(listener)) {
    354             mapModeChangeListeners.remove(listener);
    355         }
     352        mapModeChangeListeners.remove(listener);
    356353    }
    357354
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r2654 r2655  
    8383     * the layer listeners
    8484     */
    85     private static final Collection<MapView.LayerChangeListener> layerChangeListeners = new CopyOnWriteArrayList<MapView.LayerChangeListener>();
    86     private static final Collection<EditLayerChangeListener> editLayerChangeListeners = new CopyOnWriteArrayList<EditLayerChangeListener>();
     85    private static final CopyOnWriteArrayList<MapView.LayerChangeListener> layerChangeListeners = new CopyOnWriteArrayList<MapView.LayerChangeListener>();
     86    private static final CopyOnWriteArrayList<EditLayerChangeListener> editLayerChangeListeners = new CopyOnWriteArrayList<EditLayerChangeListener>();
    8787
    8888    /**
     
    9292     */
    9393    public static void removeLayerChangeListener(MapView.LayerChangeListener listener) {
    94         if (listener != null && layerChangeListeners.contains(listener)) {
    95             layerChangeListeners.remove(listener);
    96         }
     94        layerChangeListeners.remove(listener);
    9795    }
    9896
    9997    public static void removeEditLayerChangeListener(EditLayerChangeListener listener) {
    100         if (listener != null && editLayerChangeListeners.contains(listener)) {
    101             editLayerChangeListeners.remove(listener);
    102         }
     98        editLayerChangeListeners.remove(listener);
    10399    }
    104100
     
    111107     */
    112108    public static void addLayerChangeListener(MapView.LayerChangeListener listener) {
    113         if (listener != null && ! layerChangeListeners.contains(listener)) {
    114             layerChangeListeners.add(listener);
     109        if (listener != null) {
     110            layerChangeListeners.addIfAbsent(listener);
    115111        }
    116112    }
    117113
    118114    public static void addEditLayerChangeListener(EditLayerChangeListener listener) {
    119         if (listener != null && ! layerChangeListeners.contains(listener)) {
    120             editLayerChangeListeners.add(listener);
     115        if (listener != null) {
     116            editLayerChangeListeners.addIfAbsent(listener);
    121117        }
    122118    }
  • trunk/src/org/openstreetmap/josm/gui/conflict/tags/MultiValueCellEditor.java

    r2512 r2655  
    4545
    4646    public void addNavigationListeners(NavigationListener listener) {
    47         if (listener != null && ! (listeners.contains(listener))) {
    48             listeners.add(listener);
     47        if (listener != null) {
     48            listeners.addIfAbsent(listener);
    4949        }
    5050    }
    5151
    5252    public void removeavigationListeners(NavigationListener listener) {
    53         if (listener != null && listeners.contains(listener)) {
    54             listeners.remove(listener);
    55         }
     53        listeners.remove(listener);
    5654    }
    5755
     
    116114        }
    117115        switch(decision.getDecisionType()) {
    118             case UNDECIDED:
    119                 editor.setSelectedIndex(0);
    120                 break;
    121             case KEEP_ONE:
    122                 editor.setSelectedItem(decision.getChosenValue());
    123                 break;
    124             case KEEP_NONE:
    125                 editor.setSelectedItem(MultiValueDecisionType.KEEP_NONE);
    126                 break;
    127             case KEEP_ALL:
    128                 editor.setSelectedItem(MultiValueDecisionType.KEEP_ALL);
     116        case UNDECIDED:
     117            editor.setSelectedIndex(0);
     118            break;
     119        case KEEP_ONE:
     120            editor.setSelectedItem(decision.getChosenValue());
     121            break;
     122        case KEEP_NONE:
     123            editor.setSelectedItem(MultiValueDecisionType.KEEP_NONE);
     124            break;
     125        case KEEP_ALL:
     126            editor.setSelectedItem(MultiValueDecisionType.KEEP_ALL);
    129127        }
    130128    }
     
    167165            } else if (MultiValueDecisionType.class.isInstance(value)) {
    168166                switch(MultiValueDecisionType.class.cast(value)) {
    169                     case KEEP_NONE:
    170                         setText(tr("none"));
    171                         setFont(UIManager.getFont("ComboBox.font").deriveFont(Font.ITALIC + Font.BOLD));
    172                         break;
    173                     case KEEP_ALL:
    174                         setText(tr("all"));
    175                         setFont(UIManager.getFont("ComboBox.font").deriveFont(Font.ITALIC + Font.BOLD));
    176                         break;
    177                     default:
    178                         // don't display other values
     167                case KEEP_NONE:
     168                    setText(tr("none"));
     169                    setFont(UIManager.getFont("ComboBox.font").deriveFont(Font.ITALIC + Font.BOLD));
     170                    break;
     171                case KEEP_ALL:
     172                    setText(tr("all"));
     173                    setFont(UIManager.getFont("ComboBox.font").deriveFont(Font.ITALIC + Font.BOLD));
     174                    break;
     175                default:
     176                    // don't display other values
    179177                }
    180178            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r2621 r2655  
    1414import java.util.List;
    1515import java.util.Set;
    16 import java.util.logging.Logger;
    1716
    1817import javax.swing.AbstractAction;
     
    3534import org.openstreetmap.josm.data.osm.DataSet;
    3635import org.openstreetmap.josm.data.osm.OsmPrimitive;
     36import org.openstreetmap.josm.data.osm.event.DatasetEventManager;
    3737import org.openstreetmap.josm.gui.MapFrame;
    3838import org.openstreetmap.josm.gui.MapView;
     
    6161 */
    6262public class ChangesetDialog extends ToggleDialog{
    63     static private final Logger logger = Logger.getLogger(ChangesetDialog.class.getName());
     63    //static private final Logger logger = Logger.getLogger(ChangesetDialog.class.getName());
    6464
    6565    private ChangesetInSelectionListModel inSelectionModel;
     
    9898
    9999        ChangesetCache.getInstance().addChangesetCacheListener(inActiveDataLayerModel);
    100         MapView.addLayerChangeListener(inActiveDataLayerModel);
    101100
    102101        DblClickHandler dblClickHandler = new DblClickHandler();
     
    114113        MapView.removeLayerChangeListener(inSelectionModel);
    115114        DataSet.selListeners.remove(inSelectionModel);
    116         MapView.removeLayerChangeListener(inActiveDataLayerModel);
     115    }
     116
     117    @Override
     118    public void showNotify() {
     119        DatasetEventManager.getInstance().addDatasetListener(inActiveDataLayerModel, true);
     120    }
     121
     122    @Override
     123    public void hideNotify() {
     124        DatasetEventManager.getInstance().removeDatasetListener(inActiveDataLayerModel);
    117125    }
    118126
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r2621 r2655  
    4747import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    4848import org.openstreetmap.josm.gui.SideButton;
    49 import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    5049import org.openstreetmap.josm.gui.layer.Layer;
    5150import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     
    285284
    286285        public void addListDataListener(ListDataListener l) {
    287             if (l != null && ! listeners.contains(l)) {
    288                 listeners.add(l);
     286            if (l != null) {
     287                listeners.addIfAbsent(l);
    289288            }
    290289        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r2626 r2655  
    642642         */
    643643        public void addLayerListModelListener(LayerListModelListener listener) {
    644             synchronized(listeners) {
    645                 if (listener != null && !listeners.contains(listener)) {
    646                     listeners.add(listener);
    647                 }
     644            if (listener != null) {
     645                listeners.addIfAbsent(listener);
    648646            }
    649647        }
     
    655653         */
    656654        public void removeLayerListModelListener(LayerListModelListener listener) {
    657             synchronized(listeners) {
    658                 if (listener != null && listeners.contains(listener)) {
    659                     listeners.remove(listener);
    660                 }
    661             }
     655            listeners.remove(listener);
    662656        }
    663657
  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r2632 r2655  
    3636import org.openstreetmap.josm.data.osm.Relation;
    3737import org.openstreetmap.josm.data.osm.RelationMember;
     38import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
    3839import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
    3940import org.openstreetmap.josm.data.osm.event.DataSetListener;
     
    738739        }
    739740    }
     741
     742    public void otherDatasetChange(AbstractDatasetChangedEvent event) {/* ignore */}
    740743}
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetListModel.java

    r2616 r2655  
    99import java.util.List;
    1010import java.util.Set;
    11 import java.util.logging.Logger;
    1211
    1312import javax.swing.DefaultListModel;
     
    2019import org.openstreetmap.josm.data.osm.DataSet;
    2120import org.openstreetmap.josm.data.osm.OsmPrimitive;
     21import org.openstreetmap.josm.data.osm.Storage;
    2222
    2323public class ChangesetListModel extends DefaultListModel  implements ChangesetCacheListener{
    24     static private final Logger logger = Logger.getLogger(ChangesetListModel.class.getName());
     24    //static private final Logger logger = Logger.getLogger(ChangesetListModel.class.getName());
    2525
    2626    private final List<Changeset> data = new ArrayList<Changeset>();
     27    private final Storage<Changeset> shownChangesets = new Storage<Changeset>();
    2728    private DefaultListSelectionModel selectionModel;
    2829
     
    6364    }
    6465
     66    protected void addChangeset(Changeset changeset) {
     67        if (shownChangesets.add(changeset)) {
     68            setChangesets(shownChangesets);
     69            updateModel();
     70        }
     71    }
     72
     73    protected void removeChangeset(Changeset changeset) {
     74        if (shownChangesets.remove(changeset)) {
     75            setChangesets(shownChangesets);
     76            updateModel();
     77        }
     78    }
     79
    6580    protected void setChangesets(Collection<Changeset> changesets) {
     81        shownChangesets.clear();
     82        if (changesets != null) {
     83            shownChangesets.addAll(changesets);
     84        }
     85        updateModel();
     86    }
     87
     88    private void updateModel() {
    6689        Set<Changeset> sel = getSelectedChangesets();
    6790        data.clear();
    68         if (changesets == null) {
    69             fireContentsChanged(this, 0, getSize());
    70             return;
    71         }
    72         data.addAll(changesets);
     91        data.addAll(shownChangesets);
    7392        ChangesetCache cache = ChangesetCache.getInstance();
    7493        for (Changeset cs: data) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetsInActiveDataLayerListModel.java

    r2652 r2655  
    44import javax.swing.DefaultListSelectionModel;
    55
    6 import org.openstreetmap.josm.Main;
    7 import org.openstreetmap.josm.gui.MapView;
    8 import org.openstreetmap.josm.gui.layer.DataChangeListener;
    9 import org.openstreetmap.josm.gui.layer.Layer;
    10 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     6import org.openstreetmap.josm.data.osm.Changeset;
     7import org.openstreetmap.josm.data.osm.OsmPrimitive;
     8import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
     9import org.openstreetmap.josm.data.osm.event.ChangesetIdChangedEvent;
     10import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
     11import org.openstreetmap.josm.data.osm.event.DataSetListener;
     12import org.openstreetmap.josm.data.osm.event.NodeMovedEvent;
     13import org.openstreetmap.josm.data.osm.event.PrimitivesAddedEvent;
     14import org.openstreetmap.josm.data.osm.event.PrimitivesRemovedEvent;
     15import org.openstreetmap.josm.data.osm.event.RelationMembersChangedEvent;
     16import org.openstreetmap.josm.data.osm.event.TagsChangedEvent;
     17import org.openstreetmap.josm.data.osm.event.WayNodesChangedEvent;
    1118
    12 public class ChangesetsInActiveDataLayerListModel extends ChangesetListModel implements MapView.LayerChangeListener, DataChangeListener{
     19public class ChangesetsInActiveDataLayerListModel extends ChangesetListModel implements DataSetListener  {
    1320
    1421    public ChangesetsInActiveDataLayerListModel(DefaultListSelectionModel selectionModel) {
     
    1623    }
    1724
    18     /* ---------------------------------------------------------------------------- */
    19     /* Interface LayerChangeListener                                                */
    20     /* ---------------------------------------------------------------------------- */
    21     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    22         if (oldLayer != null && oldLayer instanceof OsmDataLayer) {
    23             OsmDataLayer l = (OsmDataLayer)oldLayer;
    24             l.listenerDataChanged.remove(this);
    25         }
    26         if (newLayer == null) {
    27             setChangesets(null);
    28         } else if (newLayer instanceof OsmDataLayer){
    29             OsmDataLayer l = (OsmDataLayer)newLayer;
    30             l.listenerDataChanged.add(this);
    31             initFromDataSet(l.data);
    32         } else {
    33             setChangesets(null);
     25    public void dataChanged(DataChangedEvent event) {
     26        initFromPrimitives(event.getPrimitives());
     27    }
     28
     29    public void nodeMoved(NodeMovedEvent event) {/* ignored */}
     30
     31    public void primtivesAdded(PrimitivesAddedEvent event) {
     32        for (OsmPrimitive primitive:event.getPrimitives()) {
     33            addChangeset(new Changeset(primitive.getChangesetId()));
    3434        }
    3535    }
    36     public void layerAdded(Layer newLayer) {}
    37     public void layerRemoved(Layer oldLayer) {}
    3836
    39     /* ---------------------------------------------------------------------------- */
    40     /* Interface DataChangeListener                                                 */
    41     /* ---------------------------------------------------------------------------- */
    42     public void dataChanged(OsmDataLayer l) {
    43         if (l == null) return;
    44         if (l != Main.main.getEditLayer()) return;
    45         initFromDataSet(l.data);
     37    public void primtivesRemoved(PrimitivesRemovedEvent event) {
     38        for (OsmPrimitive primitive:event.getPrimitives()) {
     39            removeChangeset(new Changeset(primitive.getChangesetId()));
     40        }
    4641    }
     42
     43    public void relationMembersChanged(RelationMembersChangedEvent event) {/* ignored */}
     44
     45    public void tagsChanged(TagsChangedEvent event) {/* ignored */}
     46
     47    public void otherDatasetChange(AbstractDatasetChangedEvent event) {
     48        if (event instanceof ChangesetIdChangedEvent) {
     49            ChangesetIdChangedEvent e = (ChangesetIdChangedEvent) event;
     50            removeChangeset(new Changeset(e.getOldChangesetId()));
     51            addChangeset(new Changeset(e.getNewChangesetId()));
     52        }
     53    }
     54
     55    public void wayNodesChanged(WayNodesChangedEvent event) {/* ignored */}
     56
    4757}
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTableModel.java

    r2622 r2655  
    3333import org.openstreetmap.josm.data.osm.RelationMember;
    3434import org.openstreetmap.josm.data.osm.Way;
     35import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
    3536import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
    3637import org.openstreetmap.josm.data.osm.event.DataSetListener;
     
    131132
    132133    public void wayNodesChanged(WayNodesChangedEvent event) {/* ignore */}
     134
     135    public void otherDatasetChange(AbstractDatasetChangedEvent event) {/* ignore */}
    133136    /* --------------------------------------------------------------------------- */
    134137
    135138    public void addMemberModelListener(IMemberModelListener listener) {
    136         synchronized (listeners) {
    137             if (listener != null && !listeners.contains(listener)) {
    138                 listeners.add(listener);
    139             }
     139        if (listener != null) {
     140            listeners.addIfAbsent(listener);
    140141        }
    141142    }
    142143
    143144    public void removeMemberModelListener(IMemberModelListener listener) {
    144         synchronized (listeners) {
    145             if (listener != null && listeners.contains(listener)) {
    146                 listeners.remove(listener);
    147             }
    148         }
     145        listeners.remove(listener);
    149146    }
    150147
    151148    protected void fireMakeMemberVisible(int index) {
    152         synchronized (listeners) {
    153             for (IMemberModelListener listener : listeners) {
    154                 listener.makeMemberVisible(index);
    155             }
     149        for (IMemberModelListener listener : listeners) {
     150            listener.makeMemberVisible(index);
    156151        }
    157152    }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationTreeModel.java

    r2578 r2655  
    44import java.util.List;
    55import java.util.concurrent.CopyOnWriteArrayList;
    6 import java.util.logging.Logger;
    76
    87import javax.swing.event.TreeModelEvent;
     
    2423 */
    2524public class RelationTreeModel implements TreeModel {
    26     private static final Logger logger = Logger.getLogger(RelationTreeModel.class.getName());
     25    //private static final Logger logger = Logger.getLogger(RelationTreeModel.class.getName());
    2726
    2827    /** the root relation */
     
    215214
    216215    public void addTreeModelListener(TreeModelListener l) {
    217         synchronized (listeners) {
    218             if (l != null && !listeners.contains(l)) {
    219                 listeners.add(l);
    220             }
     216        if (l != null) {
     217            listeners.addIfAbsent(l);
    221218        }
    222219    }
    223220
    224221    public void removeTreeModelListener(TreeModelListener l) {
    225         synchronized (listeners) {
    226             if (l != null && listeners.contains(l)) {
    227                 listeners.remove(l);
    228             }
    229         }
     222        listeners.remove(l);
    230223    }
    231224
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java

    r2626 r2655  
    2020import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
    2121import org.openstreetmap.josm.data.osm.Way;
     22import org.openstreetmap.josm.data.osm.event.AbstractDatasetChangedEvent;
    2223import org.openstreetmap.josm.data.osm.event.DataChangedEvent;
    2324import org.openstreetmap.josm.data.osm.event.DataSetListener;
     
    830831    }
    831832
     833    public void otherDatasetChange(AbstractDatasetChangedEvent event) {
     834        // Irrelevant
     835    }
     836
    832837    /* ---------------------------------------------------------------------- */
    833838    /* DataChangeListener                                                     */
  • trunk/src/org/openstreetmap/josm/gui/io/FilenameCellEditor.java

    r2512 r2655  
    7272
    7373    public void addCellEditorListener(CellEditorListener l) {
    74         if (!listeners.contains(l)) {
    75             listeners.add(l);
     74        if (l != null) {
     75            listeners.addIfAbsent(l);
    7676        }
    7777    }
     
    102102
    103103    public void removeCellEditorListener(CellEditorListener l) {
    104         if (listeners.contains(l)) {
    105             listeners.remove(l);
    106         }
     104        listeners.remove(l);
    107105    }
    108106
  • trunk/src/org/openstreetmap/josm/gui/io/SaveFlagCellEditor.java

    r2512 r2655  
    3737
    3838    public void addCellEditorListener(CellEditorListener l) {
    39         if (!listeners.contains(l)) {
    40             listeners.add(l);
     39        if (l != null) {
     40            listeners.addIfAbsent(l);
    4141        }
    4242    }
     
    6767
    6868    public void removeCellEditorListener(CellEditorListener l) {
    69         if (listeners.contains(l)) {
    70             listeners.remove(l);
    71         }
     69        listeners.remove(l);
    7270    }
    7371
     
    9088        SaveLayerInfo info = (SaveLayerInfo)value;
    9189        switch(column) {
    92             case 4: setInitialValue(info.isDoUploadToServer()); break;
    93             case 5: setInitialValue(info.isDoSaveToFile()); break;
     90        case 4: setInitialValue(info.isDoUploadToServer()); break;
     91        case 5: setInitialValue(info.isDoSaveToFile()); break;
    9492        }
    9593        return this;
  • trunk/src/org/openstreetmap/josm/gui/preferences/StyleSourceEditor.java

    r2626 r2655  
    859859
    860860        public void addCellEditorListener(CellEditorListener l) {
    861             if (!listeners.contains(l)) {
    862                 listeners.add(l);
     861            if (l != null) {
     862                listeners.addIfAbsent(l);
    863863            }
    864864        }
     
    891891
    892892        public void removeCellEditorListener(CellEditorListener l) {
    893             if (listeners.contains(l)) {
    894                 listeners.remove(l);
    895             }
     893            listeners.remove(l);
    896894        }
    897895
  • trunk/src/org/openstreetmap/josm/io/NmeaReader.java

    r2626 r2655  
    272272                        e[GPGGA.LONGITUDE.position]
    273273                );
    274                 if(latLon==null) throw(null); // malformed
     274                if(latLon==null)
     275                    throw new NullPointerException(); // malformed
    275276
    276277                if((latLon.lat()==0.0) && (latLon.lon()==0.0)) {
Note: See TracChangeset for help on using the changeset viewer.