Changeset 2655 in josm


Ignore:
Timestamp:
Dec 19, 2009 10:47:49 AM (3 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.