Changeset 1890 in josm for trunk/src/org

Timestamp:

2009-08-02T23:15:26+02:00 (15 years ago)

Author:

Gubaer

Message:

update: rewrite of layer dialog
new: allows multiple selection of layers in the dialog
new: move up, move down, toggle visibility, and delete on multiple layers
new: merge from an arbitrary layer into another layer, not only from the first into the second
new: new action for merging of the currently selected primitives on an arbitrary layer
new: make "active" layer explicit (special icon); activating a layer automatically moves it in the first position
refactoring: public fields 'name' and 'visible' on Layer are @deprecated. Use the setter/getters instead, Layer now emits PropertyChangeEvents if name or visibility are changed.

Location:

trunk/src/org/openstreetmap/josm

Files:

• actions/AbstractMergeAction.java (added)
• actions/MergeLayerAction.java (added)
• actions/MergeSelectionAction.java (added)
• actions/RenameLayerAction.java (modified) (2 diffs)
• actions/SaveActionBase.java (modified) (1 diff)
• gui/MainMenu.java (modified) (3 diffs)
• gui/MapFrame.java (modified) (5 diffs)
• gui/MapView.java (modified) (8 diffs)
• gui/dialogs/LayerListDialog.java (modified) (3 diffs)
• gui/dialogs/relation/GenericRelationEditor.java (modified) (4 diffs)
• gui/layer/GeoImageLayer.java (modified) (5 diffs)
• gui/layer/GpxLayer.java (modified) (11 diffs)
• gui/layer/Layer.java (modified) (7 diffs)
• gui/layer/OsmDataLayer.java (modified) (4 diffs)
• gui/layer/RawGpsLayer.java (modified) (12 diffs)
• gui/layer/markerlayer/MarkerLayer.java (modified) (10 diffs)

trunk/src/org/openstreetmap/josm/actions/RenameLayerAction.java

@@ -43 +43 @@
     public void actionPerformed(ActionEvent e) {
         Box panel = Box.createVerticalBox();
-        final JTextField name = new JTextField(layer.name);
+        final JTextField name = new JTextField(layer.getName());
         panel.add(name);
         JCheckBox filerename = new JCheckBox(tr("Also rename the file"));
@@ -105 +105 @@
             }
         }
-        layer.name = nameText;
+        layer.setName(nameText);
         Main.parent.repaint();
     }

trunk/src/org/openstreetmap/josm/actions/SaveActionBase.java

@@ -72 +72 @@
         save(file, layer);
 
-        layer.name = file.getName();
+        layer.setName(file.getName());
         layer.setAssociatedFile(file);
         Main.parent.repaint();

trunk/src/org/openstreetmap/josm/gui/MainMenu.java

@@ -40 +40 @@
 import org.openstreetmap.josm.actions.JoinNodeWayAction;
 import org.openstreetmap.josm.actions.JosmAction;
+import org.openstreetmap.josm.actions.MergeLayerAction;
 import org.openstreetmap.josm.actions.MergeNodesAction;
+import org.openstreetmap.josm.actions.MergeSelectionAction;
 import org.openstreetmap.josm.actions.MirrorAction;
 import org.openstreetmap.josm.actions.NewAction;
@@ -110 +112 @@
     public final JosmAction duplicate = new DuplicateAction();
     public final JosmAction delete = new DeleteAction();
+    public final JosmAction merge = new MergeLayerAction();
+    public final JosmAction mergeSelected = new MergeSelectionAction();
     public final JosmAction selectAll = new SelectAllAction();
     public final JosmAction unselectAll = new UnselectAllAction();
@@ -213 +217 @@
         add(editMenu, duplicate);
         add(editMenu, delete);
+        editMenu.addSeparator();
+        add(editMenu,merge);
+        add(editMenu,mergeSelected);
         editMenu.addSeparator();
         add(editMenu, selectAll);

trunk/src/org/openstreetmap/josm/gui/MapFrame.java

@@ -100 +100 @@
 
         toolBarToggle.setFloatable(false);
-        addToggleDialog(new LayerListDialog(this));
+        LayerListDialog.createInstance(this);
+        addToggleDialog(LayerListDialog.getInstance());
         addToggleDialog(new PropertiesDialog(this));
         addToggleDialog(new HistoryDialog());
@@ -133 +134 @@
      */
     public void destroy() {
-        for (ToggleDialog t : allDialogs)
+        for (ToggleDialog t : allDialogs) {
             t.close();
+        }
         for (int i = 0; i < toolBarActions.getComponentCount(); ++i)
-            if (toolBarActions.getComponent(i) instanceof Destroyable)
+            if (toolBarActions.getComponent(i) instanceof Destroyable) {
                 ((Destroyable)toolBarActions).destroy();
+            }
         for (int i = 0; i < toolBarToggle.getComponentCount(); ++i)
-            if (toolBarToggle.getComponent(i) instanceof Destroyable)
+            if (toolBarToggle.getComponent(i) instanceof Destroyable) {
                 ((Destroyable)toolBarToggle).destroy();
+            }
 
         // remove menu entries
@@ -195 +199 @@
         boolean old = isVisible();
         super.setVisible(aFlag);
-        if (old != aFlag)
+        if (old != aFlag) {
             firePropertyChange("visible", old, aFlag);
+        }
     }
 
@@ -209 +214 @@
         if (mapMode == this.mapMode)
             return;
-        if (this.mapMode != null)
+        if (this.mapMode != null) {
             this.mapMode.exitMode();
+        }
         this.mapMode = mapMode;
         mapMode.enterMode();
@@ -230 +236 @@
         if(Main.pref.getBoolean("sidetoolbar.visible", true))
         {
-            if(Main.pref.getBoolean("sidetoolbar.scrollable", true))
+            if(Main.pref.getBoolean("sidetoolbar.scrollable", true)) {
                 panel.add(new ScrollViewport(jb, ScrollViewport.VERTICAL_DIRECTION),
-                BorderLayout.WEST);
-            else
+                        BorderLayout.WEST);
+            } else {
                 panel.add(jb, BorderLayout.WEST);
-        }
-        if (statusLine != null && Main.pref.getBoolean("statusline.visible", true))
+            }
+        }
+        if (statusLine != null && Main.pref.getBoolean("statusline.visible", true)) {
             panel.add(statusLine, BorderLayout.SOUTH);
+        }
     }
 }

trunk/src/org/openstreetmap/josm/gui/MapView.java

@@ -15 +15 @@
 import java.awt.geom.GeneralPath;
 import java.awt.image.BufferedImage;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -57 +59 @@
  * @author imi
  */
-public class MapView extends NavigatableComponent {
+public class MapView extends NavigatableComponent implements PropertyChangeListener {
 
 
@@ -177 +179 @@
             }
         }
+        layer.addPropertyChangeListener(this);
         AudioPlayer.reset();
         repaint();
@@ -203 +206 @@
      */
     public boolean isActiveLayerVisible() {
-        return isActiveLayerDrawable() && activeLayer.visible;
+        return isActiveLayerDrawable() && activeLayer.isVisible();
     }
 
@@ -212 +215 @@
     public void removeLayer(Layer layer) {
         if (layer == activeLayer) {
+            for (Layer.LayerChangeListener l : Layer.listeners) {
+                l.activeLayerChange(layer, null);
+            }
             activeLayer = null;
         }
@@ -219 +225 @@
             }
         }
+        layer.removePropertyChangeListener(this);
         layer.destroy();
         AudioPlayer.reset();
@@ -283 +290 @@
         for (int i = layers.size()-1; i >= 0; --i) {
             Layer l = layers.get(i);
-            if (l.visible/* && l != getActiveLayer()*/) {
+            if (l.isVisible()/* && l != getActiveLayer()*/) {
                 l.paint(tempG, this);
             }
@@ -472 +479 @@
         return temporaryLayers.remove(mvp);
     }
+
+    public void propertyChange(PropertyChangeEvent evt) {
+        if (evt.getPropertyName().equals(Layer.VISIBLE_PROP)) {
+            repaint();
+        }
+    }
 }

trunk/src/org/openstreetmap/josm/gui/dialogs/LayerListDialog.java

@@ -9 +9 @@
 import java.awt.Point;
 import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseEvent;
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 
 import javax.swing.AbstractAction;
-import javax.swing.Action;
 import javax.swing.DefaultListCellRenderer;
 import javax.swing.DefaultListModel;
+import javax.swing.DefaultListSelectionModel;
 import javax.swing.Icon;
 import javax.swing.JLabel;
@@ -25 +30 @@
 import javax.swing.JPanel;
 import javax.swing.JScrollPane;
