Changeset 1820 in josm


Ignore:
Timestamp:
2009-07-21T19:52:53+02:00 (15 years ago)
Author:
Gubaer
Message:

JosmAction is now a LayerChangeListener and a SelectionChangeListener
updated all JosmActions
fixed #3018: Make sure tools menu entries (and actions) are deactivated when no layer

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

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/actions/AbstractInfoAction.java

    r1814 r1820  
    8585
    8686    protected abstract String createInfoUrl(OsmPrimitive primitive);
     87
     88    @Override
     89    protected void updateEnabledState() {
     90        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     91    }
    8792}

  • trunk/src/org/openstreetmap/josm/actions/AddNodeAction.java

    r1814 r1820  
    1515import org.openstreetmap.josm.Main;
    1616import org.openstreetmap.josm.command.AddCommand;
     17import org.openstreetmap.josm.data.coor.LatLon;
    1718import org.openstreetmap.josm.data.osm.Node;
    18 import org.openstreetmap.josm.data.coor.LatLon;
    19 import org.openstreetmap.josm.gui.layer.Layer;
    20 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2119import org.openstreetmap.josm.tools.GBC;
    2220import org.openstreetmap.josm.tools.Shortcut;
    … …  
    2624 * and when ok is pressed, a new node is created at the specified position.
    2725 */
    28 public final class AddNodeAction extends JosmAction implements LayerChangeListener {
     26public final class AddNodeAction extends JosmAction {
    2927
    3028    public AddNodeAction() {
    … …  
    3230                Shortcut.registerShortcut("addnode", tr("Edit: {0}", tr("Add Node...")), KeyEvent.VK_D, Shortcut.GROUP_EDIT,
    3331                        Shortcut.SHIFT_DEFAULT), true);
    34         Layer.listeners.add(this);
    35         refreshEnabled();
    36     }
    37 
    38     protected void refreshEnabled() {
    39         setEnabled(Main.map != null
    40                 && Main.map.mapView != null
    41                 && Main.map.mapView.getEditLayer() != null);
    4232    }
    4333
    … …  
    8373    }
    8474
    85     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    86         refreshEnabled();
     75    @Override
     76    protected void updateEnabledState() {
     77        setEnabled(getEditLayer() != null);
    8778    }
    8879
    89     public void layerAdded(Layer newLayer) {
    90         refreshEnabled();
     80}
    9181
    92     }
    93 
    94     public void layerRemoved(Layer oldLayer) {
    95         refreshEnabled();
    96     }
    97 }

  • trunk/src/org/openstreetmap/josm/actions/AlignInCircleAction.java

    r1814 r1820  
    7979
    8080    public void actionPerformed(ActionEvent e) {
     81        if (!isEnabled())
     82            return;
     83
    8184        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
    8285        Collection<Node> nodes = new LinkedList<Node>();
    … …  
    208211        Main.map.repaint();
    209212    }
     213
     214    @Override
     215    protected void updateEnabledState() {
     216        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     217    }
    210218}

  • trunk/src/org/openstreetmap/josm/actions/AlignInLineAction.java

    r1814 r1820  
    4040     */
    4141    public void actionPerformed(ActionEvent e) {
     42        if (!isEnabled())
     43            return;
    4244        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
    4345        Collection<Node> nodes = new LinkedList<Node>();
    … …  
    125127        Main.map.repaint();
    126128    }
     129
     130    @Override
     131    protected void updateEnabledState() {
     132        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     133    }
    127134}

  • trunk/src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r1814 r1820  
    117117        return v;
    118118    }
     119
     120    @Override
     121    protected void updateEnabledState() {
     122        setEnabled(Main.map != null);
     123    }
     124
    119125}

  • trunk/src/org/openstreetmap/josm/actions/CombineWayAction.java

    r1817 r1820  
    3030import org.openstreetmap.josm.command.DeleteCommand;
    3131import org.openstreetmap.josm.command.SequenceCommand;
    32 import org.openstreetmap.josm.data.SelectionChangedListener;
    33 import org.openstreetmap.josm.data.osm.DataSet;
    3432import org.openstreetmap.josm.data.osm.Node;
    3533import org.openstreetmap.josm.data.osm.OsmPrimitive;
    … …  
    3937import org.openstreetmap.josm.data.osm.Way;
    4038import org.openstreetmap.josm.gui.ExtendedDialog;
    41 import org.openstreetmap.josm.gui.layer.Layer;
    42 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    4339import org.openstreetmap.josm.tools.GBC;
    4440import org.openstreetmap.josm.tools.Pair;
    … …  
    5046 * @author Imi
    5147 */
    52 public class CombineWayAction extends JosmAction implements SelectionChangedListener,LayerChangeListener {
     48public class CombineWayAction extends JosmAction {
    5349
    5450    public CombineWayAction() {
    5551        super(tr("Combine Way"), "combineway", tr("Combine several ways into one."),
    5652                Shortcut.registerShortcut("tools:combineway", tr("Tool: {0}", tr("Combine Way")), KeyEvent.VK_C, Shortcut.GROUP_EDIT), true);
    57         DataSet.selListeners.add(this);
    58         Layer.listeners.add(this);
    59         refreshEnabled();
    6053    }
    6154
    … …  
    300293    }
    301294
    302     /**
    303      * Enable the "Combine way" menu option if more then one way is selected
    304      */
    305     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    306         refreshEnabled();
    307     }
    308 
    309     protected void refreshEnabled() {
     295    @Override
     296    protected void updateEnabledState() {
    310297        if (getCurrentDataSet() == null) {
    311298            setEnabled(false);
    … …  
    321308        setEnabled(numWays >= 2);
    322309    }
    323 
    324 
    325     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    326         refreshEnabled();
    327     }
    328 
    329     public void layerAdded(Layer newLayer) {
    330         refreshEnabled();
    331 
    332     }
    333 
    334     public void layerRemoved(Layer oldLayer) {
    335         refreshEnabled();
    336     }
    337 
    338310}

  • trunk/src/org/openstreetmap/josm/actions/CopyAction.java

    r1814 r1820  
    1616
    1717import org.openstreetmap.josm.Main;
    18 import org.openstreetmap.josm.data.SelectionChangedListener;
    1918import org.openstreetmap.josm.data.osm.DataSet;
    2019import org.openstreetmap.josm.data.osm.DataSource;
    … …  
    2726import org.openstreetmap.josm.tools.Shortcut;
    2827
    29 public final class CopyAction extends JosmAction implements SelectionChangedListener {
     28public final class CopyAction extends JosmAction {
    3029
    3130    private LinkedList<JosmAction> listeners;
    … …  
    3534                tr("Copy selected objects to paste buffer."),
    3635                Shortcut.registerShortcut("system:copy", tr("Edit: {0}", tr("Copy")), KeyEvent.VK_C, Shortcut.GROUP_MENU), true);
    37         setEnabled(false);
    38         DataSet.selListeners.add(this);
    3936        listeners = new LinkedList<JosmAction>();
    4037    }
    … …  
    131128    }
    132129
    133     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    134         setEnabled(! newSelection.isEmpty());
     130    @Override
     131    protected void updateEnabledState() {
     132        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
    135133    }
    136134

  • trunk/src/org/openstreetmap/josm/actions/CreateCircleAction.java

    r1814 r1820  
    7373
    7474    public void actionPerformed(ActionEvent e) {
     75        if (!isEnabled())
     76            return;
     77
    7578        int numberOfNodesInCircle = Main.pref.getInteger("createcircle.nodecount", 8);
    7679        if (numberOfNodesInCircle < 1) {
    … …  
    265268        Main.map.repaint();
    266269    }
     270
     271    @Override
     272    protected void updateEnabledState() {
     273        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     274    }
    267275}

  • trunk/src/org/openstreetmap/josm/actions/DeleteAction.java

    r1750 r1820  
    33
    44import static org.openstreetmap.josm.tools.I18n.tr;
    5 
    6 import java.util.Collection;
    75
    86import java.awt.event.ActionEvent;
    … …  
    119import org.openstreetmap.josm.Main;
    1210import org.openstreetmap.josm.tools.Shortcut;
    13 import org.openstreetmap.josm.data.osm.DataSet;
    14 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    15 import org.openstreetmap.josm.data.SelectionChangedListener;
    1611
    17 public final class DeleteAction extends JosmAction implements SelectionChangedListener {
     12public final class DeleteAction extends JosmAction {
    1813
    1914    public DeleteAction() {
    2015        super(tr("Delete"), "dialogs/delete", tr("Delete selected objects."),
    21         Shortcut.registerShortcut("system:delete", tr("Edit: {0}", tr("Delete")), KeyEvent.VK_DELETE, Shortcut.GROUP_DIRECT), true);
    22         DataSet.selListeners.add(this);
    23         setEnabled(false);
     16                Shortcut.registerShortcut("system:delete", tr("Edit: {0}", tr("Delete")), KeyEvent.VK_DELETE, Shortcut.GROUP_DIRECT), true);
    2417    }
    2518
    2619    public void actionPerformed(ActionEvent e) {
     20        if (!isEnabled())
     21            return;
    2722        if(!Main.map.mapView.isActiveLayerVisible())
    2823            return;
    2924        new org.openstreetmap.josm.actions.mapmode.DeleteAction(Main.map)
    30                 .doActionPerformed(e);
     25        .doActionPerformed(e);
    3126    }
    32     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    33         setEnabled(! newSelection.isEmpty());
     27
     28    @Override
     29    protected void updateEnabledState() {
     30        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
    3431    }
    3532}

  • trunk/src/org/openstreetmap/josm/actions/DistributeAction.java

    r1814 r1820  
    3838     */
    3939    public void actionPerformed(ActionEvent e) {
     40        if (!isEnabled())
     41            return;
    4042        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
    4143        Collection<Node> nodes = new LinkedList<Node>();
    … …  
    126128        Main.map.repaint();
    127129    }
     130
     131    @Override
     132    protected void updateEnabledState() {
     133        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     134    }
    128135}

  • trunk/src/org/openstreetmap/josm/actions/DownloadReferrersAction.java

    r1811 r1820  
    3535 *
    3636 */
    37 public class DownloadReferrersAction extends JosmAction implements SelectionChangedListener, LayerChangeListener {
     37public class DownloadReferrersAction extends JosmAction{
    3838
    3939    public DownloadReferrersAction() {
    4040        super(tr("Download referrers from OSM..."), "downloadreferrers", tr("Download primitives referring to one of the selected primitives"),
    4141                Shortcut.registerShortcut("file:downloadreferrers", tr("File: {0}", tr("Download referrers...")), KeyEvent.VK_D, Shortcut.GROUPS_ALT2+Shortcut.GROUP_HOTKEY), true);
    42 
    43         Layer.listeners.add(this);
    44         DataSet.selListeners.add(this);
    45         refreshEnabled();
    4642    }
    4743
    … …  
    168164     *
    169165     */
    170     protected void refreshEnabled() {
    171         setEnabled(Main.map != null
    172                 && Main.map.mapView !=null
    173                 && Main.map.mapView.getEditLayer() != null
    174                 && ! Main.map.mapView.getEditLayer().data.getSelected().isEmpty()
    175         );
    176     }
    177 
    178     /* ---------------------------------------------------------------------------------- */
    179     /* Interface SelectionChangeListener                                                  */
    180     /* ---------------------------------------------------------------------------------- */
    181     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    182         refreshEnabled();
    183     }
    184 
    185     /* ---------------------------------------------------------------------------------- */
    186     /* Interface LayerChangeListener                                                      */
    187     /* ---------------------------------------------------------------------------------- */
    188     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    189         refreshEnabled();
    190     }
    191 
    192     public void layerAdded(Layer newLayer) {
    193         refreshEnabled();
    194     }
    195 
    196     public void layerRemoved(Layer oldLayer) {
    197         refreshEnabled();
     166    @Override
     167    protected void updateEnabledState() {
     168        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
    198169    }
    199170}

  • trunk/src/org/openstreetmap/josm/actions/DuplicateAction.java

    r1814 r1820  
    77import java.awt.event.ActionEvent;
    88import java.awt.event.KeyEvent;
    9 import java.util.Collection;
    109
    11 import org.openstreetmap.josm.data.SelectionChangedListener;
    12 import org.openstreetmap.josm.data.osm.DataSet;
    13 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    14 import org.openstreetmap.josm.gui.layer.Layer;
    15 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1610import org.openstreetmap.josm.tools.Shortcut;
    1711
    18 public final class DuplicateAction extends JosmAction implements SelectionChangedListener, LayerChangeListener {
     12public final class DuplicateAction extends JosmAction{
    1913
    2014    public DuplicateAction() {
    … …  
    2216                tr("Duplicate selection by copy and immediate paste."),
    2317                Shortcut.registerShortcut("system:duplicate", tr("Edit: {0}", tr("Duplicate")), KeyEvent.VK_D, Shortcut.GROUP_MENU), true);
    24         setEnabled(false);
    25         DataSet.selListeners.add(this);
    26         Layer.listeners.add(this);
    2718    }
    2819
    … …  
    3223
    3324
    34     protected void refreshEnabled() {
    35         setEnabled(getCurrentDataSet() != null
    36                 && ! getCurrentDataSet().getSelected().isEmpty()
    37         );
    38     }
    39 
    40     /* ---------------------------------------------------------------------------------- */
    41     /* Interface SelectionChangeListener                                                  */
    42     /* ---------------------------------------------------------------------------------- */
    43     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    44         refreshEnabled();
    45     }
    46 
    47     /* ---------------------------------------------------------------------------------- */
    48     /* Interface LayerChangeListener                                                      */
    49     /* ---------------------------------------------------------------------------------- */
    50     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    51         refreshEnabled();
    52     }
    53 
    54     public void layerAdded(Layer newLayer) {
    55         refreshEnabled();
    56     }
    57 
    58     public void layerRemoved(Layer oldLayer) {
    59         refreshEnabled();
     25    @Override
     26    protected void updateEnabledState() {
     27        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
    6028    }
    6129}

  • trunk/src/org/openstreetmap/josm/actions/GpxExportAction.java

    r1814 r1820  
    3232import org.openstreetmap.josm.gui.layer.Layer;
    3333import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    34 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    3534import org.openstreetmap.josm.io.GpxWriter;
    3635import org.openstreetmap.josm.tools.GBC;
    … …  
    4039 * Exports data to gpx.
    4140 */
    42 public class GpxExportAction extends DiskAccessAction implements LayerChangeListener {
     41public class GpxExportAction extends DiskAccessAction {
    4342
    4443    private final static String warningGpl = "<html><font color='red' size='-2'>"+tr("Note: GPL is not compatible with the OSM license. Do not upload GPL licensed tracks.")+"</html>";
    … …  
    4746        super(tr("Export to GPX..."), "exportgpx", tr("Export the data to GPX file."),
    4847                Shortcut.registerShortcut("file:exportgpx", tr("Export to GPX..."), KeyEvent.VK_E, Shortcut.GROUP_MENU));
    49         Layer.listeners.add(this);
    50         refreshEnabled();
    5148    }
    5249
    … …  
    333330     *
    334331     */
    335     protected void refreshEnabled() {
     332    @Override
     333    protected void updateEnabledState() {
    336334        boolean check = Main.main != null
    337335        && Main.map != null
    … …  
    345343        setEnabled(layer instanceof GpxLayer);
    346344    }
    347 
    348     /* ---------------------------------------------------------------------------------- */
    349     /* Interface LayerChangeListener                                                      */
    350     /* ---------------------------------------------------------------------------------- */
    351     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    352         refreshEnabled();
    353     }
    354 
    355     public void layerAdded(Layer newLayer) {
    356         refreshEnabled();
    357     }
    358 
    359     public void layerRemoved(Layer oldLayer) {
    360         refreshEnabled();
    361     }
    362345}

  • trunk/src/org/openstreetmap/josm/actions/HelpAction.java

    r1755 r1820  
    1212import java.awt.event.WindowEvent;
    1313import java.io.IOException;
    14 import java.io.StringReader;
    1514
    1615import javax.swing.AbstractAction;
    … …  
    6463                if (e.getEventType() != HyperlinkEvent.EventType.ACTIVATED)
    6564                    return;
    66                 if (e.getURL() == null)
     65                if (e.getURL() == null) {
    6766                    help.setText("<html>404 not found</html>");
    68                 else if (e.getURL().toString().endsWith("action=edit"))
     67                } else if (e.getURL().toString().endsWith("action=edit")) {
    6968                    OpenBrowser.displayUrl(e.getURL().toString());
    70                 else
     69                } else {
    7170                    setHelpUrl(e.getURL().toString());
     71                }
    7272            }
    7373        });
    … …  
    119119            String topic = null;
    120120            Point mouse = Main.parent.getMousePosition();
    121             if (mouse != null)
     121            if (mouse != null) {
    122122                topic = contextSensitiveHelp(SwingUtilities.getDeepestComponentAt(Main.parent, mouse.x, mouse.y));
     123            }
    123124            if (topic == null) {
    124125                helpBrowser.setVisible(false);
    125126                setHelpUrl(baseurl+pathbase+"Help");
    126             } else
     127            } else {
    127128                help(topic);
     129            }
    128130        } else {
    129131            helpBrowser.setVisible(false);
    … …  
    176178            int i = pathbase.length()+baseurl.length();
    177179            String title = url.substring(i);
    178             if(languageCode.length() != 0 && !title.startsWith(languageCode))
     180            if(languageCode.length() != 0 && !title.startsWith(languageCode)) {
    179181                title = languageCode + title;
     182            }
    180183            langurl = url.substring(0, i) + title;
    181184        }
    … …  
    185188            loaded = loadHelpUrl(url, langurl, true);
    186189        }
    187         if(!loaded)
     190        if(!loaded) {
    188191            loaded = loadHelpUrl(url, langurl, false);
    189         if(!loaded)
     192        }
     193        if(!loaded) {
    190194            help.setText(tr("Error while loading page {0}",url));
     195        }
    191196        helpBrowser.setVisible(true);
    192197    }
    … …  
    194199    private boolean loadHelpUrl(String url, String langurl, boolean lang)
    195200    {
    196       this.url = lang ? langurl : url;
    197       boolean loaded = false;
    198       try {
    199           String txt = reader.read(this.url);
    200           if(txt.length() == 0)
    201           {
    202               if(lang)
    203                   throw new IOException();
    204               else
    205               {
    206                 if(url.equals(langurl))
    207                 {
    208                     txt = ("<HTML>"+tr("Help page missing. Create it in <A HREF=\"{0}\">english</A>.",
    209                     url+"?action=edit")+"</HTML>");
    210                 }
     201        this.url = lang ? langurl : url;
     202        boolean loaded = false;
     203        try {
     204            String txt = reader.read(this.url);
     205            if(txt.length() == 0)
     206            {
     207                if(lang)
     208                    throw new IOException();
    211209                else
    212210                {
    213                     txt = ("<HTML>"+tr("Help page missing. Create it in <A HREF=\"{0}\">english</A> or <A HREF=\"{1}\">your language</A>.",
    214                     url+"?action=edit", langurl+"?action=edit")+"</HTML>");
     211                    if(url.equals(langurl))
     212                    {
     213                        txt = ("<HTML>"+tr("Help page missing. Create it in <A HREF=\"{0}\">english</A>.",
     214                                url+"?action=edit")+"</HTML>");
     215                    }
     216                    else
     217                    {
     218                        txt = ("<HTML>"+tr("Help page missing. Create it in <A HREF=\"{0}\">english</A> or <A HREF=\"{1}\">your language</A>.",
     219                                url+"?action=edit", langurl+"?action=edit")+"</HTML>");
     220                    }
    215221                }
    216               }
    217           }
    218           help.setText(txt);
    219           help.setCaretPosition(0);
    220           loaded = true;
    221       } catch (IOException ex) {
    222       }
    223       return loaded;
     222            }
     223            help.setText(txt);
     224            help.setCaretPosition(0);
     225            loaded = true;
     226        } catch (IOException ex) {
     227        }
     228        return loaded;
    224229    }
    225230

  • trunk/src/org/openstreetmap/josm/actions/JoinNodeWayAction.java

    r1814 r1820  
    3232
    3333    public void actionPerformed(ActionEvent e) {
     34        if (!isEnabled())
     35            return;
    3436        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
    3537        if (sel.size() != 1 || !(sel.iterator().next() instanceof Node)) return;
    … …  
    8486        Collections.reverse(is);
    8587    }
     88
     89    @Override
     90    protected void updateEnabledState() {
     91        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
     92    }
    8693}

  • trunk/src/org/openstreetmap/josm/actions/JosmAction.java

    r1814 r1820  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.util.Collection;
     7
    68import javax.swing.AbstractAction;
    79import javax.swing.JComponent;
    810
    911import org.openstreetmap.josm.Main;
     12import org.openstreetmap.josm.data.SelectionChangedListener;
    1013import org.openstreetmap.josm.data.osm.DataSet;
     14import org.openstreetmap.josm.data.osm.OsmPrimitive;
     15import org.openstreetmap.josm.gui.layer.Layer;
    1116import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     17import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    1218import org.openstreetmap.josm.tools.Destroyable;
    1319import org.openstreetmap.josm.tools.ImageProvider;
    … …  
    1622/**
    1723 * Base class helper for all Actions in JOSM. Just to make the life easier.
    18  *
     24 *
     25 * A JosmAction is a {@see LayerChangeListener} and a {@see SelectionChangedListener}. Upon
     26 * a layer change event or a selection change event it invokes {@see #updateEnabled()}.
     27 * Subclasses can override {@see #updateEnabled()} in order to update the {@see #isEnabled()}-state
     28 * of a JosmAction depending on the {@see #getCurrentDataSet()} and the current layers
     29 * (see also {@see #getEditLayer()}).
     30 *
    1931 * destroy() from interface Destroyable is called e.g. for MapModes, when the last layer has
    2032 * been removed and so the mapframe will be destroyed. For other JosmActions, destroy() may never
    … …  
    2638
    2739    protected Shortcut sc;
     40    private LayerChangeAdapter layerChangeAdapter;
     41    private SelectionChangeAdapter selectionChangeAdapter;
    2842
    2943    public Shortcut getShortcut() {
    … …  
    6579            Main.toolbar.register(this);
    6680        }
     81        installAdapters();
     82    }
     83
     84    public JosmAction() {
     85        setHelpId();
     86        installAdapters();
    6787    }
    6888
    … …  
    7292            Main.contentPane.getActionMap().remove(sc.getKeyStroke());
    7393        }
     94        if (Layer.listeners != null) {
     95            Layer.listeners.remove(layerChangeAdapter);
     96        }
     97        if (DataSet.selListeners != null) {
     98            DataSet.selListeners.remove(selectionChangeAdapter);
     99        }
    74100    }
    75101
    76     public JosmAction() {
    77         setHelpId();
    78     }
     102
    79103
    80104    /**
    … …  
    117141        return Main.main.getCurrentDataSet();
    118142    }
     143
     144    private void installAdapters() {
     145        // make this action listen to layer change and selection change events
     146        //
     147        layerChangeAdapter = new LayerChangeAdapter();
     148        selectionChangeAdapter = new SelectionChangeAdapter();
     149        Layer.listeners.add(layerChangeAdapter);
     150        DataSet.selListeners.add(selectionChangeAdapter);
     151        updateEnabledState();
     152    }
     153
     154    /**
     155     * This method is called when a layer change event or a selection update event
     156     * occurs, see {@see LayerChangeListener} and {@see SelectionChangedListener}.
     157     *
     158     * The default implementation is empty. Subclasses can override the method
     159     * in order to set the {@see #isEnabled()}-state of a JosmAction depending on
     160     * the {@see #getCurrentDataSet()} and the current layers (see
     161     * also {@see #getEditLayer()}).
     162     *
     163     */
     164    protected void updateEnabledState() {
     165        // override in subclasses
     166    }
     167
     168    /**
     169     * Adapter for layer change events
     170     *
     171     */
     172    private class LayerChangeAdapter implements LayerChangeListener {
     173        public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     174            updateEnabledState();
     175        }
     176
     177        public void layerAdded(Layer newLayer) {
     178            updateEnabledState();
     179        }
     180
     181        public void layerRemoved(Layer oldLayer) {
     182            updateEnabledState();
     183        }
     184    }
     185
     186    /**
     187     * Adapter for selection change events
     188     *
     189     */
     190    private class SelectionChangeAdapter implements SelectionChangedListener {
     191        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     192            updateEnabledState();
     193        }
     194    }
    119195}

  • trunk/src/org/openstreetmap/josm/actions/MergeNodesAction.java

    r1814 r1820  
    2929import org.openstreetmap.josm.command.DeleteCommand;
    3030import org.openstreetmap.josm.command.SequenceCommand;
    31 import org.openstreetmap.josm.data.SelectionChangedListener;
    32 import org.openstreetmap.josm.data.osm.DataSet;
    3331import org.openstreetmap.josm.data.osm.Node;
    3432import org.openstreetmap.josm.data.osm.OsmPrimitive;
    … …  
    5149 *
    5250 */
    53 public class MergeNodesAction extends JosmAction implements SelectionChangedListener {
     51public class MergeNodesAction extends JosmAction {
    5452
    5553    public MergeNodesAction() {
    5654        super(tr("Merge Nodes"), "mergenodes", tr("Merge nodes into the oldest one."),
    5755                Shortcut.registerShortcut("tools:mergenodes", tr("Tool: {0}", tr("Merge Nodes")), KeyEvent.VK_M, Shortcut.GROUP_EDIT), true);
    58         DataSet.selListeners.add(this);
    5956    }
    6057
    6158    public void actionPerformed(ActionEvent event) {
     59        if (!isEnabled())
     60            return;
     61
    6262        Collection<OsmPrimitive> selection = getCurrentDataSet().getSelected();
    6363        LinkedList<Node> selectedNodes = new LinkedList<Node>();
    … …  
    295295     * Enable the "Merge Nodes" menu option if more then one node is selected
    296296     */
    297     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    298         boolean ok = true;
    299         if (newSelection.size() < 2) {
     297    @Override
     298    public void updateEnabledState() {
     299        if (getCurrentDataSet() == null || getCurrentDataSet().getSelected().isEmpty()) {
    300300            setEnabled(false);
    301301            return;
    302302        }
    303         for (OsmPrimitive osm : newSelection) {
     303        boolean ok = true;
     304        if (getCurrentDataSet().getSelected().size() < 2) {
     305            setEnabled(false);
     306            return;
     307        }
     308        for (OsmPrimitive osm : getCurrentDataSet().getSelected()) {
    304309            if (!(osm instanceof Node)) {
    305310                ok = false;

  • trunk/src/org/openstreetmap/josm/actions/MirrorAction.java

    r1814 r1820  
    7171        Main.map.repaint();
    7272    }
     73
     74    @Override
     75    protected void updateEnabledState() {
     76        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
     77    }
    7378}

  • trunk/src/org/openstreetmap/josm/actions/MoveAction.java

    r1814 r1820  
    110110        Main.map.mapView.repaint();
    111111    }
     112
     113    @Override
     114    protected void updateEnabledState() {
     115        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
     116    }
    112117}

  • trunk/src/org/openstreetmap/josm/actions/OrthogonalizeAction.java

    r1814 r1820  
    4646
    4747    public void actionPerformed(ActionEvent e) {
    48 
     48        if (!isEnabled())
     49            return;
    4950        Collection<OsmPrimitive> sel = getCurrentDataSet().getSelected();
    5051
    … …  
    278279        return heading_delta;
    279280    }
     281
     282    @Override
     283    protected void updateEnabledState() {
     284        setEnabled(getCurrentDataSet() != null && ! getCurrentDataSet().getSelected().isEmpty());
     285    }
    280286}

  • trunk/src/org/openstreetmap/josm/actions/PasteAction.java

    r1814 r1820  
    3232        super(tr("Paste"), "paste", tr("Paste contents of paste buffer."),
    3333                Shortcut.registerShortcut("system:paste", tr("Edit: {0}", tr("Paste")), KeyEvent.VK_V, Shortcut.GROUP_MENU), true);
    34         setEnabled(false);
    3534    }
    3635
    3736    public void actionPerformed(ActionEvent e) {
     37        if (!isEnabled())
     38            return;
    3839        pasteData(Main.pasteBuffer, Main.pasteSource, e);
    3940    }
    … …  
    116117        Main.map.mapView.repaint();
    117118    }
     119
     120    @Override
     121    protected void updateEnabledState() {
     122        if (getCurrentDataSet() == null || getCurrentDataSet().getSelected().isEmpty()) {
     123            setEnabled(false);
     124            return;
     125        }
     126        if (Main.pasteBuffer == null) {
     127            setEnabled(false);
     128        }
     129        setEnabled(
     130                !Main.pasteBuffer.nodes.isEmpty()
     131                || !Main.pasteBuffer.ways.isEmpty()
     132                || !Main.pasteBuffer.relations.isEmpty()
     133        );
     134    }
    118135}

  • trunk/src/org/openstreetmap/josm/actions/PasteTagsAction.java

    r1814 r1820  
    1717import org.openstreetmap.josm.command.Command;
    1818import org.openstreetmap.josm.command.SequenceCommand;
    19 import org.openstreetmap.josm.data.SelectionChangedListener;
    2019import org.openstreetmap.josm.data.osm.DataSet;
    2120import org.openstreetmap.josm.data.osm.DataSource;
    … …  
    2322import org.openstreetmap.josm.tools.Shortcut;
    2423
    25 public final class PasteTagsAction extends JosmAction implements SelectionChangedListener {
     24public final class PasteTagsAction extends JosmAction {
    2625
    2726    public PasteTagsAction(JosmAction copyAction) {
    … …  
    2928                tr("Apply tags of contents of paste buffer to all selected items."),
    3029                Shortcut.registerShortcut("system:pastestyle", tr("Edit: {0}", tr("Paste Tags")), KeyEvent.VK_V, Shortcut.GROUP_MENU, Shortcut.SHIFT_DEFAULT), true);
    31         DataSet.selListeners.add(this);
    3230        copyAction.addListener(this);
    33         setEnabled(false);
    3431    }
    3532
    … …  
    125122    }
    126123
    127     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    128         possiblyEnable(newSelection, Main.pasteBuffer);
     124    @Override
     125    protected void updateEnabledState() {
     126        if (getCurrentDataSet() == null || Main.pasteBuffer == null) {
     127            setEnabled(false);
     128            return;
     129        }
     130        possiblyEnable(getCurrentDataSet().getSelected(), Main.pasteBuffer);
    129131    }
    130132}

  • trunk/src/org/openstreetmap/josm/actions/RedoAction.java

    r1169 r1820  
    2222    public RedoAction() {
    2323        super(tr("Redo"), "redo", tr("Redo the last undone action."),
    24         Shortcut.registerShortcut("system:redo", tr("Edit: {0}", tr("Redo")), KeyEvent.VK_Y, Shortcut.GROUP_MENU), true);
     24                Shortcut.registerShortcut("system:redo", tr("Edit: {0}", tr("Redo")), KeyEvent.VK_Y, Shortcut.GROUP_MENU), true);
    2525        setEnabled(false);
    2626    }
    … …  
    3232        Main.main.undoRedo.redo();
    3333    }
     34
     35    @Override
     36    protected void updateEnabledState() {
     37        setEnabled(Main.map != null);
     38    }
    3439}

  • trunk/src/org/openstreetmap/josm/actions/ReverseWayAction.java

    r1814 r1820  
    1818import org.openstreetmap.josm.corrector.ReverseWayTagCorrector;
    1919import org.openstreetmap.josm.corrector.UserCancelException;
     20import org.openstreetmap.josm.data.SelectionChangedListener;
    2021import org.openstreetmap.josm.data.osm.DataSet;
    21 import org.openstreetmap.josm.data.osm.Node;
    2222import org.openstreetmap.josm.data.osm.OsmPrimitive;
    23 import org.openstreetmap.josm.data.osm.Relation;
    2423import org.openstreetmap.josm.data.osm.Way;
    25 import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
     24import org.openstreetmap.josm.gui.layer.Layer;
     25import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2626import org.openstreetmap.josm.tools.Shortcut;
    2727
    28 public final class ReverseWayAction extends JosmAction {
     28public final class ReverseWayAction extends JosmAction implements SelectionChangedListener, LayerChangeListener {
    2929
    3030    public ReverseWayAction() {
    3131        super(tr("Reverse Ways"), "wayflip", tr("Reverse the direction of all selected ways."),
    3232                Shortcut.registerShortcut("tools:reverse", tr("Tool: {0}", tr("Reverse Ways")), KeyEvent.VK_R, Shortcut.GROUP_EDIT), true);
     33        DataSet.selListeners.add(this);
     34        Layer.listeners.add(this);
     35        refreshEnabled();
    3336    }
    3437
    3538    public void actionPerformed(ActionEvent e) {
     39        if (! isEnabled())
     40            return;
     41        if (getCurrentDataSet() == null)
     42            return;
     43
    3644        final Collection<Way> sel = new LinkedList<Way>();
    37         new AbstractVisitor() {
    38             public void visit(Node n) {
     45        for (OsmPrimitive primitive : getCurrentDataSet().getSelected()) {
     46            if (primitive instanceof Way) {
     47                sel.add((Way)primitive);
    3948            }
    40 
    41             public void visit(Way w) {
    42                 sel.add(w);
    43             }
    44 
    45             public void visit(Relation e) {
    46             }
    47 
    48             public void visitAll() {
    49                 for (OsmPrimitive osm : getCurrentDataSet().getSelected()) {
    50                     osm.visit(this);
    51                 }
    52             }
    53         }.visitAll();
    54 
     49        }
    5550        if (sel.isEmpty()) {
    5651            JOptionPane.showMessageDialog(Main.parent,
    … …  
    8681        Main.map.repaint();
    8782    }
     83
     84    protected int getNumWaysInSelection() {
     85        if (getCurrentDataSet() == null) return 0;
     86        int ret = 0;
     87        for (OsmPrimitive primitive : getCurrentDataSet().getSelected()) {
     88            if (primitive instanceof Way) {
     89                ret++;
     90            }
     91        }
     92        return ret;
     93    }
     94
     95    protected void refreshEnabled() {
     96        setEnabled(getNumWaysInSelection() > 0);
     97    }
     98
     99    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     100        refreshEnabled();
     101    }
     102
     103    public void layerAdded(Layer newLayer) {
     104        refreshEnabled();
     105
     106    }
     107
     108    public void layerRemoved(Layer oldLayer) {
     109        refreshEnabled();
     110    }
     111
     112    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     113        refreshEnabled();
     114    }
    88115}

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

    r1814 r1820  
    2626import org.openstreetmap.josm.gui.layer.Layer;
    2727import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    28 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2928import org.openstreetmap.josm.io.GpxImporter;
    3029import org.openstreetmap.josm.io.GpxWriter;
    … …  
    3534import org.openstreetmap.josm.tools.Shortcut;
    3635
    37 public abstract class SaveActionBase extends DiskAccessAction implements LayerChangeListener {
     36public abstract class SaveActionBase extends DiskAccessAction {
    3837
    3938    public SaveActionBase(String name, String iconName, String tooltip, Shortcut shortcut) {
    4039        super(name, iconName, tooltip, shortcut);
    41         Layer.listeners.add(this);
    42         refreshEnabled();
    4340    }
    4441
    … …  
    275272     *
    276273     */
    277     protected void refreshEnabled() {
    278         boolean check = Main.main != null
    279         && Main.map != null
     274    @Override
     275    protected void updateEnabledState() {
     276        boolean check = Main.map != null
    280277        && Main.map.mapView !=null
    281278        && Main.map.mapView.getActiveLayer() != null;
    … …  
    287284        setEnabled(layer instanceof OsmDataLayer || layer instanceof GpxLayer);
    288285    }
    289 
    290 
    291     /* ---------------------------------------------------------------------------------- */
    292     /* Interface LayerChangeListener                                                      */
    293     /* ---------------------------------------------------------------------------------- */
    294     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    295         refreshEnabled();
    296     }
    297 
    298     public void layerAdded(Layer newLayer) {
    299         refreshEnabled();
    300     }
    301 
    302     public void layerRemoved(Layer oldLayer) {
    303         refreshEnabled();
    304     }
    305286}

  • trunk/src/org/openstreetmap/josm/actions/SelectAllAction.java

    r1814 r1820  
    1111import org.openstreetmap.josm.tools.Shortcut;
    1212
    13 public class SelectAllAction extends JosmAction implements LayerChangeListener{
     13public class SelectAllAction extends JosmAction {
    1414
    1515    public SelectAllAction() {
    1616        super(tr("Select All"),"selectall", tr("Select all undeleted objects in the data layer. This selects incomplete objects too."),
    1717                Shortcut.registerShortcut("system:selectall", tr("Edit: {0}", tr("Select All")), KeyEvent.VK_A, Shortcut.GROUP_MENU), true);
    18         Layer.listeners.add(this);
    19         refreshEnabled();
    2018    }
    2119
    … …  
    3028     *
    3129     */
    32     protected void refreshEnabled() {
     30    @Override
     31    protected void updateEnabledState() {
    3332        setEnabled(getEditLayer() != null);
    3433    }
    35 
    36     /* ---------------------------------------------------------------------------------- */
    37     /* Interface LayerChangeListener                                                      */
    38     /* ---------------------------------------------------------------------------------- */
    39     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    40         refreshEnabled();
    41     }
    42 
    43     public void layerAdded(Layer newLayer) {
    44         refreshEnabled();
    45     }
    46 
    47     public void layerRemoved(Layer oldLayer) {
    48         refreshEnabled();
    49     }
    5034}

  • trunk/src/org/openstreetmap/josm/actions/SplitWayAction.java

    r1814 r1820  
    3434import org.openstreetmap.josm.data.osm.visitor.Visitor;
    3535import org.openstreetmap.josm.gui.PrimitiveNameFormatter;
     36import org.openstreetmap.josm.gui.layer.Layer;
     37import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    3638import org.openstreetmap.josm.tools.Shortcut;
    3739
    … …  
    4345 */
    4446
    45 public class SplitWayAction extends JosmAction implements SelectionChangedListener {
     47public class SplitWayAction extends JosmAction {
    4648
    4749    private Way selectedWay;
    … …  
    5456        super(tr("Split Way"), "splitway", tr("Split a way at the selected node."),
    5557                Shortcut.registerShortcut("tools:splitway", tr("Tool: {0}", tr("Split Way")), KeyEvent.VK_P, Shortcut.GROUP_EDIT), true);
    56         DataSet.selListeners.add(this);
    5758    }
    5859
    … …  
    337338    }
    338339
    339     /**
    340      * Enable the "split way" menu option if the selection looks like we could use it.
    341      */
    342     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    343         setEnabled(checkSelection(newSelection));
     340    @Override
     341    protected void updateEnabledState() {
     342        if (getCurrentDataSet() == null) {
     343            setEnabled(false);
     344            return;
     345        }
     346        setEnabled(checkSelection(getCurrentDataSet().getSelected()));
    344347    }
    345348}

  • trunk/src/org/openstreetmap/josm/actions/UnGlueAction.java

    r1814 r1820  
    3939 */
    4040
    41 public class UnGlueAction extends JosmAction { //implements SelectionChangedListener {
     41public class UnGlueAction extends JosmAction {
    4242
    4343    private Node selectedNode;
    … …  
    5151        super(tr("UnGlue Ways"), "unglueways", tr("Duplicate nodes that are used by multiple ways."),
    5252                Shortcut.registerShortcut("tools:unglue", tr("Tool: {0}", tr("UnGlue Ways")), KeyEvent.VK_G, Shortcut.GROUP_EDIT), true);
    53         //DataSet.selListeners.add(this);
    5453    }
    5554
    … …  
    410409        getCurrentDataSet().setSelected(allNewNodes);
    411410    }
     411
     412    @Override
     413    protected void updateEnabledState() {
     414        setEnabled(getCurrentDataSet() != null && !getCurrentDataSet().getSelected().isEmpty());
     415    }
    412416}

  • trunk/src/org/openstreetmap/josm/actions/UndoAction.java

    r1169 r1820  
    2222    public UndoAction() {
    2323        super(tr("Undo"), "undo", tr("Undo the last action."),
    24         Shortcut.registerShortcut("system:undo", tr("Edit: {0}", tr("Undo")), KeyEvent.VK_Z, Shortcut.GROUP_MENU), true);
     24                Shortcut.registerShortcut("system:undo", tr("Edit: {0}", tr("Undo")), KeyEvent.VK_Z, Shortcut.GROUP_MENU), true);
    2525        setEnabled(false);
    2626    }
    … …  
    3232        Main.main.undoRedo.undo();
    3333    }
     34
     35    @Override
     36    protected void updateEnabledState() {
     37        setEnabled(Main.map != null);
     38    }
    3439}

  • trunk/src/org/openstreetmap/josm/actions/UnselectAllAction.java

    r1814 r1820  
    1313import org.openstreetmap.josm.tools.Shortcut;
    1414
    15 public class UnselectAllAction extends JosmAction implements LayerChangeListener {
     15public class UnselectAllAction extends JosmAction {
    1616
    1717    public UnselectAllAction() {
    … …  
    3737                        KeyEvent.VK_ESCAPE, Shortcut.GROUP_DIRECT).getKeyStroke(),
    3838                        tr("Unselect All"));
    39         Layer.listeners.add(this);
    40         refreshEnabled();
    4139    }
    4240
    … …  
    5048     *
    5149     */
    52     protected void refreshEnabled() {
     50    @Override
     51    protected void updateEnabledState() {
    5352        setEnabled(getEditLayer() != null);
    5453    }
    55 
    56     /* ---------------------------------------------------------------------------------- */
    57     /* Interface LayerChangeListener                                                      */
    58     /* ---------------------------------------------------------------------------------- */
    59     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    60         refreshEnabled();
    61     }
    62 
    63     public void layerAdded(Layer newLayer) {
    64         refreshEnabled();
    65     }
    66 
    67     public void layerRemoved(Layer oldLayer) {
    68         refreshEnabled();
    69     }
    7054}

  • trunk/src/org/openstreetmap/josm/actions/UpdateDataAction.java

    r1814 r1820  
    1616import org.openstreetmap.josm.data.osm.DataSource;
    1717import org.openstreetmap.josm.gui.layer.Layer;
    18 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1918import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2019import org.openstreetmap.josm.tools.Shortcut;
    2120
    22 public class UpdateDataAction extends JosmAction implements LayerChangeListener{
     21public class UpdateDataAction extends JosmAction{
    2322    public UpdateDataAction() {
    2423        super(tr("Update Data"),
    … …  
    3029                        Shortcut.GROUP_HOTKEY),
    3130                        true);
    32         refreshEnabled();
    33         Layer.listeners.add(this);
    3431    }
    3532
    … …  
    3835     *
    3936     */
    40     protected void refreshEnabled() {
     37    @Override
     38    protected void updateEnabledState() {
    4139        setEnabled(getEditLayer() != null);
    4240    }
    … …  
    8684        new DownloadOsmTaskList().download(false, areas);
    8785    }
    88 
    89     /* ---------------------------------------------------------------------------------- */
    90     /* Interface LayerChangeListener                                                      */
    91     /* ---------------------------------------------------------------------------------- */
    92     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    93         refreshEnabled();
    94     }
    95 
    96     public void layerAdded(Layer newLayer) {
    97         refreshEnabled();
    98     }
    99 
    100     public void layerRemoved(Layer oldLayer) {
    101         refreshEnabled();
    102     }
    10386}

  • trunk/src/org/openstreetmap/josm/actions/UpdateSelectionAction.java

    r1814 r1820  
    3333 *
    3434 */
    35 public class UpdateSelectionAction extends JosmAction implements SelectionChangedListener, LayerChangeListener {
     35public class UpdateSelectionAction extends JosmAction {
    3636
    3737    /**
    … …  
    184184                        Shortcut.GROUP_HOTKEY + Shortcut.GROUPS_ALT2),
    185185                        true);
    186         refreshEnabled();
    187         Layer.listeners.add(this);
    188         DataSet.selListeners.add(this);
    189186    }
    190187
    … …  
    193190     *
    194191     */
    195     protected void refreshEnabled() {
     192    @Override
     193    protected void updateEnabledState() {
    196194        setEnabled(getCurrentDataSet() != null
    197195                && ! getCurrentDataSet().getSelected().isEmpty()
    … …  
    217215        updatePrimitives(selection);
    218216    }
    219 
    220     public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    221         refreshEnabled();
    222     }
    223 
    224     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    225         refreshEnabled();
    226     }
    227 
    228     public void layerAdded(Layer newLayer) {
    229         refreshEnabled();
    230     }
    231 
    232     public void layerRemoved(Layer oldLayer) {
    233         refreshEnabled();
    234     }
    235217}

  • trunk/src/org/openstreetmap/josm/actions/UploadAction.java

    r1814 r1820  
    2929import org.openstreetmap.josm.gui.PleaseWaitRunnable;
    3030import org.openstreetmap.josm.gui.historycombobox.SuggestingJHistoryComboBox;
    31 import org.openstreetmap.josm.gui.layer.Layer;
    32 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    3331import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    3432import org.openstreetmap.josm.io.OsmApi;
    … …  
    5149 * @author imi
    5250 */
    53 public class UploadAction extends JosmAction implements LayerChangeListener{
     51public class UploadAction extends JosmAction{
    5452    static private Logger logger = Logger.getLogger(UploadAction.class.getName());
    5553
    … …  
    155153            }
    156154        });
    157 
    158         Layer.listeners.add(this);
    159         refreshEnabled();
    160155    }
    161156
    … …  
    164159     *
    165160     */
    166     protected void refreshEnabled() {
    167         setEnabled(Main.main != null
    168                 && Main.map != null
    169                 && Main.map.mapView !=null
    170                 && Main.map.mapView.getEditLayer() != null
    171         );
     161    @Override
     162    protected void updateEnabledState() {
     163        setEnabled(getEditLayer() != null);
    172164    }
    173165
    174166    public void actionPerformed(ActionEvent e) {
     167        if (!isEnabled())
     168            return;
    175169        if (Main.map == null) {
    176170            JOptionPane.showMessageDialog(Main.parent,tr("Nothing to upload. Get some data first."));
    … …  
    600594        e.printStackTrace();
    601595    }
    602 
    603     /* ---------------------------------------------------------------------------------- */
    604     /* Interface LayerChangeListener                                                      */
    605     /* ---------------------------------------------------------------------------------- */
    606     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    607         refreshEnabled();
    608     }
    609 
    610     public void layerAdded(Layer newLayer) {
    611         refreshEnabled();
    612     }
    613 
    614     public void layerRemoved(Layer oldLayer) {
    615         refreshEnabled();
    616     }
    617596}

  • trunk/src/org/openstreetmap/josm/actions/ZoomInAction.java

    r1722 r1820  
    1414    public ZoomInAction() {
    1515        super(tr("Zoom In"), "dialogs/zoomin", tr("Zoom In"),
    16         Shortcut.registerShortcut("view:zoomin", tr("View: {0}", tr("Zoom In")), KeyEvent.VK_PLUS, Shortcut.GROUP_DIRECT), true);
     16                Shortcut.registerShortcut("view:zoomin", tr("View: {0}", tr("Zoom In")), KeyEvent.VK_PLUS, Shortcut.GROUP_DIRECT), true);
    1717        setEnabled(true);
    1818    }

  • trunk/src/org/openstreetmap/josm/actions/search/SearchAction.java

    r1814 r1820  
    2323import org.openstreetmap.josm.data.osm.OsmPrimitive;
    2424import org.openstreetmap.josm.gui.ExtendedDialog;
    25 import org.openstreetmap.josm.gui.layer.Layer;
    26 import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2725import org.openstreetmap.josm.tools.GBC;
    2826import org.openstreetmap.josm.tools.Shortcut;
    2927
    30 public class SearchAction extends JosmAction implements LayerChangeListener{
     28public class SearchAction extends JosmAction{
    3129
    3230    public static final int SEARCH_HISTORY_SIZE = 10;
    … …  
    4341        super(tr("Search..."), "dialogs/search", tr("Search for objects."),
    4442                Shortcut.registerShortcut("system:find", tr("Search..."), KeyEvent.VK_F, Shortcut.GROUP_HOTKEY), true);
    45         Layer.listeners.add(this);
    46         refreshEnabled();
    4743    }
    4844
    … …  
    240236     *
    241237     */
    242     protected void refreshEnabled() {
     238    @Override
     239    protected void updateEnabledState() {
    243240        setEnabled(getEditLayer() != null);
    244241    }
    245 
    246     /* ---------------------------------------------------------------------------------- */
    247     /* Interface LayerChangeListener                                                      */
    248     /* ---------------------------------------------------------------------------------- */
    249     public void activeLayerChange(Layer oldLayer, Layer newLayer) {
    250         refreshEnabled();
    251     }
    252 
    253     public void layerAdded(Layer newLayer) {
    254         refreshEnabled();
    255     }
    256 
    257     public void layerRemoved(Layer oldLayer) {
    258         refreshEnabled();
    259     }
    260242}

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

    r1814 r1820  
    183183        if(activeLayer != null && activeLayer instanceof OsmDataLayer)
    184184            return ((OsmDataLayer)activeLayer).data;
    185         return new DataSet();
     185        return null;
    186186    }
    187187
Note: See TracChangeset for help on using the changeset viewer.