Changeset 2621 in josm for trunk


Ignore:
Timestamp:
2009-12-12T17:51:39+01:00 (12 years ago)
Author:
Gubaer
Message:

Moved layer listener management from Layer to MapView
Made sure that listeners also unregister when they register for layer change events.

This will certainly break plugins. Plugin updates will follow later.

Location:
trunk/src/org/openstreetmap/josm
Files:
25 edited

Legend:

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

    r2512 r2621  
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1515import org.openstreetmap.josm.data.osm.PrimitiveDeepCopy;
     16import org.openstreetmap.josm.gui.MapView;
    1617import org.openstreetmap.josm.gui.layer.Layer;
    1718import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    18 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1919import org.openstreetmap.josm.tools.Destroyable;
    2020import org.openstreetmap.josm.tools.ImageProvider;
     
    9393            Main.contentPane.getActionMap().remove(sc.getKeyStroke());
    9494        }
    95         if (Layer.listeners != null) {
    96             Layer.listeners.remove(layerChangeAdapter);
    97         }
     95        MapView.removeLayerChangeListener(layerChangeAdapter);
    9896        if (DataSet.selListeners != null) {
    9997            DataSet.selListeners.remove(selectionChangeAdapter);
     
    146144        layerChangeAdapter = new LayerChangeAdapter();
    147145        selectionChangeAdapter = new SelectionChangeAdapter();
    148         Layer.listeners.add(layerChangeAdapter);
     146        MapView.addLayerChangeListener(layerChangeAdapter);
    149147        DataSet.selListeners.add(selectionChangeAdapter);
    150148        initEnabledState();
     
    195193     *
    196194     */
    197     private class LayerChangeAdapter implements LayerChangeListener {
     195    private class LayerChangeAdapter implements MapView.LayerChangeListener {
    198196        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    199197            updateEnabledState();
  • trunk/src/org/openstreetmap/josm/data/UndoRedoHandler.java

    r2552 r2621  
    44import java.util.Collection;
    55import java.util.Iterator;
    6 import java.util.List;
    76import java.util.LinkedList;
    87import java.util.Stack;
     
    109import org.openstreetmap.josm.Main;
    1110import org.openstreetmap.josm.command.Command;
    12 import org.openstreetmap.josm.data.osm.DataSet;
    1311import org.openstreetmap.josm.data.osm.OsmPrimitive;
     12import org.openstreetmap.josm.gui.MapView;
    1413import org.openstreetmap.josm.gui.layer.Layer;
    1514import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    16 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1715import org.openstreetmap.josm.gui.layer.OsmDataLayer.CommandQueueListener;
    1816
    19 public class UndoRedoHandler implements LayerChangeListener {
     17public class UndoRedoHandler implements MapView.LayerChangeListener {
    2018
    2119    /**
     
    3129
    3230    public UndoRedoHandler() {
    33         Layer.listeners.add(this);
     31        MapView.addLayerChangeListener(this);
    3432    }
    3533
  • trunk/src/org/openstreetmap/josm/gui/MainMenu.java

    r2575 r2621  
    77import static org.openstreetmap.josm.tools.I18n.tr;
    88
    9 import java.awt.event.ActionEvent;
    10 import java.awt.event.ActionListener;
    119import java.awt.event.KeyEvent;
    1210
     
    3331import org.openstreetmap.josm.actions.DuplicateAction;
    3432import org.openstreetmap.josm.actions.ExitAction;
     33import org.openstreetmap.josm.actions.FullscreenToggleAction;
    3534import org.openstreetmap.josm.actions.GpxExportAction;
    3635import org.openstreetmap.josm.actions.HelpAction;
    3736import org.openstreetmap.josm.actions.HistoryInfoAction;
    3837import org.openstreetmap.josm.actions.InfoAction;
     38import org.openstreetmap.josm.actions.JoinAreasAction;
    3939import org.openstreetmap.josm.actions.JoinNodeWayAction;
    40 import org.openstreetmap.josm.actions.JoinAreasAction;
    4140import org.openstreetmap.josm.actions.JosmAction;
    4241import org.openstreetmap.josm.actions.MergeLayerAction;
     
    6867import org.openstreetmap.josm.actions.UploadSelectionAction;
    6968import org.openstreetmap.josm.actions.WireframeToggleAction;
    70 import org.openstreetmap.josm.actions.FullscreenToggleAction;
    7169import org.openstreetmap.josm.actions.ZoomInAction;
    7270import org.openstreetmap.josm.actions.ZoomOutAction;
     
    8078import org.openstreetmap.josm.actions.search.SearchAction;
    8179import org.openstreetmap.josm.gui.layer.Layer;
    82 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    8380import org.openstreetmap.josm.tools.Shortcut;
    8481/**
     
    309306    }
    310307
    311     class PresetsMenuEnabler implements LayerChangeListener {
     308    class PresetsMenuEnabler implements MapView.LayerChangeListener {
    312309        private JMenu presetsMenu;
    313310        public PresetsMenuEnabler(JMenu presetsMenu) {
    314             Layer.listeners.add(this);
     311            MapView.addLayerChangeListener(this);
    315312            this.presetsMenu = presetsMenu;
    316313        }
  • trunk/src/org/openstreetmap/josm/gui/MapView.java

    r2617 r2621  
    2626import java.util.LinkedList;
    2727import java.util.List;
     28import java.util.concurrent.CopyOnWriteArrayList;
    2829
    2930import javax.swing.AbstractButton;
     
    6465 */
    6566public class MapView extends NavigatableComponent implements PropertyChangeListener {
     67
     68    /**
     69     * Interface to notify listeners of the change of the active layer.
     70     * @author imi
     71     */
     72    public interface LayerChangeListener {
     73        void activeLayerChange(Layer oldLayer, Layer newLayer);
     74        void layerAdded(Layer newLayer);
     75        void layerRemoved(Layer oldLayer);
     76    }
     77
     78    /**
     79     * the layer listeners
     80     */
     81    private static final Collection<MapView.LayerChangeListener> layerChangeListeners = new CopyOnWriteArrayList<MapView.LayerChangeListener>();
     82
     83    /**
     84     * Removes a layer change listener
     85     *
     86     * @param listener the listener. Ignored if null or already registered.
     87     */
     88    public static void removeLayerChangeListener(MapView.LayerChangeListener listener) {
     89        if (listener != null && layerChangeListeners.contains(listener)) {
     90            layerChangeListeners.remove(listener);
     91        }
     92    }
     93
     94    /**
     95     * Adds a layer change listener
     96     *
     97     * @param listener the listener. Ignored if null or already registered.
     98     */
     99    public static void addLayerChangeListener(MapView.LayerChangeListener listener) {
     100        if (listener != null && ! layerChangeListeners.contains(listener)) {
     101            layerChangeListeners.add(listener);
     102        }
     103    }
     104
     105    protected static void fireActiveLayerChanged(Layer oldLayer, Layer newLayer) {
     106        for (LayerChangeListener l : layerChangeListeners) {
     107            l.activeLayerChange(oldLayer, newLayer);
     108        }
     109    }
     110
     111    protected static void fireLayerAdded(Layer newLayer) {
     112        for (MapView.LayerChangeListener l : MapView.layerChangeListeners) {
     113            l.layerAdded(newLayer);
     114        }
     115    }
     116
     117    protected static void fireLayerRemoved(Layer layer) {
     118        for (MapView.LayerChangeListener l : MapView.layerChangeListeners) {
     119            l.layerRemoved(layer);
     120        }
     121    }
    66122
    67123    /**
     
    187243            layers.add(0, layer);
    188244        }
    189 
    190         for (Layer.LayerChangeListener l : Layer.listeners) {
    191             l.layerAdded(layer);
    192         }
     245        fireLayerAdded(layer);
    193246        if (layer instanceof OsmDataLayer || activeLayer == null) {
    194247            // autoselect the new layer
    195248            Layer old = activeLayer;
    196249            setActiveLayer(layer);
    197             for (Layer.LayerChangeListener l : Layer.listeners) {
    198                 l.activeLayerChange(old, layer);
    199             }
     250            fireActiveLayerChanged(old, layer);
    200251        }
    201252        layer.addPropertyChangeListener(this);
     
    229280    }
    230281
    231     protected void fireActiveLayerChanged(Layer oldLayer, Layer newLayer) {
    232         for (Layer.LayerChangeListener l : Layer.listeners) {
    233             l.activeLayerChange(oldLayer, newLayer);
    234         }
    235     }
    236282
    237283    /**
     
    272318        }
    273319        if (layers.remove(layer)) {
    274             for (Layer.LayerChangeListener l : Layer.listeners) {
    275                 l.layerRemoved(layer);
    276             }
     320            fireLayerRemoved(layer);
    277321        }
    278322        layer.removePropertyChangeListener(this);
     
    290334
    291335    private boolean virtualNodesEnabled = false;
     336
    292337    public void setVirtualNodesEnabled(boolean enabled) {
    293338        if(virtualNodesEnabled != enabled) {
     
    536581        activeLayer = layer;
    537582        if (old != layer) {
    538             for (Layer.LayerChangeListener l : Layer.listeners) {
    539                 l.activeLayerChange(old, layer);
    540             }
     583            fireActiveLayerChanged(old, layer);
    541584        }
    542585        if (layer instanceof OsmDataLayer) {
     
    650693        }
    651694    }
     695
    652696}
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ChangesetDialog.java

    r2616 r2621  
    3636import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3737import org.openstreetmap.josm.gui.MapFrame;
     38import org.openstreetmap.josm.gui.MapView;
    3839import org.openstreetmap.josm.gui.dialogs.changeset.ChangesetInSelectionListModel;
    3940import org.openstreetmap.josm.gui.dialogs.changeset.ChangesetListCellRenderer;
     
    4344import org.openstreetmap.josm.gui.help.HelpUtil;
    4445import org.openstreetmap.josm.gui.io.CloseChangesetTask;
    45 import org.openstreetmap.josm.gui.layer.Layer;
    4646import org.openstreetmap.josm.tools.ImageProvider;
    4747import org.openstreetmap.josm.tools.OpenBrowser;
     
    9494
    9595        ChangesetCache.getInstance().addChangesetCacheListener(inSelectionModel);
    96         Layer.listeners.add(inSelectionModel);
     96        MapView.addLayerChangeListener(inSelectionModel);
    9797        DataSet.selListeners.add(inSelectionModel);
    9898
    9999        ChangesetCache.getInstance().addChangesetCacheListener(inActiveDataLayerModel);
    100         Layer.listeners.add(inActiveDataLayerModel);
     100        MapView.addLayerChangeListener(inActiveDataLayerModel);
    101101
    102102        DblClickHandler dblClickHandler = new DblClickHandler();
     
    112112    public void tearDown() {
    113113        ChangesetCache.getInstance().removeChangesetCacheListener(inActiveDataLayerModel);
    114         Layer.listeners.remove(inSelectionModel);
     114        MapView.removeLayerChangeListener(inSelectionModel);
    115115        DataSet.selListeners.remove(inSelectionModel);
    116         Layer.listeners.remove(inActiveDataLayerModel);
     116        MapView.removeLayerChangeListener(inActiveDataLayerModel);
    117117    }
    118118
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r2512 r2621  
    4343import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
    4444import org.openstreetmap.josm.data.osm.visitor.Visitor;
     45import org.openstreetmap.josm.gui.MapView;
    4546import org.openstreetmap.josm.gui.NavigatableComponent;
    4647import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    4748import org.openstreetmap.josm.gui.SideButton;
    48 import org.openstreetmap.josm.gui.help.HelpUtil;
     49import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4950import org.openstreetmap.josm.gui.layer.Layer;
    5051import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    51 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    5252import org.openstreetmap.josm.tools.ImageProvider;
    5353import org.openstreetmap.josm.tools.Shortcut;
     
    5858 *
    5959 */
    60 public final class ConflictDialog extends ToggleDialog implements LayerChangeListener, IConflictListener, SelectionChangedListener{
     60public final class ConflictDialog extends ToggleDialog implements MapView.LayerChangeListener, IConflictListener, SelectionChangedListener{
    6161
    6262    static public Color getColor() {
     
    122122        build();
    123123        DataSet.selListeners.add(this);
    124         Layer.listeners.add(this);
     124        MapView.addLayerChangeListener(this);
    125125        refreshView();
     126    }
     127
     128
     129
     130    @Override
     131    public void tearDown() {
     132        MapView.removeLayerChangeListener(this);
     133        DataSet.selListeners.remove(this);
    126134    }
    127135
  • trunk/src/org/openstreetmap/josm/gui/dialogs/ConflictResolutionDialog.java

    r2512 r2621  
    2828import org.openstreetmap.josm.gui.conflict.pair.ConflictResolver;
    2929import org.openstreetmap.josm.gui.conflict.pair.properties.OperationCancelledException;
    30 import org.openstreetmap.josm.gui.help.HelpBrowser;
    3130import org.openstreetmap.josm.gui.help.HelpBrowserProxy;
    3231import org.openstreetmap.josm.gui.help.HelpUtil;
     
    231230                );
    232231                switch(ret) {
    233                     case JOptionPane.YES_OPTION:
    234                         setVisible(false);
    235                         break;
    236                     default:
    237                         return;
     232                case JOptionPane.YES_OPTION:
     233                    setVisible(false);
     234                    break;
     235                default:
     236                    return;
    238237                }
    239238            }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/FilterDialog.java

    r2512 r2621  
    44import static org.openstreetmap.josm.tools.I18n.marktr;
    55import static org.openstreetmap.josm.tools.I18n.tr;
    6 import static org.openstreetmap.josm.tools.I18n.trn;
     6
     7import java.awt.BorderLayout;
     8import java.awt.Component;
     9import java.awt.GridLayout;
     10import java.awt.event.ActionEvent;
     11import java.awt.event.ActionListener;
     12import java.awt.event.KeyEvent;
     13import java.awt.event.MouseEvent;
    714
    815import javax.swing.JCheckBox;
    916import javax.swing.JPanel;
    10 import javax.swing.JTable;
    11 import javax.swing.table.JTableHeader;
    12 import javax.swing.table.DefaultTableCellRenderer;
    13 import javax.swing.event.TableModelListener;
    14 import javax.swing.event.TableModelEvent;
    15 import javax.swing.table.TableCellRenderer;
    16 import javax.swing.ListSelectionModel;
    1717import javax.swing.JPopupMenu;
    1818import javax.swing.JScrollPane;
    19 
    20 import java.awt.Component;
    21 import java.awt.FlowLayout;
    22 import java.awt.BorderLayout;
    23 import java.awt.GridLayout;
    24 import java.awt.event.KeyEvent;
    25 import java.awt.event.ActionListener;
    26 import java.awt.event.ActionEvent;
    27 import java.awt.event.MouseEvent;
    28 
    29 import org.openstreetmap.josm.Main;
     19import javax.swing.JTable;
     20import javax.swing.ListSelectionModel;
     21import javax.swing.event.TableModelEvent;
     22import javax.swing.event.TableModelListener;
     23import javax.swing.table.DefaultTableCellRenderer;
     24import javax.swing.table.JTableHeader;
     25import javax.swing.table.TableCellRenderer;
     26
     27import org.openstreetmap.josm.actions.search.SearchAction;
     28import org.openstreetmap.josm.data.osm.Filter;
     29import org.openstreetmap.josm.data.osm.Filters;
     30import org.openstreetmap.josm.gui.MapView;
    3031import org.openstreetmap.josm.gui.SideButton;
    31 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
     32import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    3233import org.openstreetmap.josm.gui.layer.DataChangeListener;
     34import org.openstreetmap.josm.gui.layer.Layer;
    3335import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    34 import org.openstreetmap.josm.gui.layer.Layer;
    35 import org.openstreetmap.josm.data.osm.Filters;
    36 import org.openstreetmap.josm.data.osm.Filter;
    3736import org.openstreetmap.josm.tools.Shortcut;
    38 import org.openstreetmap.josm.data.osm.DataSet;
    39 import org.openstreetmap.josm.actions.search.SearchAction;
    4037
    4138/**
     
    4340 * @author Petr_Dlouhý
    4441 */
    45 public class FilterDialog extends ToggleDialog implements DataChangeListener, LayerChangeListener, TableModelListener {
     42public class FilterDialog extends ToggleDialog implements DataChangeListener, MapView.LayerChangeListener, TableModelListener {
    4643    private JTable userTable;
    4744    private Filters filters = new Filters();
     
    5451
    5552    public FilterDialog(){
    56        super(tr("Filter"), "filter", tr("Filter objects and hide/disable them."),
    57                Shortcut.registerShortcut("subwindow:filter", tr("Toggle: {0}", tr("Filter")), KeyEvent.VK_F, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 162);
    58 
    59        Layer.listeners.add(this);
    60        build();
     53        super(tr("Filter"), "filter", tr("Filter objects and hide/disable them."),
     54                Shortcut.registerShortcut("subwindow:filter", tr("Toggle: {0}", tr("Filter")), KeyEvent.VK_F, Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 162);
     55
     56        MapView.addLayerChangeListener(this);
     57        build();
     58    }
     59
     60    @Override
     61    public void tearDown() {
     62        MapView.removeLayerChangeListener(this);
    6163    }
    6264
     
    6567
    6668        addButton = new SideButton(marktr("Add"), "add", "SelectionList", tr("Add filter."),
    67               new ActionListener(){
    68                  public void actionPerformed(ActionEvent evt){
    69                     Filter filter = (Filter)SearchAction.showSearchDialog(new Filter());
    70                     if(filter != null){
    71                        filters.addFilter(filter);
    72                        filters.filter();
    73                     }
    74                  }
    75               });
     69                new ActionListener(){
     70            public void actionPerformed(ActionEvent evt){
     71                Filter filter = (Filter)SearchAction.showSearchDialog(new Filter());
     72                if(filter != null){
     73                    filters.addFilter(filter);
     74                    filters.filter();
     75                }
     76            }
     77        });
    7678        pnl.add(addButton);
    7779
    7880        editButton = new SideButton(marktr("Edit"), "edit", "SelectionList", tr("Edit filter."),
    79               new ActionListener(){
    80                  public void actionPerformed(ActionEvent evt){
    81                     int index = userTable.getSelectionModel().getMinSelectionIndex();
    82                     if(index < 0) return;
    83                     Filter f = filters.getFilter(index);
    84                     Filter filter = (Filter)SearchAction.showSearchDialog(f);
    85                     if(filter != null){
    86                        filters.setFilter(index, filter);
    87                        filters.filter();
    88                     }
    89                  }
    90               });
     81                new ActionListener(){
     82            public void actionPerformed(ActionEvent evt){
     83                int index = userTable.getSelectionModel().getMinSelectionIndex();
     84                if(index < 0) return;
     85                Filter f = filters.getFilter(index);
     86                Filter filter = (Filter)SearchAction.showSearchDialog(f);
     87                if(filter != null){
     88                    filters.setFilter(index, filter);
     89                    filters.filter();
     90                }
     91            }
     92        });
    9193        pnl.add(editButton);
    9294
    9395        deleteButton = new SideButton(marktr("Delete"), "delete", "SelectionList", tr("Delete filter."),
    94               new ActionListener(){
    95                  public void actionPerformed(ActionEvent evt){
    96                     int index = userTable.getSelectionModel().getMinSelectionIndex();
    97                     if(index < 0) return;
    98                     filters.removeFilter(index);
    99                  }
    100               });
     96                new ActionListener(){
     97            public void actionPerformed(ActionEvent evt){
     98                int index = userTable.getSelectionModel().getMinSelectionIndex();
     99                if(index < 0) return;
     100                filters.removeFilter(index);
     101            }
     102        });
    101103        pnl.add(deleteButton);
    102104
    103105        upButton = new SideButton(marktr("Up"), "up", "SelectionList", tr("Move filter up."),
    104               new ActionListener(){
    105                  public void actionPerformed(ActionEvent evt){
    106                     int index = userTable.getSelectionModel().getMinSelectionIndex();
    107                     if(index < 0) return;
    108                     filters.moveUpFilter(index);
    109                     userTable.getSelectionModel().setSelectionInterval(index-1, index-1);
    110                  }
    111               });
     106                new ActionListener(){
     107            public void actionPerformed(ActionEvent evt){
     108                int index = userTable.getSelectionModel().getMinSelectionIndex();
     109                if(index < 0) return;
     110                filters.moveUpFilter(index);
     111                userTable.getSelectionModel().setSelectionInterval(index-1, index-1);
     112            }
     113        });
    112114        pnl.add(upButton);
    113115
    114116        downButton = new SideButton(marktr("Down"), "down", "SelectionList", tr("Move filter down."),
    115               new ActionListener(){
    116                  public void actionPerformed(ActionEvent evt){
    117                     int index = userTable.getSelectionModel().getMinSelectionIndex();
    118                     if(index < 0) return;
    119                     filters.moveDownFilter(index);
    120                     userTable.getSelectionModel().setSelectionInterval(index+1, index+1);
    121                  }
    122               });
     117                new ActionListener(){
     118            public void actionPerformed(ActionEvent evt){
     119                int index = userTable.getSelectionModel().getMinSelectionIndex();
     120                if(index < 0) return;
     121                filters.moveDownFilter(index);
     122                userTable.getSelectionModel().setSelectionInterval(index+1, index+1);
     123            }
     124        });
    123125        pnl.add(downButton);
    124126        return pnl;
     
    126128
    127129    protected String[] columnToolTips = {
    128         tr("Enable filter"),
    129         tr("Hide elements"),
    130         null,
    131         tr("Apply also for children"),
    132         tr("Inverse filter"),
    133         tr("Filter mode")
     130            tr("Enable filter"),
     131            tr("Hide elements"),
     132            null,
     133            tr("Apply also for children"),
     134            tr("Inverse filter"),
     135            tr("Filter mode")
    134136    };
    135137
     
    138140        pnl.setLayout(new BorderLayout());
    139141        userTable = new JTable(filters){
     142            @Override
    140143            protected JTableHeader createDefaultTableHeader() {
    141144                return new JTableHeader(columnModel) {
    142                    public String getToolTipText(MouseEvent e) {
    143                        String tip = null;
    144                        java.awt.Point p = e.getPoint();
    145                        int index = columnModel.getColumnIndexAtX(p.x);
    146                        int realIndex = columnModel.getColumn(index).getModelIndex();
    147                        return columnToolTips[realIndex];
    148                    }
    149                };
    150            }
     145                    @Override
     146                    public String getToolTipText(MouseEvent e) {
     147                        String tip = null;
     148                        java.awt.Point p = e.getPoint();
     149                        int index = columnModel.getColumnIndexAtX(p.x);
     150                        int realIndex = columnModel.getColumn(index).getModelIndex();
     151                        return columnToolTips[realIndex];
     152                    }
     153                };
     154            }
    151155        };
    152156
     
    192196    }
    193197
    194    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    195       filters.filter();
    196    }
    197 
    198    public void dataChanged(OsmDataLayer l){
    199       filters.filter();
    200    }
    201 
    202    class StringRenderer extends DefaultTableCellRenderer {
    203       public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,int row,int column) {
    204          Filters model = (Filters)table.getModel();
    205          Component cell = (Component)super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
    206          cell.setEnabled(model.isCellEnabled(row, column));
    207          return cell;
    208       }
    209    }
    210 
    211    class BooleanRenderer extends JCheckBox implements TableCellRenderer {
    212       public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,int row,int column) {
    213          Filters model = (Filters)table.getModel();
    214          setSelected((Boolean)value);
    215          setEnabled(model.isCellEnabled(row, column));
    216          setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
    217          return this;
    218       }
    219    }
    220 
    221    public void tableChanged(TableModelEvent e){
    222       setTitle("Filter Hidden:" + filters.hiddenCount + " Disabled:" + filters.disabledCount);
    223    }
     198    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     199        filters.filter();
     200    }
     201
     202    public void dataChanged(OsmDataLayer l){
     203        filters.filter();
     204    }
     205
     206    class StringRenderer extends DefaultTableCellRenderer {
     207        @Override
     208        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,int row,int column) {
     209            Filters model = (Filters)table.getModel();
     210            Component cell = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
     211            cell.setEnabled(model.isCellEnabled(row, column));
     212            return cell;
     213        }
     214    }
     215
     216    class BooleanRenderer extends JCheckBox implements TableCellRenderer {
     217        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,int row,int column) {
     218            Filters model = (Filters)table.getModel();
     219            setSelected((Boolean)value);
     220            setEnabled(model.isCellEnabled(row, column));
     221            setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
     222            return this;
     223        }
     224    }
     225
     226    public void tableChanged(TableModelEvent e){
     227        setTitle("Filter Hidden:" + filters.hiddenCount + " Disabled:" + filters.disabledCount);
     228    }
    224229}
  • trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

    r2602 r2621  
    1 // License: GPL. Copyright 2007 by Immanuel Scholz and others
    21package org.openstreetmap.josm.gui.dialogs;
    32
     
    4443import org.openstreetmap.josm.gui.MapView;
    4544import org.openstreetmap.josm.gui.SideButton;
     45import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4646import org.openstreetmap.josm.gui.io.SaveLayersDialog;
    4747import org.openstreetmap.josm.gui.layer.Layer;
    4848import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    49 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    5049import org.openstreetmap.josm.tools.ImageProvider;
    5150import org.openstreetmap.josm.tools.Shortcut;
     
    9594    private LayerList layerList;
    9695
     96    ActivateLayerAction activateLayerAction;
     97
    9798    protected JPanel createButtonPanel() {
    9899        JPanel buttonPanel = new JPanel(new GridLayout(1, 5));
     
    111112
    112113        // -- activate action
    113         ActivateLayerAction activateLayerAction = new ActivateLayerAction();
     114        activateLayerAction = new ActivateLayerAction();
    114115        adaptTo(activateLayerAction, selectionModel);
    115         adaptToLayerChanges(activateLayerAction);
     116        MapView.addLayerChangeListener(activateLayerAction);
    116117        buttonPanel.add(new SideButton(activateLayerAction, "activate"));
    117118
     
    151152        selectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
    152153        model = new LayerListModel(selectionModel);
    153         Layer.listeners.add(model);
     154        MapView.addLayerChangeListener(model);
    154155
    155156        // create the list control
     
    182183    }
    183184
     185    @Override
     186    public void tearDown() {
     187        MapView.removeLayerChangeListener(model);
     188        MapView.removeLayerChangeListener(activateLayerAction);
     189    }
     190
    184191    public LayerListModel getModel() {
    185192        return model;
     
    232239                }
    233240        );
    234     }
    235     /**
    236      * Wires <code>listener</code> to {@see MapView} in such a way, that
    237      * <code>listener</code> receives a {@see IEnabledStateUpdating#updateEnabledState()}
    238      * on every {@see LayerChangeListener}-event emitted by {@see MapView}.
    239      *
    240      * @param listener  the listener
    241      */
    242     protected void adaptToLayerChanges(final IEnabledStateUpdating listener) {
    243         Layer.listeners.add(
    244                 new LayerChangeListener() {
    245                     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    246                         listener.updateEnabledState();
    247                     }
    248                     public void layerAdded(Layer newLayer) {
    249                         listener.updateEnabledState();
    250                     }
    251                     public void layerRemoved(Layer oldLayer) {
    252                         listener.updateEnabledState();
    253                     }
    254                 }
    255         );
    256     }
    257 
    258     private enum DeleteDecision {
    259         deleteCurrent,
    260         dontDeleteCurrent,
    261         deleteAll,
    262         cancel
    263241    }
    264242
     
    400378     */
    401379
    402     public final class ActivateLayerAction extends AbstractAction implements IEnabledStateUpdating{
     380    public final class ActivateLayerAction extends AbstractAction implements IEnabledStateUpdating, MapView.LayerChangeListener{
    403381        private  Layer layer;
    404382
     
    449427                setEnabled(!isActiveLayer(layer));
    450428            }
     429        }
     430
     431        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     432            updateEnabledState();
     433        }
     434        public void layerAdded(Layer newLayer) {
     435            updateEnabledState();
     436        }
     437        public void layerRemoved(Layer oldLayer) {
     438            updateEnabledState();
    451439        }
    452440    }
     
    633621     * the properties {@see Layer#VISIBLE_PROP} and {@see Layer#NAME_PROP}.
    634622     */
    635     public class LayerListModel extends DefaultListModel implements LayerChangeListener, PropertyChangeListener{
     623    public class LayerListModel extends DefaultListModel implements MapView.LayerChangeListener, PropertyChangeListener{
    636624
    637625        /** manages list selection state*/
  • trunk/src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r2578 r2621  
    6666import org.openstreetmap.josm.gui.ExtendedDialog;
    6767import org.openstreetmap.josm.gui.MapFrame;
     68import org.openstreetmap.josm.gui.MapView;
    6869import org.openstreetmap.josm.gui.SideButton;
     70import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    6971import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
    7072import org.openstreetmap.josm.gui.layer.Layer;
    7173import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    72 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    7374import org.openstreetmap.josm.gui.preferences.TaggingPresetPreference;
    7475import org.openstreetmap.josm.gui.tagging.TaggingPreset;
     
    9596 * @author imi
    9697 */
    97 public class PropertiesDialog extends ToggleDialog implements SelectionChangedListener, LayerChangeListener {
     98public class PropertiesDialog extends ToggleDialog implements SelectionChangedListener, MapView.LayerChangeListener {
    9899    /**
    99100     * Watches for double clicks and from editing or new property, depending on the
     
    594595
    595596        DataSet.selListeners.add(this);
    596         Layer.listeners.add(this);
     597        MapView.addLayerChangeListener(this);
     598    }
     599
     600    @Override
     601    public void tearDown() {
     602        MapView.removeLayerChangeListener(this);
    597603    }
    598604
  • trunk/src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

    r2578 r2621  
    4141import org.openstreetmap.josm.data.osm.Way;
    4242import org.openstreetmap.josm.gui.DefaultNameFormatter;
     43import org.openstreetmap.josm.gui.MapView;
    4344import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    4445import org.openstreetmap.josm.gui.SideButton;
     46import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4547import org.openstreetmap.josm.gui.dialogs.relation.DownloadRelationTask;
    4648import org.openstreetmap.josm.gui.dialogs.relation.RelationEditor;
     
    4850import org.openstreetmap.josm.gui.layer.Layer;
    4951import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    50 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    5152import org.openstreetmap.josm.tools.GBC;
    5253import org.openstreetmap.josm.tools.ImageProvider;
     
    6061 * objects are visible on the map and can be selected there. Relations are not.
    6162 */
    62 public class RelationListDialog extends ToggleDialog implements LayerChangeListener, DataSetListener, DataChangeListener {
     63public class RelationListDialog extends ToggleDialog implements MapView.LayerChangeListener, DataSetListener, DataChangeListener {
    6364    //private static final Logger logger = Logger.getLogger(RelationListDialog.class.getName());
    6465
     
    137138
    138139    @Override public void showNotify() {
    139         Layer.listeners.add(this);
    140         Layer.listeners.add(newAction);
     140        MapView.addLayerChangeListener(this);
     141        MapView.addLayerChangeListener(newAction);
    141142        // Register as a data set listener for the current edit layer only.
    142143        // See also activeLayerChanged
     
    148149
    149150    @Override public void hideNotify() {
    150         Layer.listeners.remove(this);
    151         Layer.listeners.remove(newAction);
    152         Layer.listeners.add(newAction);
     151        MapView.removeLayerChangeListener(this);
     152        MapView.removeLayerChangeListener(newAction);
    153153        // unregistering from *all* data layer is somewhat overkill but it
    154154        // doesn't harm either.
     
    345345     *
    346346     */
    347     class NewAction extends AbstractAction implements LayerChangeListener{
     347    class NewAction extends AbstractAction implements MapView.LayerChangeListener{
    348348        public NewAction() {
    349349            putValue(SHORT_DESCRIPTION,tr("Create a new relation"));
  • trunk/src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r2563 r2621  
    4343import org.openstreetmap.josm.data.osm.Way;
    4444import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     45import org.openstreetmap.josm.gui.MapView;
    4546import org.openstreetmap.josm.gui.OsmPrimitivRenderer;
    4647import org.openstreetmap.josm.gui.SideButton;
     48import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4749import org.openstreetmap.josm.gui.layer.Layer;
    4850import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    49 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    5051import org.openstreetmap.josm.tools.Shortcut;
    5152
     
    5758 * @author imi
    5859 */
    59 public class SelectionListDialog extends ToggleDialog implements SelectionChangedListener, LayerChangeListener {
     60public class SelectionListDialog extends ToggleDialog implements SelectionChangedListener, MapView.LayerChangeListener {
    6061
    6162    private static final int SELECTION_HISTORY_SIZE = 10;
     
    163164
    164165        DataSet.selListeners.add(this);
    165         Layer.listeners.add(this);
     166        MapView.addLayerChangeListener(this);
     167    }
     168
     169    @Override
     170    public void tearDown() {
     171        MapView.removeLayerChangeListener(this);
     172        DataSet.selListeners.remove(this);
    166173    }
    167174
  • trunk/src/org/openstreetmap/josm/gui/dialogs/UserListDialog.java

    r2512 r2621  
    4141import org.openstreetmap.josm.data.osm.OsmPrimitive;
    4242import org.openstreetmap.josm.data.osm.User;
     43import org.openstreetmap.josm.gui.MapView;
    4344import org.openstreetmap.josm.gui.SideButton;
     45import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    4446import org.openstreetmap.josm.gui.layer.Layer;
    4547import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    46 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    4748import org.openstreetmap.josm.tools.ImageProvider;
    4849import org.openstreetmap.josm.tools.Shortcut;
     
    5354 *
    5455 */
    55 public class UserListDialog extends ToggleDialog implements SelectionChangedListener, LayerChangeListener {
     56public class UserListDialog extends ToggleDialog implements SelectionChangedListener, MapView.LayerChangeListener {
    5657
    5758    /**
     
    6970        build();
    7071        DataSet.selListeners.add(this);
    71         Layer.listeners.add(this);
     72        MapView.addLayerChangeListener(this);
     73    }
     74
     75    @Override
     76    public void tearDown() {
     77        MapView.removeLayerChangeListener(this);
     78        DataSet.selListeners.remove(this);
    7279    }
    7380
     
    312319            UserInfo info = data.get(row);
    313320            switch(column) {
    314                 case 0: /* author */ return info.getName() == null ? "" : info.getName();
    315                 case 1: /* count */ return info.count;
    316                 case 2: /* percent */ return NumberFormat.getPercentInstance().format(info.percent);
     321            case 0: /* author */ return info.getName() == null ? "" : info.getName();
     322            case 1: /* count */ return info.count;
     323            case 2: /* percent */ return NumberFormat.getPercentInstance().format(info.percent);
    317324            }
    318325            return null;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetInSelectionListModel.java

    r2613 r2621  
    88import org.openstreetmap.josm.data.SelectionChangedListener;
    99import org.openstreetmap.josm.data.osm.OsmPrimitive;
     10import org.openstreetmap.josm.gui.MapView;
     11import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    1012import org.openstreetmap.josm.gui.layer.Layer;
    1113import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    12 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1314
    14 public class ChangesetInSelectionListModel extends ChangesetListModel implements SelectionChangedListener, LayerChangeListener{
     15public class ChangesetInSelectionListModel extends ChangesetListModel implements SelectionChangedListener, MapView.LayerChangeListener{
    1516
    1617    public ChangesetInSelectionListModel(DefaultListSelectionModel selectionModel) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/changeset/ChangesetsInActiveDataLayerListModel.java

    r2613 r2621  
    55
    66import org.openstreetmap.josm.Main;
     7import org.openstreetmap.josm.gui.MapView;
     8import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    79import org.openstreetmap.josm.gui.layer.DataChangeListener;
    810import org.openstreetmap.josm.gui.layer.Layer;
    911import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    10 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1112
    12 public class ChangesetsInActiveDataLayerListModel extends ChangesetListModel implements LayerChangeListener, DataChangeListener{
     13public class ChangesetsInActiveDataLayerListModel extends ChangesetListModel implements MapView.LayerChangeListener, DataChangeListener{
    1314
    1415    public ChangesetsInActiveDataLayerListModel(DefaultListSelectionModel selectionModel) {
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

    r2581 r2621  
    544544            getLayer().data.removeDataSetListener(memberTableModel);
    545545            getLayer().listenerDataChanged.remove(memberTableModel);
     546            memberTable.unlinkAsListener();
    546547            dispose();
    547548        }
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/MemberTable.java

    r2563 r2621  
    2525import org.openstreetmap.josm.actions.AutoScaleAction;
    2626import org.openstreetmap.josm.data.osm.OsmPrimitive;
     27import org.openstreetmap.josm.gui.MapView;
     28import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    2729import org.openstreetmap.josm.gui.layer.Layer;
    2830import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    29 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    3031
    3132public class MemberTable extends JTable implements IMemberModelListener {
     
    3839    /** the popup menu */
    3940    protected JPopupMenu popupMenu;
     41    private ZoomToAction zoomToAction;
    4042
    4143    /**
     
    148150
    149151    /**
    150      * creates the popup men
    151      */
    152     protected void createPopupMenu() {
    153         popupMenu = new JPopupMenu();
    154         ZoomToAction zoomToAction = new ZoomToAction();
    155         Layer.listeners.add(zoomToAction);
    156         getSelectionModel().addListSelectionListener(zoomToAction);
    157         popupMenu.add(zoomToAction);
    158     }
    159 
    160     /**
    161152     * Replies the popup menu for this table
    162153     *
     
    165156    protected JPopupMenu getPopUpMenu() {
    166157        if (popupMenu == null) {
    167             createPopupMenu();
     158            popupMenu = new JPopupMenu();
     159            zoomToAction = new ZoomToAction();
     160            MapView.addLayerChangeListener(zoomToAction);
     161            getSelectionModel().addListSelectionListener(zoomToAction);
     162            popupMenu.add(zoomToAction);
    168163        }
    169164        return popupMenu;
     165    }
     166
     167    public void unlinkAsListener() {
     168        MapView.removeLayerChangeListener(zoomToAction);
    170169    }
    171170
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/RelationDialogManager.java

    r2512 r2621  
    1212
    1313import org.openstreetmap.josm.data.osm.Relation;
     14import org.openstreetmap.josm.gui.MapView;
    1415import org.openstreetmap.josm.gui.layer.Layer;
    1516import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    16 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1717
    1818/**
     
    2020 *
    2121 */
    22 public class RelationDialogManager extends WindowAdapter implements LayerChangeListener{
     22public class RelationDialogManager extends WindowAdapter implements MapView.LayerChangeListener{
    2323
    2424    /** keeps track of open relation editors */
     
    3333        if (RelationDialogManager.relationDialogManager == null) {
    3434            RelationDialogManager.relationDialogManager = new RelationDialogManager();
    35             Layer.listeners.add(RelationDialogManager.relationDialogManager);
     35            MapView.addLayerChangeListener(RelationDialogManager.relationDialogManager);
    3636        }
    3737        return RelationDialogManager.relationDialogManager;
  • trunk/src/org/openstreetmap/josm/gui/dialogs/relation/SelectionTableModel.java

    r2563 r2621  
    1313import org.openstreetmap.josm.data.osm.DataSet;
    1414import org.openstreetmap.josm.data.osm.OsmPrimitive;
     15import org.openstreetmap.josm.gui.MapView;
    1516import org.openstreetmap.josm.gui.layer.Layer;
    1617import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    17 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1818
    19 public class SelectionTableModel extends AbstractTableModel implements SelectionChangedListener, LayerChangeListener{
     19public class SelectionTableModel extends AbstractTableModel implements SelectionChangedListener, MapView.LayerChangeListener{
    2020
    2121    /** this selection table model only displays selected primitives in this layer */
     
    3434        this.layer = layer;
    3535        cache = new ArrayList<OsmPrimitive>();
    36         Layer.listeners.add(this);
     36        MapView.addLayerChangeListener(this);
    3737        populateSelectedPrimitives(layer);
    3838    }
     
    4040    public void unregister() {
    4141        DataSet.selListeners.remove(this);
    42         Layer.listeners.remove(this);
     42        MapView.removeLayerChangeListener(this);
    4343    }
    4444
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserDialogManager.java

    r2512 r2621  
    1010import org.openstreetmap.josm.Main;
    1111import org.openstreetmap.josm.data.osm.history.History;
     12import org.openstreetmap.josm.gui.MapView;
    1213import org.openstreetmap.josm.gui.layer.Layer;
    13 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1414import org.openstreetmap.josm.tools.WindowGeometry;
    1515
    16 public class HistoryBrowserDialogManager implements LayerChangeListener {
     16public class HistoryBrowserDialogManager implements MapView.LayerChangeListener {
    1717    static private HistoryBrowserDialogManager instance;
    1818    static public HistoryBrowserDialogManager getInstance() {
     
    2727    protected HistoryBrowserDialogManager() {
    2828        dialogs = new HashMap<Long, HistoryBrowserDialog>();
    29         Layer.listeners.add(this);
     29        MapView.addLayerChangeListener(this);
    3030    }
    3131
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java

    r2556 r2621  
    2929import org.openstreetmap.josm.data.osm.history.HistoryWay;
    3030import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
     31import org.openstreetmap.josm.gui.MapView;
    3132import org.openstreetmap.josm.gui.layer.DataChangeListener;
    3233import org.openstreetmap.josm.gui.layer.Layer;
    3334import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    34 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    3535
    3636/**
     
    5959 * @see HistoryBrowser
    6060 */
    61 public class HistoryBrowserModel extends Observable implements LayerChangeListener, DataSetListener, DataChangeListener {
     61public class HistoryBrowserModel extends Observable implements MapView.LayerChangeListener, DataSetListener, DataChangeListener {
    6262
    6363    private static Logger logger = Logger.getLogger(HistoryBrowserModel.class.getName());
     
    9797            getEditLayer().listenerDataChanged.add(this);
    9898        }
    99         Layer.listeners.add(this);
    100 
     99        MapView.addLayerChangeListener(this);
    101100    }
    102101
     
    772771            getEditLayer().data.removeDataSetListener(this);
    773772        }
    774         Layer.listeners.remove(this);
    775 
     773        MapView.removeLayerChangeListener(this);
    776774    }
    777775
  • trunk/src/org/openstreetmap/josm/gui/layer/Layer.java

    r2619 r2621  
    1111import java.beans.PropertyChangeSupport;
    1212import java.io.File;
    13 import java.util.Collection;
    14 import java.util.concurrent.CopyOnWriteArrayList;
    1513
    1614import javax.swing.AbstractAction;
     
    4947
    5048    /**
    51      * Interface to notify listeners of the change of the active layer.
    52      * @author imi
    53      */
    54     public interface LayerChangeListener {
    55         void activeLayerChange(Layer oldLayer, Layer newLayer);
    56         void layerAdded(Layer newLayer);
    57         void layerRemoved(Layer oldLayer);
    58     }
    59 
    60     /**
    61      * The listener of the active layer changes. You may register/deregister yourself
    62      * while an LayerChangeListener - action is executed.
    63      *
    64      * @deprecated use {@see #addLayerChangeListener(LayerChangeListener)}
    65      * and {@see #removeLayerChangeListener(LayerChangeListener)}
    66      */
    67     @Deprecated
    68     public static final Collection<LayerChangeListener> listeners = new CopyOnWriteArrayList<LayerChangeListener>();
    69 
    70     /**
    71      * Adds a layer change listener
    72      *
    73      * @param listener the listener. Ignored if null or already registered.
    74      */
    75     public static void addLayerChangeListener(LayerChangeListener listener) {
    76         if (listener != null && ! listeners.contains(listener)) {
    77             listeners.add(listener);
    78         }
    79     }
    80 
    81     /**
    82      * Removes a layer change listener
    83      *
    84      * @param listener the listener. Ignored if null or already registered.
    85      */
    86     public static void removeLayerChangeListener(LayerChangeListener listener) {
    87         if (listener != null && listeners.contains(listener)) {
    88             listeners.remove(listener);
    89         }
    90     }
    91 
    92     /**
    9349     * The visibility state of the layer.
    9450     *
  • trunk/src/org/openstreetmap/josm/gui/layer/geoimage/GeoImageLayer.java

    r2617 r2621  
    1616import java.awt.Graphics2D;
    1717import java.awt.Image;
    18 import java.awt.MediaTracker;
    1918import java.awt.Point;
    2019import java.awt.Rectangle;
    21 import java.awt.Toolkit;
    2220import java.awt.event.MouseAdapter;
    2321import java.awt.event.MouseEvent;
    2422import java.awt.image.BufferedImage;
     23import java.beans.PropertyChangeEvent;
    2524import java.beans.PropertyChangeListener;
    26 import java.beans.PropertyChangeEvent;
    2725import java.io.File;
    2826import java.io.IOException;
     
    3028import java.util.ArrayList;
    3129import java.util.Arrays;
     30import java.util.Collection;
    3231import java.util.Collections;
    33 import java.util.Collection;
    3432import java.util.Date;
     33import java.util.HashSet;
    3534import java.util.LinkedHashSet;
    36 import java.util.HashSet;
    3735import java.util.List;
    3836
     
    5048import org.openstreetmap.josm.gui.MapView;
    5149import org.openstreetmap.josm.gui.PleaseWaitRunnable;
     50import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
    5251import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
    5352import org.openstreetmap.josm.gui.layer.GpxLayer;
     
    102101        }
    103102        public int compareTo(ImageEntry image) {
    104             if (time != null && image.time != null) {
     103            if (time != null && image.time != null)
    105104                return time.compareTo(image.time);
    106             } else if (time == null && image.time == null) {
     105            else if (time == null && image.time == null)
    107106                return 0;
    108             } else if (time == null) {
     107            else if (time == null)
    109108                return -1;
    110             } else {
     109            else
    111110                return 1;
    112             }
    113111        }
    114112    }
     
    147145            }
    148146
    149             if (cancelled) {
     147            if (cancelled)
    150148                return;
    151             }
    152149            progressMonitor.subTask(tr("Read photos..."));
    153150            progressMonitor.setTicksCount(files.size());
     
    205202                        e.printStackTrace();
    206203                        rememberError(tr("Unable to get canonical path for directory {0}\n",
    207                                            f.getAbsolutePath()));
     204                                f.getAbsolutePath()));
    208205                    }
    209206
     
    228225
    229226                } else {
    230                       files.add(f);
    231                 }
    232             }
    233 
    234             if (nullFile) {
     227                    files.add(f);
     228                }
     229            }
     230
     231            if (nullFile)
    235232                throw new NullPointerException();
    236             }
    237233        }
    238234
     
    265261                Main.main.addLayer(layer);
    266262                layer.hook_up_mouse_events(); // Main.map.mapView should exist
    267                                               // now. Can add mouse listener
     263                // now. Can add mouse listener
    268264
    269265                if (! cancelled && layer.data.size() > 0) {
     
    329325                new JSeparator(),
    330326                correlateItem
    331                 };
     327        };
    332328    }
    333329
     
    336332        int i = 0;
    337333        for (ImageEntry e : data)
    338             if (e.pos != null)
     334            if (e.pos != null) {
    339335                i++;
     336            }
    340337        return data.size() + " " + trn("image", "images", data.size())
    341                 + " loaded. " + tr("{0} were found to be gps tagged.", i);
     338        + " loaded. " + tr("{0} were found to be gps tagged.", i);
    342339    }
    343340
     
    406403
    407404        return new Dimension(
    408             (int) Math.round(f * thumb.getWidth(null)),
    409             (int) Math.round(f * thumb.getHeight(null)));
     405                (int) Math.round(f * thumb.getWidth(null)),
     406                (int) Math.round(f * thumb.getHeight(null)));
    410407    }
    411408
     
    432429
    433430                for (ImageEntry e : data) {
    434                     if (e.pos == null)
     431                    if (e.pos == null) {
    435432                        continue;
     433                    }
    436434                    Point p = mv.getPoint(e.pos);
    437435                    if (e.thumbnail != null) {
     
    444442                    else { // thumbnail not loaded yet
    445443                        icon.paintIcon(mv, tempG,
    446                                    p.x - icon.getIconWidth() / 2,
    447                                    p.y - icon.getIconHeight() / 2);
     444                                p.x - icon.getIconWidth() / 2,
     445                                p.y - icon.getIconHeight() / 2);
    448446                    }
    449447                }
     
    454452        else {
    455453            for (ImageEntry e : data) {
    456                 if (e.pos == null)
     454                if (e.pos == null) {
    457455                    continue;
     456                }
    458457                Point p = mv.getPoint(e.pos);
    459458                icon.paintIcon(mv, g,
    460                            p.x - icon.getIconWidth() / 2,
    461                            p.y - icon.getIconHeight() / 2);
     459                        p.x - icon.getIconWidth() / 2,
     460                        p.y - icon.getIconHeight() / 2);
    462461            }
    463462        }
     
    475474                } else {
    476475                    selectedIcon.paintIcon(mv, g,
    477                                 p.x - selectedIcon.getIconWidth() / 2,
    478                                 p.y - selectedIcon.getIconHeight() / 2);
     476                            p.x - selectedIcon.getIconWidth() / 2,
     477                            p.y - selectedIcon.getIconHeight() / 2);
    479478                }
    480479            }
     
    484483    @Override
    485484    public void visitBoundingBox(BoundingXYVisitor v) {
    486         for (ImageEntry e : data)
     485        for (ImageEntry e : data) {
    487486            v.visit(e.pos);
     487        }
    488488    }
    489489
     
    508508
    509509            Rational[] components = dir
    510                     .getRationalArray(GpsDirectory.TAG_GPS_LONGITUDE);
     510            .getRationalArray(GpsDirectory.TAG_GPS_LONGITUDE);
    511511
    512512            deg = components[0].intValue();
     
    516516            lon = (deg + (min / 60) + (sec / 3600));
    517517
    518             if (dir.getString(GpsDirectory.TAG_GPS_LONGITUDE_REF).charAt(0) == 'W')
     518            if (dir.getString(GpsDirectory.TAG_GPS_LONGITUDE_REF).charAt(0) == 'W') {
    519519                lon = -lon;
     520            }
    520521
    521522            // latitude
     
    529530            lat = (deg + (min / 60) + (sec / 3600));
    530531
    531             if (dir.getString(GpsDirectory.TAG_GPS_LATITUDE_REF).charAt(0) == 'S')
     532            if (dir.getString(GpsDirectory.TAG_GPS_LATITUDE_REF).charAt(0) == 'S') {
    532533                lat = -lat;
     534            }
    533535
    534536            // Store values
     
    569571
    570572    public void checkPreviousNextButtons() {
    571 //        System.err.println("showing image " + currentPhoto);
     573        //        System.err.println("showing image " + currentPhoto);
    572574        ImageViewerDialog.setNextEnabled(currentPhoto < data.size() - 1);
    573575        ImageViewerDialog.setPreviousEnabled(currentPhoto > 0);
     
    596598            @Override public void mousePressed(MouseEvent e) {
    597599
    598                 if (e.getButton() != MouseEvent.BUTTON1) {
     600                if (e.getButton() != MouseEvent.BUTTON1)
    599601                    return;
    600                 }
    601                 if (isVisible())
     602                if (isVisible()) {
    602603                    Main.map.mapView.repaint();
     604                }
    603605            }
    604606
    605607            @Override public void mouseReleased(MouseEvent ev) {
    606                 if (ev.getButton() != MouseEvent.BUTTON1) {
     608                if (ev.getButton() != MouseEvent.BUTTON1)
    607609                    return;
    608                 }
    609                 if (!isVisible()) {
     610                if (!isVisible())
    610611                    return;
    611                 }
    612612
    613613                for (int i = data.size() - 1; i >= 0; --i) {
    614614                    ImageEntry e = data.get(i);
    615                     if (e.pos == null)
     615                    if (e.pos == null) {
    616616                        continue;
     617                    }
    617618                    Point p = Main.map.mapView.getPoint(e.pos);
    618619                    Rectangle r;
     
    622623                    } else {
    623624                        r = new Rectangle(p.x - icon.getIconWidth() / 2,
    624                                             p.y - icon.getIconHeight() / 2,
    625                                             icon.getIconWidth(),
    626                                             icon.getIconHeight());
     625                                p.y - icon.getIconHeight() / 2,
     626                                icon.getIconWidth(),
     627                                icon.getIconHeight());
    627628                    }
    628629                    if (r.contains(ev.getPoint())) {
     
    636637        };
    637638        Main.map.mapView.addMouseListener(mouseAdapter);
    638         Layer.listeners.add(new LayerChangeListener() {
     639        MapView.addLayerChangeListener(new LayerChangeListener() {
    639640            public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    640641                if (newLayer == GeoImageLayer.this && currentPhoto >= 0) {
     
    656657                    data.clear();
    657658                    data = null;
     659                    // stop listening to layer change events
     660                    MapView.removeLayerChangeListener(this);
    658661                }
    659662            }
  • trunk/src/org/openstreetmap/josm/gui/tagging/TaggingPreset.java

    r2512 r2621  
    4444import org.openstreetmap.josm.data.osm.Way;
    4545import org.openstreetmap.josm.gui.ExtendedDialog;
     46import org.openstreetmap.josm.gui.MapView;
    4647import org.openstreetmap.josm.gui.QuadStateCheckBox;
    4748import org.openstreetmap.josm.gui.layer.Layer;
    4849import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    49 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    5050import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionCache;
    5151import org.openstreetmap.josm.gui.tagging.ac.AutoCompletionItemPritority;
     
    6565 * It is also able to construct dialogs out of preset definitions.
    6666 */
    67 public class TaggingPreset extends AbstractAction implements LayerChangeListener {
     67public class TaggingPreset extends AbstractAction implements MapView.LayerChangeListener {
    6868
    6969    public TaggingPresetMenu group = null;
     
    181181            }
    182182            if(locale_text == null) {
    183                 if(text_context != null)
     183                if(text_context != null) {
    184184                    locale_text = trc(text_context, text);
    185                 else
     185                } else {
    186186                    locale_text = tr(text);
     187                }
    187188            }
    188189            p.add(new JLabel(locale_text+":"), GBC.std().insets(0,0,10,0));
     
    231232
    232233            if(locale_text == null) {
    233                 if(text_context != null)
     234                if(text_context != null) {
    234235                    locale_text = trc(text_context, text);
    235                 else
     236                } else {
    236237                    locale_text = tr(text);
     238                }
    237239            }
    238240
     
    334336            for (int i=0; i<value_array.length; i++) {
    335337                lhm.put(value_array[i], (locale_display_values == null)
    336                 ? (values_context == null ? tr(display_array[i])
    337                 : tr(values_context, display_array[i])) : display_array[i]);
     338                        ? (values_context == null ? tr(display_array[i])
     339                                : tr(values_context, display_array[i])) : display_array[i]);
    338340            }
    339341            if(!usage.unused()){
     
    377379
    378380            if(locale_text == null) {
    379                 if(text_context != null)
     381                if(text_context != null) {
    380382                    locale_text = trc(text_context, text);
    381                 else
     383                } else {
    382384                    locale_text = tr(text);
     385                }
    383386            }
    384387            p.add(new JLabel(locale_text+":"), GBC.std().insets(0,0,10,0));
     
    427430        @Override public boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel) {
    428431            if(locale_text == null) {
    429                 if(text_context != null)
     432                if(text_context != null) {
    430433                    locale_text = trc(text_context, text);
    431                 else
     434                } else {
    432435                    locale_text = tr(text);
     436                }
    433437            }
    434438            p.add(new JLabel(locale_text), GBC.eol());
     
    447451        @Override public boolean addToPanel(JPanel p, Collection<OsmPrimitive> sel) {
    448452            if(locale_text == null) {
    449                 if(text == null)
     453                if(text == null) {
    450454                    locale_text = tr("More information about this feature");
    451                 else if(text_context != null)
     455                } else if(text_context != null) {
    452456                    locale_text = trc(text_context, text);
    453                 else
     457                } else {
    454458                    locale_text = tr(text);
     459                }
    455460            }
    456461            String url = locale_href;
     
    508513     */
    509514    public TaggingPreset() {
    510         Layer.listeners.add(this);
     515        MapView.addLayerChangeListener(this);
    511516        updateEnabledState();
    512517    }
     
    522527    public String getLocaleName() {
    523528        if(locale_name == null) {
    524             if(name_context != null)
     529            if(name_context != null) {
    525530                locale_name = trc(name_context, name);
    526             else
     531            } else {
    527532                locale_name = tr(name);
     533            }
    528534        }
    529535        return locale_name;
  • trunk/src/org/openstreetmap/josm/gui/tagging/ac/AutoCompletionCache.java

    r2578 r2621  
    1212import org.openstreetmap.josm.data.osm.Relation;
    1313import org.openstreetmap.josm.data.osm.RelationMember;
     14import org.openstreetmap.josm.gui.MapView;
    1415import org.openstreetmap.josm.gui.layer.Layer;
    1516import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    16 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1717
    1818/**
     
    4040    static {
    4141        caches = new HashMap<OsmDataLayer, AutoCompletionCache>();
    42         Layer.listeners.add(new LayerChangeListener() {
     42        MapView.addLayerChangeListener(new MapView.LayerChangeListener() {
    4343            public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    4444                // do nothing
Note: See TracChangeset for help on using the changeset viewer.