+import javax.swing.ListModel;
 import javax.swing.ListSelectionModel;
 import javax.swing.UIManager;
+import javax.swing.event.ListDataEvent;
+import javax.swing.event.ListDataListener;
 import javax.swing.event.ListSelectionEvent;
 import javax.swing.event.ListSelectionListener;
 
 import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.actions.MergeLayerAction;
 import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
 import org.openstreetmap.josm.gui.ExtendedDialog;
@@ -40 +49 @@
 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
 import org.openstreetmap.josm.tools.ImageProvider;
+import org.openstreetmap.josm.tools.Shortcut;
 import org.openstreetmap.josm.tools.ImageProvider.OverlayPosition;
-import org.openstreetmap.josm.tools.Shortcut;
 
 /**
- * A component that manages the list of all layers and react to selection changes
- * by setting the active layer in the mapview.
- *
- * @author imi
+ * This is a toggle dialog which displays the list of layers. Actions allow to
+ * change the ordering the layer, to hide/show layers, to activate layers
+ * and to delete layers.
+ * 
  */
-public class LayerListDialog extends ToggleDialog implements LayerChangeListener {
-
-    /**
-     * The last layerlist created. Used to update the list in the Show/Hide and Delete actions.
-     * TODO: Replace with Listener-Pattern.
-     */
-    static JList instance;
-    private JScrollPane listScrollPane;
-
-    public final static class DeleteLayerAction extends AbstractAction {
-
-        private final Layer layer;
-
+public class LayerListDialog extends ToggleDialog {
+
+    /** the unique instance of the dialog */
+    static private LayerListDialog instance;
+
+    /**
+     * Creates the instance of the dialog. It's connected to the map frame <code>mapFrame</code>
+     * 
+     * @param mapFrame the map frame
+     */
+    static public void createInstance(MapFrame mapFrame) {
+        instance = new LayerListDialog(mapFrame);
+    }
+
+    /**
+     * Replies the instance of the dialog
+     * 
+     * @return the instance of the dialog
+     * @throws IllegalStateException thrown, if the dialog is not created yet
+     * @see #createInstance(MapFrame)
+     */
+    static public LayerListDialog getInstance() throws IllegalStateException {
+        if (instance == null)
+            throw new IllegalStateException(tr("Dialog not created yet. Invoke createInstance() first"));
+        return instance;
+    }
+
+    /** the model for the layer list */
+    private LayerListModel model;
+
+    /** the selection model */
+    private DefaultListSelectionModel selectionModel;
+
+    /** the list of layers */
+    private LayerList layerList;
+
+    protected JPanel createButtonPanel() {
+        JPanel buttonPanel = new JPanel(new GridLayout(1, 5));
+
+        // -- move up action
+        MoveUpAction moveUpAction = new MoveUpAction();
+        adaptTo(moveUpAction, model);
+        adaptTo(moveUpAction,selectionModel);
+        buttonPanel.add(new SideButton(moveUpAction));
+
+        // -- move down action
+        MoveDownAction moveDownAction = new MoveDownAction();
+        adaptTo(moveDownAction, model);
+        adaptTo(moveDownAction,selectionModel);
+        buttonPanel.add(new SideButton(moveDownAction));
+
+        // -- activate action
+        ActivateLayerAction activateLayerAction = new ActivateLayerAction();
+        adaptTo(activateLayerAction, selectionModel);
+        buttonPanel.add(new SideButton(activateLayerAction, "activate"));
+
+        // -- show hide action
+        ShowHideLayerAction showHideLayerAction = new ShowHideLayerAction();
+        adaptTo(showHideLayerAction, selectionModel);
+        buttonPanel.add(new SideButton(showHideLayerAction, "showhide"));
+
+        // -- merge layer action
+        MergeAction mergeLayerAction = new MergeAction();
+        adaptTo(mergeLayerAction, model);
+        adaptTo(mergeLayerAction,selectionModel);
+        buttonPanel.add(new SideButton(mergeLayerAction));
+
+        //-- delete layer action
+        DeleteLayerAction deleteLayerAction = new DeleteLayerAction();
+        adaptTo(deleteLayerAction, selectionModel);
+        buttonPanel.add(new SideButton(deleteLayerAction, "delete"));
+
+        return buttonPanel;
+    }
+
+    /**
+     * Create an layerlist and attach it to the given mapView.
+     */
+    protected LayerListDialog(MapFrame mapFrame) {
+        super(tr("Layers"), "layerlist", tr("Open a list of all loaded layers."),
+                Shortcut.registerShortcut("subwindow:layers", tr("Toggle: {0}", tr("Layers")), KeyEvent.VK_L, Shortcut.GROUP_LAYER), 100);
+
+        // create the models
+        //
+        selectionModel = new DefaultListSelectionModel();
+        selectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+        model = new LayerListModel(selectionModel);
+        Layer.listeners.add(model);
+
+        // create the list control
+        //
+        layerList = new LayerList(model);
+        layerList.setSelectionModel(selectionModel);
+        layerList.addMouseListener(new LayerListMouseAdapter());
+        layerList.setBackground(UIManager.getColor("Button.background"));
+        layerList.setCellRenderer(new LayerListCellRenderer());
+        add(new JScrollPane(layerList), BorderLayout.CENTER);
+
+        // init the model
+        //
+        final MapView mapView = mapFrame.mapView;
+        model.populate(mapView.getAllLayers());
+        model.setSelectedLayer(mapView.getActiveLayer());
+        model.addLayerListModelListener(
+                new LayerListModelListener() {
+                    public void makeVisible(int index, Layer layer) {
+                        layerList.ensureIndexIsVisible(index);
+                    }
+                }
+        );
+
+        add(createButtonPanel(), BorderLayout.SOUTH);
+    }
+
+    public LayerListModel getModel() {
+        return model;
+    }
+
+    private interface IEnabledStateUpdating {
+        void updateEnabledState();
+    }
+
+    protected void adaptTo(final IEnabledStateUpdating listener, ListSelectionModel listSelectionModel) {
+        listSelectionModel.addListSelectionListener(
+                new ListSelectionListener() {
+                    public void valueChanged(ListSelectionEvent e) {
+                        listener.updateEnabledState();
+                    }
+                }
+        );
+    }
+
+    protected void adaptTo(final IEnabledStateUpdating listener, ListModel listModel) {
+        listModel.addListDataListener(
+                new ListDataListener() {
+                    public void contentsChanged(ListDataEvent e) {
+                        listener.updateEnabledState();
+                    }
+
+                    public void intervalAdded(ListDataEvent e) {
+                        listener.updateEnabledState();
+                    }
+
+                    public void intervalRemoved(ListDataEvent e) {
+                        listener.updateEnabledState();
+                    }
+                }
+        );
+    }
+
+    /**
+     * The action to delete the currently selected layer
+     */
+    public final  class DeleteLayerAction extends AbstractAction implements IEnabledStateUpdating {
+
+        private  Layer layer;
+
+        /**
+         * Creates a {@see DeleteLayerAction} for a specific layer.
+         * 
+         * @param layer the layer. Must not be null.
+         * @exception IllegalArgumentException thrown, if layer is null
+         */
         public DeleteLayerAction(Layer layer) {
-            super(tr("Delete"), ImageProvider.get("dialogs", "delete"));
+            this();
+            if (layer == null)
+                throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
+            this.layer = layer;
+            putValue(NAME, tr("Delete"));
+            updateEnabledState();
+        }
+
+        /**
+         * Creates a {@see DeleteLayerAction} which will delete the currently
+         * selected layers in the layer dialog.
+         * 
+         */
+        public DeleteLayerAction() {
+            putValue(SMALL_ICON,ImageProvider.get("dialogs", "delete"));
             putValue(SHORT_DESCRIPTION, tr("Delete the selected layer."));
             putValue("help", "Action/LayerDelete");
+            updateEnabledState();
+        }
+
+        protected boolean confirmSkipSaving(OsmDataLayer layer) {
+            int result = new ExtendedDialog(Main.parent,
+                    tr("Unsaved Changes"),
+                    tr("There are unsaved changes in the layer''{0}''. Delete the layer anwyay?",layer.getName()),
+                    new String[] {tr("Delete Layer"), tr("Cancel")},
+                    new String[] {"dialogs/delete.png", "cancel.png"}).getValue();
+
+            return result != 1;
+        }
+
+        protected boolean confirmDeleteLayer(Layer layer) {
+            return ConditionalOptionPaneUtil.showConfirmationDialog(
+                    "delete_layer",
+                    Main.parent,
+                    tr("Do you really want to delete the whole layer ''{0}''?", layer.getName()),
+                    tr("Confirmation"),
+                    JOptionPane.YES_NO_OPTION,
+                    JOptionPane.QUESTION_MESSAGE,
+                    JOptionPane.YES_OPTION);
+        }
+
+        public void deleteLayer(Layer layer) {
+            if (layer == null)
+                return;
+            if (layer instanceof OsmDataLayer) {
+                OsmDataLayer dataLayer = (OsmDataLayer)layer;
+                if (dataLayer.isModified() && ! confirmSkipSaving(dataLayer))
+                    return;
+                else if (!confirmDeleteLayer(dataLayer))
+                    return;
+
+            } else {
+                if (!confirmDeleteLayer(layer))
+                    return;
+            }
+            // model and view are going to be updated via LayerChangeListener
+            //
+            Main.main.removeLayer(layer);
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            if (this.layer == null) {
+                List<Layer> selectedLayers = getModel().getSelectedLayers();
+                for (Layer layer: selectedLayers) {
+                    deleteLayer(layer);
+                }
+            } else {
+                deleteLayer(this.layer);
+            }
+        }
+
+        public void updateEnabledState() {
+            if (layer == null) {
+                setEnabled(! getModel().getSelectedLayers().isEmpty());
+            } else {
+                setEnabled(true);
+            }
+        }
+    }
+
+    public final class ShowHideLayerAction extends AbstractAction implements IEnabledStateUpdating {
+        private  Layer layer;
+
+        /**
+         * Creates a {@see ShowHideLayerAction} which toggle the visibility of
+         * a specific layer.
+         * 
+         * @param layer  the layer. Must not be null.
+         * @exception IllegalArgumentException thrown, if layer is null
+         */
+        public ShowHideLayerAction(Layer layer) throws IllegalArgumentException {
+            this();
+            if (layer == null)
+                throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
             this.layer = layer;
-        }
-
-        public void actionPerformed(ActionEvent e) {
-            int sel = instance.getSelectedIndex();
-            Layer l = layer != null ? layer : (Layer)instance.getSelectedValue();
-            if(l == null)
-                return;
-            if (l instanceof OsmDataLayer)
-            {
-                if (((OsmDataLayer)l).isModified())
-                {
-                    int result = new ExtendedDialog(Main.parent, tr("Unsaved Changes"),
-                            tr("There are unsaved changes. Delete the layer anwyay?"),
-                            new String[] {tr("Delete Layer"), tr("Cancel")},
-                            new String[] {"dialogs/delete.png", "cancel.png"}).getValue();
-
-                    if(result != 1) return;
-                }
-                else if (!ConditionalOptionPaneUtil.showConfirmationDialog(
-                        "delete_layer",
-                        Main.parent,
-                        tr("Do you really want to delete the whole layer?"),
-                        tr("Confirmation"),
-                        JOptionPane.YES_NO_OPTION,
-                        JOptionPane.QUESTION_MESSAGE,
-                        JOptionPane.YES_OPTION))
-                    return;
-            }
-            Main.main.removeLayer(l);
-            if (sel >= instance.getModel().getSize()) {
-                sel = instance.getModel().getSize()-1;
-            }
-            if (instance.getSelectedValue() == null) {
-                instance.setSelectedIndex(sel);
-            }
-            if (Main.map != null) {
-                Main.map.mapView.setActiveLayer((Layer)instance.getSelectedValue());
-            }
-        }
-    }
-
-    public final static class ShowHideLayerAction extends AbstractAction {
-        private final Layer layer;
-
-        public ShowHideLayerAction(Layer layer) {
-            super(tr("Show/Hide"), ImageProvider.get("dialogs", "showhide"));
+            putValue(NAME, tr("Show/Hide"));
+            updateEnabledState();
+        }
+
+        /**
+         * Creates a {@see ShowHideLayerAction} which will toggle the visibility of
+         * the currently selected layers
+         * 
+         */
+        public ShowHideLayerAction() {
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "showhide"));
             putValue(SHORT_DESCRIPTION, tr("Toggle visible state of the selected layer."));
             putValue("help", "Action/LayerShowHide");
+            updateEnabledState();
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            if (layer != null) {
+                layer.toggleVisible();
+            } else {
+                for(Layer layer: model.getSelectedLayers()) {
+                    layer.toggleVisible();
+                }
+            }
+        }
+
+        public void updateEnabledState() {
+            if (layer == null) {
+                setEnabled(! getModel().getSelectedLayers().isEmpty());
+            } else {
+                setEnabled(true);
+            }
+        }
+    }
+
+    /**
+     * The action to activate the currently selected layer
+     */
+
+    public final class ActivateLayerAction extends AbstractAction implements IEnabledStateUpdating{
+        private  Layer layer;
+
+        public ActivateLayerAction(Layer layer) throws IllegalArgumentException {
+            this();
+            if (layer == null)
+                throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
             this.layer = layer;
+            putValue(NAME, tr("Activate"));
+            updateEnabledState();
+        }
+
+        public ActivateLayerAction() {
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "activate"));
+            putValue(SHORT_DESCRIPTION, tr("Activate the selected layer"));
+            putValue("help", "Action/ActivateLayer");
+            updateEnabledState();
         }
 
         public void actionPerformed(ActionEvent e) {
-            Layer l = layer == null ? (Layer)instance.getSelectedValue() : layer;
-            if(l == null)
+            Layer toActivate;
+            if (layer != null) {
+                toActivate = layer;
+            } else {
+                toActivate = model.getSelectedLayers().get(0);
+            }
+            getModel().activateLayer(toActivate);
+        }
+
+        protected boolean isActiveLayer(Layer layer) {
+            if (Main.map == null) return false;
+            if (Main.map.mapView == null) return false;
+            return Main.map.mapView.getActiveLayer() == layer;
+        }
+
+        public void updateEnabledState() {
+            if (layer == null) {
+                if (getModel().getSelectedLayers().size() != 1) {
+                    setEnabled(false);
+                    return;
+                }
+                Layer selectedLayer = getModel().getSelectedLayers().get(0);
+                setEnabled(!isActiveLayer(selectedLayer));
+            } else {
+                setEnabled(!isActiveLayer(layer));
+            }
+        }
+    }
+
+    /**
+     * The action to merge the currently selected layer into another layer.
+     */
+    public final class MergeAction extends AbstractAction implements IEnabledStateUpdating {
+        private  Layer layer;
+
+        public MergeAction(Layer layer) throws IllegalArgumentException {
+            this();
+            if (layer == null)
+                throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "layer"));
+            this.layer = layer;
+            putValue(NAME, tr("Merge"));
+            updateEnabledState();
+        }
+
+        public MergeAction() {
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "mergedown"));
+            putValue(SHORT_DESCRIPTION, tr("Merge this layer into another layer"));
+            putValue("help", "Action/MergeLayer");
+            updateEnabledState();
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            if (layer != null) {
+                new MergeLayerAction().merge(layer);
+            } else {
+                Layer selectedLayer = getModel().getSelectedLayers().get(0);
+                new MergeLayerAction().merge(selectedLayer);
+            }
+        }
+
+        protected boolean isActiveLayer(Layer layer) {
+            if (Main.map == null) return false;
+            if (Main.map.mapView == null) return false;
+            return Main.map.mapView.getActiveLayer() == layer;
+        }
+
+        public void updateEnabledState() {
+            if (layer == null) {
+                if (getModel().getSelectedLayers().size() != 1) {
+                    setEnabled(false);
+                    return;
+                }
+                Layer selectedLayer = getModel().getSelectedLayers().get(0);
+                List<Layer> targets = getModel().getPossibleMergeTargets(selectedLayer);
+                setEnabled(!targets.isEmpty());
+            } else {
+                List<Layer> targets = getModel().getPossibleMergeTargets(layer);
+                setEnabled(!targets.isEmpty());
+            }
+        }
+    }
+
+    /**
+     * the list cell renderer used to render layer list entries
+     *
+     */
+    class LayerListCellRenderer extends DefaultListCellRenderer {
+
+        protected boolean isActiveLayer(Layer layer) {
+            if (Main.map == null) return false;
+            if (Main.map.mapView == null) return false;
+            return Main.map.mapView.getActiveLayer() == layer;
+        }
+
+        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
+            Layer layer = (Layer)value;
+            JLabel label = (JLabel)super.getListCellRendererComponent(list,
+                    layer.getName(), index, isSelected, cellHasFocus);
+            Icon icon = layer.getIcon();
+            if (isActiveLayer(layer)) {
+                icon = ImageProvider.overlay(icon, "overlay/active", OverlayPosition.SOUTHWEST);
+            }
+            if (!layer.isVisible()) {
+                icon = ImageProvider.overlay(icon, "overlay/invisiblenew", OverlayPosition.SOUTHEAST);
+            }
+            label.setIcon(icon);
+            label.setToolTipText(layer.getToolTipText());
+            return label;
+        }
+    }
+
+    class LayerListMouseAdapter extends MouseAdapter {
+
+        private void openPopup(MouseEvent e) {
+            Point p = e.getPoint();
+            int index = layerList.locationToIndex(p);
+            if (index < 0) return;
+            if (!layerList.getCellBounds(index, index).contains(e.getPoint()))
                 return;
-            l.visible = !l.visible;
-            Main.map.mapView.repaint();
-            instance.repaint();
-        }
-    }
-
-    public final static class ShowHideMarkerText extends AbstractAction {
-        private final Layer layer;
-
-        public ShowHideMarkerText(Layer layer) {
-            super(tr("Show/Hide Text/Icons"), ImageProvider.get("dialogs", "showhide"));
-            putValue(SHORT_DESCRIPTION, tr("Toggle visible state of the marker text and icons."));
-            putValue("help", "Action/ShowHideTextIcons");
-            this.layer = layer;
+            Layer layer = model.getLayer(index);
+            LayerListPopup menu = new LayerListPopup(layerList, layer);
+            menu.show(LayerListDialog.this, p.x, p.y-3);
+        }
+        @Override public void mousePressed(MouseEvent e) {
+            if (e.isPopupTrigger()) {
+                openPopup(e);
+            }
+        }
+        @Override public void mouseReleased(MouseEvent e) {
+            if (e.isPopupTrigger()) {
+                openPopup(e);
+            }
+        }
+        @Override public void mouseClicked(MouseEvent e) {
+            if (e.getClickCount() == 2) {
+                int index = layerList.locationToIndex(e.getPoint());
+                if (!layerList.getCellBounds(index, index).contains(e.getPoint()))
+                    return;
+                Layer layer = model.getLayer(index);
+                String current = Main.pref.get("marker.show "+layer.getName(),"show");
+                Main.pref.put("marker.show "+layer.getName(), current.equalsIgnoreCase("show") ? "hide" : "show");
+                layer.toggleVisible();
+            }
+        }
+    }
+
+    /**
+     * The action to move up the currently selected entries in the list.
+     */
+    class MoveUpAction extends AbstractAction implements  IEnabledStateUpdating{
+        public MoveUpAction() {
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "up"));
+            putValue(SHORT_DESCRIPTION, tr("Move the selected layer one row up."));
+            updateEnabledState();
+        }
+
+        public void updateEnabledState() {
+            setEnabled(model.canMoveUp());
         }
 
         public void actionPerformed(ActionEvent e) {
-            Layer l = layer == null ? (Layer)instance.getSelectedValue() : layer;
-            String current = Main.pref.get("marker.show "+l.name,"show");
-            Main.pref.put("marker.show "+l.name, current.equalsIgnoreCase("show") ? "hide" : "show");
-            Main.map.mapView.repaint();
-            instance.repaint();
-        }
-    }
-
-    /**
-     * The data model for the list component.
-     */
-    DefaultListModel model = new DefaultListModel();
-    /**
-     * The merge action. This is only called, if the current selection and its
-     * item below are editable datasets and the merge button is clicked.
-     */
-    private final SideButton mergeButton;
-    /**
-     * Button for moving layer up.
-     */
-    private final SideButton upButton;
-    /**
-     * Button for moving layer down.
-     */
-    private final SideButton downButton;
-    /**
-     * Button for delete layer.
-     */
-    private Action deleteAction = new DeleteLayerAction(null);
-
-    /**
-     * Create an layerlist and attach it to the given mapView.
-     */
-    public LayerListDialog(MapFrame mapFrame) {
-        super(tr("Layers"), "layerlist", tr("Open a list of all loaded layers."),
-                Shortcut.registerShortcut("subwindow:layers", tr("Toggle: {0}", tr("Layers")), KeyEvent.VK_L, Shortcut.GROUP_LAYER), 100);
-        instance = new JList(model) {
-            @Override
-            protected void processMouseEvent(MouseEvent e) {
-                // if the layer list is embedded in a detached dialog, the last row is
-                // is selected if a user clicks in the empty space *below* the last row.
-                // This mouse event filter prevents this.
-                //
-                int idx = locationToIndex(e.getPoint());
-                if (getCellBounds(idx, idx).contains(e.getPoint())) {
-                    super.processMouseEvent(e);
-                }
-            }
-        };
-        listScrollPane = new JScrollPane(instance);
-        add(listScrollPane, BorderLayout.CENTER);
-        instance.setBackground(UIManager.getColor("Button.background"));
-        instance.setCellRenderer(new DefaultListCellRenderer(){
-            @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
-                Layer layer = (Layer)value;
-                JLabel label = (JLabel)super.getListCellRendererComponent(list,
-                        layer.name, index, isSelected, cellHasFocus);
-                Icon icon = layer.getIcon();
-                if (!layer.visible) {
-                    icon = ImageProvider.overlay(icon, "overlay/invisible", OverlayPosition.SOUTHEAST);
-                }
-                label.setIcon(icon);
-                label.setToolTipText(layer.getToolTipText());
-                return label;
-            }
-        });
-
-        final MapView mapView = mapFrame.mapView;
-
-        Collection<Layer> data = mapView.getAllLayers();
-        for (Layer l : data) {
-            model.addElement(l);
-        }
-
-        instance.setSelectedValue(mapView.getActiveLayer(), true);
-        instance.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
-        instance.addListSelectionListener(new ListSelectionListener(){
-            public void valueChanged(ListSelectionEvent e) {
-                if (instance.getModel().getSize() == 0)
-                    return;
-                if (instance.getSelectedIndex() == -1) {
-                    instance.setSelectedIndex(e.getFirstIndex());
-                }
-                mapView.setActiveLayer((Layer)instance.getSelectedValue());
-            }
-        });
-        Layer.listeners.add(this);
-
-        instance.addMouseListener(new MouseAdapter(){
-            private void openPopup(MouseEvent e) {
-                Point p = e.getPoint();
-                int index = instance.locationToIndex(p);
-                Layer layer = (Layer)instance.getModel().getElementAt(index);
-                LayerListPopup menu = new LayerListPopup(instance, layer);
-                menu.show(listScrollPane, p.x, p.y-3);
-            }
-            @Override public void mousePressed(MouseEvent e) {
-                if (e.isPopupTrigger()) {
-                    openPopup(e);
-                }
-            }
-            @Override public void mouseReleased(MouseEvent e) {
-                if (e.isPopupTrigger()) {
-                    openPopup(e);
-                }
-            }
-            @Override public void mouseClicked(MouseEvent e) {
-                if (e.getClickCount() == 2) {
-                    int index = instance.locationToIndex(e.getPoint());
-                    Layer layer = (Layer)instance.getModel().getElementAt(index);
-                    String current = Main.pref.get("marker.show "+layer.name,"show");
-                    Main.pref.put("marker.show "+layer.name, current.equalsIgnoreCase("show") ? "hide" : "show");
-                    layer.visible = !layer.visible;
-                    Main.map.mapView.repaint();
-                    instance.repaint();
-                }
-            }
-        });
-
-
-        // Buttons
-        JPanel buttonPanel = new JPanel(new GridLayout(1, 5));
-
-        ActionListener upDown = new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                Layer l = (Layer)instance.getSelectedValue();
-                int sel = instance.getSelectedIndex();
-                int selDest = e.getActionCommand().equals("up") ? sel-1 : sel+1;
-                mapView.moveLayer(l, selDest);
-                model.set(sel, model.get(selDest));
-                model.set(selDest, l);
-                instance.setSelectedIndex(selDest);
-                updateButtonEnabled();
-                mapView.repaint();
-            }
-        };
-
-        upButton = new SideButton("up", "LayerList", tr("Move the selected layer one row up."), upDown);
-        buttonPanel.add(upButton);
-
-        downButton = new SideButton("down", "LayerList", tr("Move the selected layer one row down."), upDown);
-        buttonPanel.add(downButton);
-
-        buttonPanel.add(new SideButton(new ShowHideLayerAction(null), "showhide"));
-        buttonPanel.add(new SideButton(deleteAction, "delete"));
-
-        mergeButton = new SideButton("mergedown", "LayerList", tr("Merge the layer directly below into the selected layer."),
-                new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                Layer lTo = (Layer)instance.getSelectedValue();
-                Layer lFrom = (Layer)model.get(instance.getSelectedIndex()+1);
-                lTo.mergeFrom(lFrom);
-                mapView.removeLayer(lFrom);
-                updateButtonEnabled();
-                mapView.repaint();
-            }
-        });
-        buttonPanel.add(mergeButton);
-
-        add(buttonPanel, BorderLayout.SOUTH);
-
-        updateButtonEnabled();
-    }
-
-    /**
-     * Updates the state of the Buttons.
-     */
-    void updateButtonEnabled() {
-        int sel = instance.getSelectedIndex();
-        Layer l = (Layer)instance.getSelectedValue();
-        boolean enable = model.getSize() > 1;
-        enable = enable && sel < model.getSize()-1;
-        enable = enable && ((Layer)model.get(sel+1)).isMergable(l);
-        mergeButton.setEnabled(enable);
-        upButton.setEnabled(sel > 0);
-        downButton.setEnabled(sel >= 0 && sel < model.getSize()-1);
-        deleteAction.setEnabled(!model.isEmpty());
-
-        if(model.getSize() != 0) {
-            setTitle(tr("Layers: {0}", model.getSize()), true);
-        } else {
-            setTitle(tr("Layers"), false);
-        }
-    }
-
-    /**
-     * Add the new layer to the list.
-     */
-    public void layerAdded(Layer newLayer) {
-        int pos = Main.map.mapView.getLayerPos(newLayer);
-        model.add(pos, newLayer);
-        updateButtonEnabled();
-    }
-
-    public void layerRemoved(Layer oldLayer) {
-        model.removeElement(oldLayer);
-        if (model.isEmpty()) {
-            Layer.listeners.remove(this);
-            return;
-        }
-        if (instance.getSelectedIndex() == -1) {
-            instance.setSelectedIndex(0);
-        }
-        updateButtonEnabled();
-    }
-
-    /**
-     * If the newLayer is not the actual selection, select it.
-     */
-    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
-        if (newLayer != instance.getSelectedValue()) {
-            instance.setSelectedValue(newLayer, true);
-        }
-        updateButtonEnabled();
+            model.moveUp();
+        }
+    }
+
+    /**
+     * The action to move down the currently selected entries in the list.
+     */
+    class MoveDownAction extends AbstractAction implements IEnabledStateUpdating {
+        public MoveDownAction() {
+            putValue(SMALL_ICON, ImageProvider.get("dialogs", "down"));
+            putValue(SHORT_DESCRIPTION, tr("Move the selected layer one row down."));
+            updateEnabledState();
+        }
+
+        public void updateEnabledState() {
+            setEnabled(model.canMoveDown());
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            model.moveDown();
+        }
+    }
+
+    /**
+     * Observer interface to be implemented by views using {@see LayerListModel}
+     *
+     */
+    public interface LayerListModelListener {
+        public void makeVisible(int index, Layer layer);
+    }
+
+    /**
+     * The layer list model. The model manages a list of layers and provides methods for
+     * moving layers up and down, for toggling their visibiliy, for activating a layer.
+     * 
+     * The model is a {@see ListModel} and it provides a {@see ListSelectionModel}. It expectes
+     * to be configured with a {@see DefaultListSelectionModel}. The selection model is used
+     * to update the selection state of views depending on messages sent to the model.
+     * 
+     * The model manages a list of {@see LayerListModelListener} which are mainly notified if
+     * the model requires views to make a specific list entry visible.
+     */
+    public class LayerListModel extends DefaultListModel implements LayerChangeListener, PropertyChangeListener{
+
+        private ArrayList<Layer> layers;
+        private DefaultListSelectionModel selectionModel;
+        private CopyOnWriteArrayList<LayerListModelListener> listeners;
+
+        private LayerListModel(DefaultListSelectionModel selectionModel) {
+            layers = new ArrayList<Layer>();
+            this.selectionModel = selectionModel;
+            listeners = new CopyOnWriteArrayList<LayerListModelListener>();
+        }
+
+        public void addLayerListModelListener(LayerListModelListener listener) {
+            synchronized(listeners) {
+                if (listener != null && !listeners.contains(listener)) {
+                    listeners.add(listener);
+                }
+            }
+        }
+
+        public void removeLayerListModelListener(LayerListModelListener listener) {
+            synchronized(listeners) {
+                if (listener != null && listeners.contains(listener)) {
+                    listeners.remove(listener);
+                }
+            }
+        }
+
+        protected void fireMakeVisible(int index, Layer layer) {
+            for (LayerListModelListener listener : listeners) {
+                listener.makeVisible(index, layer);
+            }
+        }
+
+        public void populate(Collection<Layer> layers) {
+            if (layers == null)
+                return;
+            this.layers.clear();
+            this.layers.addAll(layers);
+            for (Layer layer: this.layers) {
+                layer.addPropertyChangeListener(this);
+            }
+            fireContentsChanged(this, 0, getSize());
+        }
+
+        public void setSelectedLayer(Layer layer) {
+            int idx = layers.indexOf(layer);
+            if (idx >= 0) {
+                selectionModel.setSelectionInterval(idx, idx);
+            }
+            fireContentsChanged(this, 0, getSize());
+            ensureSelectedIsVisible();
+        }
+
+        public List<Layer> getSelectedLayers() {
+            ArrayList<Layer> selected = new ArrayList<Layer>();
+            for (int i=0; i<layers.size(); i++) {
+                if (selectionModel.isSelectedIndex(i)) {
+                    selected.add(layers.get(i));
+                }
+            }
+            return selected;
+        }
+
+        public List<Integer> getSelectedRows() {
+            ArrayList<Integer> selected = new ArrayList<Integer>();
+            for (int i=0; i<layers.size();i++) {
+                if (selectionModel.isSelectedIndex(i)) {
+                    selected.add(i);
+                }
+            }
+            return selected;
+        }
+
+        public void removeLayer(Layer layer) {
+            if (layer == null)
+                return;
+            List<Integer> selectedRows = getSelectedRows();
+            int deletedRow = layers.indexOf(layer);
+            if (deletedRow < 0)
+                // layer not found in the list of layers
+                return;
+            layers.remove(layer);
+            fireContentsChanged(this, 0,getSize());
+            for (int row: selectedRows) {
+                if (row < deletedRow) {
+                    selectionModel.addSelectionInterval(row, row);
+                } else if (row == deletedRow){
+                    // do nothing
+                } else {
+                    selectionModel.addSelectionInterval(row-1, row-1);
+                }
+            }
+            ensureSelectedIsVisible();
+        }
+
+        public void addLayer(Layer layer) {
+            if (layer == null) return;
+            if (layers.contains(layer)) return;
+            layers.add(layer);
+            layer.addPropertyChangeListener(this);
+            fireContentsChanged(this, 0, getSize());
+        }
+
+        public Layer getFirstLayer() {
+            if (getSize() == 0) return null;
+            return layers.get(0);
+        }
+
+        public Layer getLayer(int index) {
+            if (index < 0 || index >= getSize())
+                return null;
+            return layers.get(index);
+        }
+
+        public boolean canMoveUp() {
+            List<Integer> sel = getSelectedRows();
+            return !sel.isEmpty() && sel.get(0) > 0;
+        }
+
+        public void moveUp() {
+            if (!canMoveUp()) return;
+            List<Integer> sel = getSelectedRows();
+            for (int row: sel) {
+                Layer l1 = layers.get(row);
+                Layer l2 = layers.get(row-1);
+                layers.set(row, l2);
+                layers.set(row-1,l1);
+                Main.map.mapView.moveLayer(l1, row-1);
+            }
+            fireContentsChanged(this, 0, getSize());
+            selectionModel.clearSelection();
+            for(int row: sel) {
+                selectionModel.addSelectionInterval(row-1, row-1);
+            }
+            ensureSelectedIsVisible();
+        }
+
+        public boolean canMoveDown() {
+            List<Integer> sel = getSelectedRows();
+            return !sel.isEmpty() && sel.get(sel.size()-1) < layers.size()-1;
+        }
+
+        public void moveDown() {
+            if (!canMoveDown()) return;
+            List<Integer> sel = getSelectedRows();
+            Collections.reverse(sel);
+            for (int row: sel) {
+                Layer l1 = layers.get(row);
+                Layer l2 = layers.get(row+1);
+                layers.set(row, l2);
+                layers.set(row+1,l1);
+                Main.map.mapView.moveLayer(l1, row+1);
+            }
+            fireContentsChanged(this, 0, getSize());
+            selectionModel.clearSelection();
+            for(int row: sel) {
+                selectionModel.addSelectionInterval(row+1, row+1);
+            }
+            ensureSelectedIsVisible();
+        }
+
+        protected void ensureSelectedIsVisible() {
+            int index = selectionModel.getMinSelectionIndex();
+            if (index <0 )return;
+            if (index >= layers.size()) return;
+            Layer layer = layers.get(index);
+            fireMakeVisible(index, layer);
+        }
+
+        public List<Layer> getPossibleMergeTargets(Layer layer) {
+            ArrayList<Layer> targets = new ArrayList<Layer>();
+            if (layer == null)
+                return targets;
+            for(Layer target: layers) {
+                if (layer == target) {
+                    continue;
+                }
+                if (target.isMergable(layer)) {
+                    targets.add(target);
+                }
+            }
+            return targets;
+        }
+
+        public void activateLayer(Layer layer) {
+            layers.remove(layer);
+            layers.add(0,layer);
+            Main.map.mapView.setActiveLayer(layer);
+            layer.setVisible(true);
+            selectionModel.setSelectionInterval(0,0);
+            ensureSelectedIsVisible();
+        }
+
+        /* ------------------------------------------------------------------------------ */
+        /* Interface ListModel                                                            */
+        /* ------------------------------------------------------------------------------ */
+        @Override
+        public Object getElementAt(int index) {
+            return layers.get(index);
+        }
+
+        @Override
+        public int getSize() {
+            return layers.size();
+        }
+
+        /* ------------------------------------------------------------------------------ */
+        /* Interface LayerChangeListener                                                  */
+        /* ------------------------------------------------------------------------------ */
+        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
+            if (oldLayer != null) {
+                int idx = layers.indexOf(oldLayer);
+                if (idx >= 0) {
+                    fireContentsChanged(this, idx,idx);
+                }
+            }
+
+            if (newLayer != null) {
+                int idx = layers.indexOf(newLayer);
+                if (idx >= 0) {
+                    fireContentsChanged(this, idx,idx);
+                }
+            }
+        }
+
+        public void layerAdded(Layer newLayer) {
+            addLayer(newLayer);
+        }
+
+        public void layerRemoved(Layer oldLayer) {
+            removeLayer(oldLayer);
+        }
+
+        /* ------------------------------------------------------------------------------ */
+        /* Interface PropertyChangeListener                                               */
+        /* ------------------------------------------------------------------------------ */
+        public void propertyChange(PropertyChangeEvent evt) {
+            if (evt.getSource() instanceof Layer) {
+                Layer layer = (Layer)evt.getSource();
+                int idx = layers.indexOf(layer);
+                if (idx < 0) return;
+                fireContentsChanged(this, idx, idx);
+            }
+        }
+    }
+
+    class LayerList extends JList {
+        public LayerList(ListModel dataModel) {
+            super(dataModel);
+        }
+
+        @Override
+        protected void processMouseEvent(MouseEvent e) {
+            // if the layer list is embedded in a detached dialog, the last row is
+            // is selected if a user clicks in the empty space *below* the last row.
+            // This mouse event filter prevents this.
+            //
+            int idx = locationToIndex(e.getPoint());
+            if (getCellBounds(idx, idx).contains(e.getPoint())) {
+                super.processMouseEvent(e);
+            }
+        }
+    }
+
+    public ShowHideLayerAction createShowHideLayerAction(Layer layer) {
+        return new ShowHideLayerAction(layer);
+    }
+
+    public DeleteLayerAction createDeleteLayerAction(Layer layer) {
+        return new DeleteLayerAction(layer);
+    }
+
+    public ActivateLayerAction createActivateLayerAction(Layer layer) {
+        return new ActivateLayerAction(layer);
+    }
+
+    public MergeAction createMergeLayerAction(Layer layer) {
+        return new MergeAction(layer);
     }
 }

trunk/src/org/openstreetmap/josm/gui/dialogs/relation/GenericRelationEditor.java

@@ -660 +660 @@
             );
             switch(ret) {
-            case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return;
-            case JOptionPane.CLOSED_OPTION: return;
-            case JOptionPane.NO_OPTION: return;
-            case JOptionPane.YES_OPTION:
-                memberTableModel.removeMembersReferringTo(toCheck);
-                break;
+                case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return;
+                case JOptionPane.CLOSED_OPTION: return;
+                case JOptionPane.NO_OPTION: return;
+                case JOptionPane.YES_OPTION:
+                    memberTableModel.removeMembersReferringTo(toCheck);
+                    break;
             }
         }
@@ -698 +698 @@
             );
             switch(ret) {
-            case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION : return true;
-            case JOptionPane.YES_OPTION: return true;
-            case JOptionPane.NO_OPTION: return false;
-            case JOptionPane.CLOSED_OPTION: return false;
-            case JOptionPane.CANCEL_OPTION: throw new AddAbortException();
+                case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION : return true;
+                case JOptionPane.YES_OPTION: return true;
+                case JOptionPane.NO_OPTION: return false;
+                case JOptionPane.CLOSED_OPTION: return false;
+                case JOptionPane.CANCEL_OPTION: throw new AddAbortException();
             }
             // should not happen
@@ -1073 +1073 @@
             );
             switch(ret) {
-            case JOptionPane.CANCEL_OPTION: return false;
-            case JOptionPane.YES_OPTION: return true;
-            case JOptionPane.NO_OPTION: return false;
+                case JOptionPane.CANCEL_OPTION: return false;
+                case JOptionPane.YES_OPTION: return true;
+                case JOptionPane.NO_OPTION: return false;
             }
             return false;
@@ -1314 +1314 @@
             );
             switch(ret) {
-            case JOptionPane.YES_OPTION: return true;
-            case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return true;
-            default:
-                return false;
+                case JOptionPane.YES_OPTION: return true;
+                case ConditionalOptionPaneUtil.DIALOG_DISABLED_OPTION: return true;
+                default:
+                    return false;
             }
         }

trunk/src/org/openstreetmap/josm/gui/layer/GeoImageLayer.java

@@ -266 +266 @@
             MapFrame frame = Main.map;
             if (frame != null) {
-              frame.mapView.repaint();
+                frame.mapView.repaint();
             }
         }
@@ -276 +276 @@
         private final GpxLayer gpxLayer;
         public Loader(Collection<File> files, GpxLayer gpxLayer) {
-            super(tr("Images for {0}", gpxLayer.name));
+            super(tr("Images for {0}", gpxLayer.getName()));
             this.files = files;
             this.gpxLayer = gpxLayer;
@@ -412 +412 @@
                     return;
                 mousePressed  = true;
-                if (visible) {
+                if (isVisible()) {
                     Main.map.mapView.repaint();
                 }
@@ -420 +420 @@
                     return;
                 mousePressed = false;
-                if (!visible)
+                if (!isVisible())
                     return;
                 for (int i = data.size(); i > 0; --i) {
@@ -699 +699 @@
         });
         return new Component[]{
-                new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)),
                 new JSeparator(),
                 sync,

trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

@@ -45 +45 @@
 import org.openstreetmap.josm.Main;
 import org.openstreetmap.josm.actions.RenameLayerAction;
-import org.openstreetmap.josm.actions.SaveAction;
-import org.openstreetmap.josm.actions.SaveAsAction;
 import org.openstreetmap.josm.actions.downloadtasks.DownloadOsmTaskList;
 import org.openstreetmap.josm.data.coor.EastNorth;
@@ -91 +89 @@
     public GpxLayer(GpxData d, String name) {
         this(d);
-        this.name = name;
+        this.setName(name);
     }
 
     public GpxLayer(GpxData d, String name, boolean isLocal) {
         this(d);
-        this.name = name;
+        this.setName(name);
         this.isLocalFile = isLocal;
     }
@@ -129 +127 @@
                     panel.add(b);
                 }
-                String propName = "draw.rawgps.lines.layer " + name;
+                String propName = "draw.rawgps.lines.layer " + getName();
                 if (Main.pref.hasKey(propName)) {
                     group.setSelected(r[Main.pref.getBoolean(propName) ? 1 : 2].getModel(), true);
@@ -157 +155 @@
         color.addActionListener(new ActionListener() {
             public void actionPerformed(ActionEvent e) {
-                JColorChooser c = new JColorChooser(getColor(name));
+                JColorChooser c = new JColorChooser(getColor(getName()));
                 Object[] options = new Object[] { tr("OK"), tr("Cancel"), tr("Default") };
                 int answer = OptionPaneUtil.showOptionDialog(
@@ -169 +167 @@
                 switch (answer) {
                     case 0:
-                        Main.pref.putColor("layer " + name, c.getColor());
+                        Main.pref.putColor("layer " + getName(), c.getColor());
                         break;
                     case 1:
                         return;
                     case 2:
-                        Main.pref.putColor("layer " + name, null);
+                        Main.pref.putColor("layer " + getName(), null);
                         break;
                 }
@@ -196 +194 @@
                 }
 
-                MarkerLayer ml = new MarkerLayer(namedTrackPoints, tr("Named Trackpoints from {0}", name),
+                MarkerLayer ml = new MarkerLayer(namedTrackPoints, tr("Named Trackpoints from {0}", getName()),
                         getAssociatedFile(), me);
                 if (ml.data.size() > 0) {
@@ -256 +254 @@
                         names = "";
                     }
-                    MarkerLayer ml = new MarkerLayer(new GpxData(), tr("Audio markers from {0}", name) + names,
+                    MarkerLayer ml = new MarkerLayer(new GpxData(), tr("Audio markers from {0}", getName()) + names,
                             getAssociatedFile(), me);
                     if (sel != null) {
@@ -312 +310 @@
 
         if (Main.applet)
-            return new Component[] { new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)), new JSeparator(), color, line,
+            return new Component[] { new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)), new JSeparator(), color, line,
                 new JMenuItem(new ConvertToDataLayerAction()), new JSeparator(),
                 new JMenuItem(new RenameLayerAction(getAssociatedFile(), this)), new JSeparator(),
                 new JMenuItem(new LayerListPopup.InfoAction(this)) };
-        return new Component[] { new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)), new JSeparator(),
+        return new Component[] { new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)), new JSeparator(),
                 new JMenuItem(new LayerSaveAction(this)), new JMenuItem(new LayerSaveAsAction(this)), color, line,
                 tagimage, importAudio, markersFromNamedTrackpoints, new JMenuItem(new ConvertToDataLayerAction()),
@@ -416 +414 @@
          ****************************************************************/
         // Long startTime = System.currentTimeMillis();
-        Color neutralColor = getColor(name);
+        Color neutralColor = getColor(getName());
         // also draw lines between points belonging to different segments
         boolean forceLines = Main.pref.getBoolean("draw.rawgps.lines.force");
@@ -431 +429 @@
         boolean lines = (Main.pref.getBoolean("draw.rawgps.lines", true) || (Main.pref
                 .getBoolean("draw.rawgps.lines.localfiles") && this.isLocalFile));
-        String linesKey = "draw.rawgps.lines.layer " + name;
+        String linesKey = "draw.rawgps.lines.layer " + getName();
         // draw lines, per-layer setting
         if (Main.pref.hasKey(linesKey)) {
@@ -726 +724 @@
             }
             Main.main
-            .addLayer(new OsmDataLayer(ds, tr("Converted from: {0}", GpxLayer.this.name), getAssociatedFile()));
+            .addLayer(new OsmDataLayer(ds, tr("Converted from: {0}", GpxLayer.this.getName()), getAssociatedFile()));
             Main.main.removeLayer(GpxLayer.this);
         }

trunk/src/org/openstreetmap/josm/gui/layer/Layer.java

@@ -8 +8 @@
 import java.awt.Graphics;
 import java.awt.event.ActionEvent;
+import java.beans.PropertyChangeListener;
+import java.beans.PropertyChangeSupport;
 import java.io.File;
 import java.util.Collection;
@@ -39 +41 @@
  */
 abstract public class Layer implements Destroyable, MapViewPaintable {
+    static public final String VISIBLE_PROP = Layer.class.getName() + ".visible";
+    static public final String NAME_PROP = Layer.class.getName() + ".name";
+
+    /** keeps track of property change listeners */
+    private PropertyChangeSupport propertyChangeSupport;
 
     /**
@@ -58 +65 @@
     /**
      * The visibility state of the layer.
-     */
+     * 
+     * @deprecated use {@see #setVisible(boolean)} and {@see #isVisible()} instead. This field
+     * is going to be private (or protected) in a future release.
+     */
+    @Deprecated
     public boolean visible = true;
 
@@ -68 +79 @@
     /**
      * The name of this layer.
-     */
+     * 
+     * @deprecated use {@see #getName()} and {@see #setName(String)} instead. This field
+     * is going to be private  (or protected) in the future.
+     */
+    @Deprecated
     public String name;
     /**
@@ -79 +94 @@
      */
     public Layer(String name) {
-        this.name = name;
+        this.propertyChangeSupport = new PropertyChangeSupport(this);
+        setName(name);
     }
 
@@ -140 +156 @@
     public String getName() {
         return name;
+    }
+
+    /**
+     * Sets the name of the layer
+     *
+     *@param name the name. If null, the name is set to the empty string.
+     *
+     */
+    public void setName(String name) {
+        if (name == null) {
+            name = "";
+        }
+        String oldValue = this.name;
+        this.name = name;
+        if (!oldValue.equals(this.name)) {
+            propertyChangeSupport.firePropertyChange(NAME_PROP, oldValue, this.name);
+        }
     }
 
@@ -189 +222 @@
     }
 
+    /**
+     * Sets the visibility of this layer. Emits property change event for
+     * property {@see #VISIBLE_PROP}.
+     * 
+     * @param visible true, if the layer is visible; false, otherwise.
+     */
+    public void setVisible(boolean visible) {
+        boolean oldValue = this.visible;
+        this.visible  = visible;
+        if (oldValue != this.visible) {
+            fireVisibleChanged(oldValue, this.visible);
+        }
+    }
+
+    /**
+     * Replies true if this layer is visible. False, otherwise.
+     * @return  true if this layer is visible. False, otherwise.
+     */
+    public boolean isVisible() {
+        return visible;
+    }
+
+    /**
+     * Toggles the visibility state of this layer.
+     */
+    public void toggleVisible() {
+        setVisible(!isVisible());
+    }
+
+    /**
+     * Adds a {@see PropertyChangeListener}
+     * 
+     * @param listener the listener
+     */
+    public void addPropertyChangeListener(PropertyChangeListener listener) {
+        propertyChangeSupport.addPropertyChangeListener(listener);
+    }
+
+    /**
+     * Removes a {@see PropertyChangeListener}
+     * 
+     * @param listener the listener
+     */
+    public void removePropertyChangeListener(PropertyChangeListener listener) {
+        propertyChangeSupport.removePropertyChangeListener(listener);
+    }
+
+    /**
+     * fires a property change for the property {@see #VISIBLE_PROP}
+     * 
+     * @param oldValue the old value
+     * @param newValue the new value
+     */
+    protected void fireVisibleChanged(boolean oldValue, boolean newValue) {
+        propertyChangeSupport.firePropertyChange(VISIBLE_PROP, oldValue, newValue);
+    }
 }

trunk/src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

@@ -407 +407 @@
         }
         final JPanel p = new JPanel(new GridBagLayout());
-        p.add(new JLabel(tr("{0} consists of:", name)), GBC.eol());
+        p.add(new JLabel(tr("{0} consists of:", getName())), GBC.eol());
         for (int i = 0; i < counter.normal.length; ++i) {
             String s = counter.normal[i]+" "+trn(counter.names[i],counter.names[i]+"s",counter.normal[i]);
@@ -423 +423 @@
         if (Main.applet)
             return new Component[]{
-                new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createActivateLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)),
+                new JSeparator(),
+                new JMenuItem(LayerListDialog.getInstance().createMergeLayerAction(this)),
                 new JSeparator(),
                 new JMenuItem(new RenameLayerAction(getAssociatedFile(), this)),
@@ -430 +433 @@
                 new JMenuItem(new LayerListPopup.InfoAction(this))};
         return new Component[]{
-                new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createActivateLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)),
                 new JSeparator(),
+                new JMenuItem(LayerListDialog.getInstance().createMergeLayerAction(this)),
                 new JMenuItem(new LayerSaveAction(this)),
                 new JMenuItem(new LayerSaveAsAction(this)),
@@ -515 +520 @@
         }
         public void actionPerformed(ActionEvent e) {
-            Main.main.addLayer(new GpxLayer(toGpxData(), tr("Converted from: {0}", name)));
+            Main.main.addLayer(new GpxLayer(toGpxData(), tr("Converted from: {0}", getName())));
             Main.main.removeLayer(OsmDataLayer.this);
         }

trunk/src/org/openstreetmap/josm/gui/layer/RawGpsLayer.java

@@ -13 +13 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
-import java.io.BufferedReader;
 import java.io.File;
-import java.io.InputStreamReader;
-import java.net.URL;
-import java.net.URLConnection;
-import java.net.UnknownHostException;
 import java.util.Collection;
 
@@ -25 +20 @@
 import javax.swing.ButtonGroup;
 import javax.swing.Icon;
-import javax.swing.JCheckBox;
 import javax.swing.JColorChooser;
 import javax.swing.JLabel;
@@ -33 +27 @@
 import javax.swing.JRadioButton;
 import javax.swing.JSeparator;
-import javax.swing.JTextField;
-import javax.swing.text.html.Option;
 
 import org.openstreetmap.josm.Main;
-import org.openstreetmap.josm.actions.GpxExportAction;
 import org.openstreetmap.josm.actions.RenameLayerAction;
 import org.openstreetmap.josm.data.Preferences.PreferenceChangedListener;
@@ -51 +42 @@
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
 import org.openstreetmap.josm.gui.dialogs.LayerListPopup;
-import org.openstreetmap.josm.io.MultiPartFormOutputStream;
 import org.openstreetmap.josm.tools.GBC;
 import org.openstreetmap.josm.tools.ImageProvider;
@@ -91 +81 @@
                 ds.ways.add(w);
             }
-            Main.main.addLayer(new OsmDataLayer(ds, tr("Converted from: {0}", RawGpsLayer.this.name), null));
+            Main.main.addLayer(new OsmDataLayer(ds, tr("Converted from: {0}", RawGpsLayer.this.getName()), null));
             Main.main.removeLayer(RawGpsLayer.this);
         }
@@ -129 +119 @@
 
     @Override public void paint(Graphics g, MapView mv) {
-        g.setColor(Main.pref.getColor(marktr("gps point"), "layer "+name, Color.gray));
+        g.setColor(Main.pref.getColor(marktr("gps point"), "layer "+getName(), Color.gray));
         Point old = null;
 
         boolean force = Main.pref.getBoolean("draw.rawgps.lines.force");
         boolean lines = Main.pref.getBoolean("draw.rawgps.lines", true);
-        String linesKey = "draw.rawgps.lines.layer "+name;
+        String linesKey = "draw.rawgps.lines.layer "+getName();
         if (Main.pref.hasKey(linesKey)) {
             lines = Main.pref.getBoolean(linesKey);
@@ -197 +187 @@
         }
         b.append("</html>");
-        return "<html>"+trn("{0} consists of {1} track", "{0} consists of {1} tracks", data.size(), name, data.size())+" ("+trn("{0} point", "{0} points", points, points)+")<br>"+b.toString();
+        return "<html>"+trn("{0} consists of {1} track", "{0} consists of {1} tracks", data.size(), getName(), data.size())+" ("+trn("{0} point", "{0} points", points, points)+")<br>"+b.toString();
     }
 
@@ -214 +204 @@
                     panel.add(b);
                 }
-                String propName = "draw.rawgps.lines.layer "+name;
+                String propName = "draw.rawgps.lines.layer "+getName();
                 if (Main.pref.hasKey(propName)) {
                     group.setSelected(r[Main.pref.getBoolean(propName) ? 1:2].getModel(), true);
@@ -241 +231 @@
         color.addActionListener(new ActionListener(){
             public void actionPerformed(ActionEvent e) {
-                JColorChooser c = new JColorChooser(Main.pref.getColor(marktr("gps point"), "layer "+name, Color.gray));
+                JColorChooser c = new JColorChooser(Main.pref.getColor(marktr("gps point"), "layer "+getName(), Color.gray));
                 Object[] options = new Object[]{tr("OK"), tr("Cancel"), tr("Default")};
                 int answer = OptionPaneUtil.showOptionDialog(
@@ -251 +241 @@
                 switch (answer) {
                     case 0:
-                        Main.pref.putColor("layer "+name, c.getColor());
+                        Main.pref.putColor("layer "+getName(), c.getColor());
                         break;
                     case 1:
                         return;
                     case 2:
-                        Main.pref.putColor("layer "+name, null);
+                        Main.pref.putColor("layer "+getName(), null);
                         break;
                 }
@@ -265 +255 @@
         if (Main.applet)
             return new Component[]{
-                new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)),
                 new JSeparator(),
                 color,
@@ -276 +266 @@
                 new JMenuItem(new LayerListPopup.InfoAction(this))};
         return new Component[]{
-                new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)),
-                new JMenuItem(new LayerListDialog.DeleteLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)),
+                new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)),
                 new JSeparator(),
                 new JMenuItem(new LayerGpxExportAction(this)),

trunk/src/org/openstreetmap/josm/gui/layer/markerlayer/MarkerLayer.java

@@ -19 +19 @@
 import java.util.Collection;
 
+import javax.swing.AbstractAction;
 import javax.swing.Icon;
 import javax.swing.JColorChooser;
@@ -62 +63 @@
     public GpxLayer fromLayer = null;
 
-    /*
-    private Icon audioTracerIcon = null;
-    private EastNorth playheadPosition = null;
-    private static Timer timer = null;
-    private static double audioAnimationInterval = 0.0; // seconds
-    private static double playheadTime = -1.0;
-     */
     public MarkerLayer(GpxData indata, String name, File associatedFile, GpxLayer fromLayer) {
 
@@ -122 +116 @@
                             return;
                         mousePressed  = true;
-                        if (visible) {
+                        if (isVisible()) {
                             Main.map.mapView.repaint();
                         }
@@ -130 +124 @@
                             return;
                         mousePressed = false;
-                        if (!visible)
+                        if (!isVisible())
                             return;
                         if (ev.getPoint() != null) {
@@ -161 +155 @@
         boolean mousePressedTmp = mousePressed;
         Point mousePos = mv.getMousePosition();
-        String mkrTextShow = Main.pref.get("marker.show "+name, "show");
-
-        g.setColor(getColor(name));
+        String mkrTextShow = Main.pref.get("marker.show "+getName(), "show");
+
+        g.setColor(getColor(getName()));
 
         for (Marker mkr : data) {
@@ -195 +189 @@
 
     @Override public Object getInfoComponent() {
-        return "<html>"+trn("{0} consists of {1} marker", "{0} consists of {1} markers", data.size(), name, data.size()) + "</html>";
+        return "<html>"+trn("{0} consists of {1} marker", "{0} consists of {1} markers", data.size(), getName(), data.size()) + "</html>";
     }
 
@@ -203 +197 @@
         color.addActionListener(new ActionListener(){
             public void actionPerformed(ActionEvent e) {
-                JColorChooser c = new JColorChooser(getColor(name));
+                JColorChooser c = new JColorChooser(getColor(getName()));
                 Object[] options = new Object[]{tr("OK"), tr("Cancel"), tr("Default")};
                 int answer = OptionPaneUtil.showOptionDialog(
@@ -215 +209 @@
                 );
                 switch (answer) {
-                case 0:
-                    Main.pref.putColor("layer "+name, c.getColor());
-                    break;
-                case 1:
-                    return;
-                case 2:
-                    Main.pref.putColor("layer "+name, null);
-                    break;
+                    case 0:
+                        Main.pref.putColor("layer "+getName(), c.getColor());
+                        break;
+                    case 1:
+                        return;
+                    case 2:
+                        Main.pref.putColor("layer "+getName(), null);
+                        break;
                 }
                 Main.map.repaint();
@@ -282 +276 @@
 
         Collection<Component> components = new ArrayList<Component>();
-        components.add(new JMenuItem(new LayerListDialog.ShowHideLayerAction(this)));
-        components.add(new JMenuItem(new LayerListDialog.ShowHideMarkerText(this)));
-        components.add(new JMenuItem(new LayerListDialog.DeleteLayerAction(this)));
+        components.add(new JMenuItem(LayerListDialog.getInstance().createShowHideLayerAction(this)));
+        components.add(new JMenuItem(new ShowHideMarkerText(this)));
+        components.add(new JMenuItem(LayerListDialog.getInstance().createDeleteLayerAction(this)));
         components.add(new JSeparator());
         components.add(color);
@@ -450 +444 @@
     }
 
+
+    public final  class ShowHideMarkerText extends AbstractAction {
+        private final Layer layer;
+
+        public ShowHideMarkerText(Layer layer) {
+            super(tr("Show/Hide Text/Icons"), ImageProvider.get("dialogs", "showhide"));
+            putValue(SHORT_DESCRIPTION, tr("Toggle visible state of the marker text and icons."));
+            putValue("help", "Action/ShowHideTextIcons");
+            this.layer = layer;
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            String current = Main.pref.get("marker.show "+layer.getName(),"show");
+            Main.pref.put("marker.show "+layer.getName(), current.equalsIgnoreCase("show") ? "hide" : "show");
+            Main.map.mapView.repaint();
+        }
+    }
 }