001// License: GPL. For details, see LICENSE file.
002package org.openstreetmap.josm.gui.dialogs;
003
004import static org.openstreetmap.josm.tools.I18n.tr;
005
006import java.awt.Color;
007import java.awt.Component;
008import java.awt.Dimension;
009import java.awt.Font;
010import java.awt.Graphics;
011import java.awt.Graphics2D;
012import java.awt.GraphicsEnvironment;
013import java.awt.RenderingHints;
014import java.awt.event.ActionEvent;
015import java.awt.event.InputEvent;
016import java.awt.event.KeyEvent;
017import java.awt.event.MouseEvent;
018import java.beans.PropertyChangeEvent;
019import java.beans.PropertyChangeListener;
020import java.util.ArrayList;
021import java.util.Arrays;
022import java.util.List;
023import java.util.Locale;
024import java.util.concurrent.CopyOnWriteArrayList;
025import java.util.stream.Collectors;
026import java.util.stream.IntStream;
027
028import javax.swing.AbstractAction;
029import javax.swing.DefaultCellEditor;
030import javax.swing.DefaultListSelectionModel;
031import javax.swing.DropMode;
032import javax.swing.Icon;
033import javax.swing.ImageIcon;
034import javax.swing.JCheckBox;
035import javax.swing.JComponent;
036import javax.swing.JLabel;
037import javax.swing.JTable;
038import javax.swing.KeyStroke;
039import javax.swing.ListSelectionModel;
040import javax.swing.UIManager;
041import javax.swing.table.AbstractTableModel;
042import javax.swing.table.DefaultTableCellRenderer;
043import javax.swing.table.TableCellRenderer;
044import javax.swing.table.TableModel;
045
046import org.openstreetmap.josm.actions.ExpertToggleAction;
047import org.openstreetmap.josm.actions.ExpertToggleAction.ExpertModeChangeListener;
048import org.openstreetmap.josm.actions.MergeLayerAction;
049import org.openstreetmap.josm.data.coor.EastNorth;
050import org.openstreetmap.josm.data.imagery.OffsetBookmark;
051import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeEvent;
052import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener;
053import org.openstreetmap.josm.data.preferences.BooleanProperty;
054import org.openstreetmap.josm.gui.MainApplication;
055import org.openstreetmap.josm.gui.MapFrame;
056import org.openstreetmap.josm.gui.MapView;
057import org.openstreetmap.josm.gui.SideButton;
058import org.openstreetmap.josm.gui.dialogs.layer.ActivateLayerAction;
059import org.openstreetmap.josm.gui.dialogs.layer.CycleLayerDownAction;
060import org.openstreetmap.josm.gui.dialogs.layer.CycleLayerUpAction;
061import org.openstreetmap.josm.gui.dialogs.layer.DeleteLayerAction;
062import org.openstreetmap.josm.gui.dialogs.layer.DuplicateAction;
063import org.openstreetmap.josm.gui.dialogs.layer.LayerListTransferHandler;
064import org.openstreetmap.josm.gui.dialogs.layer.LayerVisibilityAction;
065import org.openstreetmap.josm.gui.dialogs.layer.MergeAction;
066import org.openstreetmap.josm.gui.dialogs.layer.MoveDownAction;
067import org.openstreetmap.josm.gui.dialogs.layer.MoveUpAction;
068import org.openstreetmap.josm.gui.dialogs.layer.ShowHideLayerAction;
069import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
070import org.openstreetmap.josm.gui.layer.JumpToMarkerActions;
071import org.openstreetmap.josm.gui.layer.Layer;
072import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
073import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
074import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
075import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
076import org.openstreetmap.josm.gui.layer.MainLayerManager;
077import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
078import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
079import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
080import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
081import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeEvent;
082import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeListener;
083import org.openstreetmap.josm.gui.util.MultikeyActionsHandler;
084import org.openstreetmap.josm.gui.util.MultikeyShortcutAction.MultikeyInfo;
085import org.openstreetmap.josm.gui.util.ReorderableTableModel;
086import org.openstreetmap.josm.gui.util.TableHelper;
087import org.openstreetmap.josm.gui.widgets.DisableShortcutsOnFocusGainedTextField;
088import org.openstreetmap.josm.gui.widgets.JosmTextField;
089import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
090import org.openstreetmap.josm.gui.widgets.ScrollableTable;
091import org.openstreetmap.josm.spi.preferences.Config;
092import org.openstreetmap.josm.tools.ImageProvider;
093import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
094import org.openstreetmap.josm.tools.InputMapUtils;
095import org.openstreetmap.josm.tools.PlatformManager;
096import org.openstreetmap.josm.tools.Shortcut;
097
098/**
099 * This is a toggle dialog which displays the list of layers. Actions allow to
100 * change the ordering of the layers, to hide/show layers, to activate layers,
101 * and to delete layers.
102 * <p>
103 * Support for multiple {@link LayerListDialog} is currently not complete but intended for the future.
104 * @since 17
105 */
106public class LayerListDialog extends ToggleDialog implements DisplaySettingsChangeListener {
107    /** the unique instance of the dialog */
108    private static volatile LayerListDialog instance;
109
110    private static final BooleanProperty DISPLAY_NUMBERS = new BooleanProperty("layerlist.display.numbers", true);
111
112    /**
113     * Creates the instance of the dialog. It's connected to the layer manager
114     *
115     * @param layerManager the layer manager
116     * @since 11885 (signature)
117     */
118    public static void createInstance(MainLayerManager layerManager) {
119        if (instance != null)
120            throw new IllegalStateException("Dialog was already created");
121        instance = new LayerListDialog(layerManager);
122    }
123
124    /**
125     * Replies the instance of the dialog
126     *
127     * @return the instance of the dialog
128     * @throws IllegalStateException if the dialog is not created yet
129     * @see #createInstance(MainLayerManager)
130     */
131    public static LayerListDialog getInstance() {
132        if (instance == null)
133            throw new IllegalStateException("Dialog not created yet. Invoke createInstance() first");
134        return instance;
135    }
136
137    /** the model for the layer list */
138    private final LayerListModel model;
139
140    /** the list of layers (technically its a JTable, but appears like a list) */
141    private final LayerList layerList;
142    private final ColumnWidthAdaptionListener visibilityWidthListener;
143
144    private final ActivateLayerAction activateLayerAction;
145    private final ShowHideLayerAction showHideLayerAction;
146
147    private final CycleLayerUpAction cycleLayerUpAction;
148    private final CycleLayerDownAction cycleLayerDownAction;
149
150    //TODO This duplicates ShowHide actions functionality
151    /** stores which layer index to toggle and executes the ShowHide action if the layer is present */
152    private final class ToggleLayerIndexVisibility extends AbstractAction {
153        private final int layerIndex;
154
155        ToggleLayerIndexVisibility(int layerIndex) {
156            this.layerIndex = layerIndex;
157        }
158
159        @Override
160        public void actionPerformed(ActionEvent e) {
161            final Layer l = model.getLayer(model.getRowCount() - layerIndex - 1);
162            if (l != null) {
163                l.toggleVisible();
164            }
165        }
166    }
167
168    private final transient Shortcut[] visibilityToggleShortcuts = new Shortcut[10];
169    private final ToggleLayerIndexVisibility[] visibilityToggleActions = new ToggleLayerIndexVisibility[10];
170
171    /**
172     * The {@link MainLayerManager} this list is for.
173     */
174    private final transient MainLayerManager layerManager;
175
176    private PopupMenuHandler popupHandler;
177
178    private LayerListModelListener modelListener;
179
180    /**
181     * registers (shortcut to toggle right hand side toggle dialogs)+(number keys) shortcuts
182     * to toggle the visibility of the first ten layers.
183     */
184    private void createVisibilityToggleShortcuts() {
185        for (int i = 0; i < 10; i++) {
186            final int i1 = i + 1;
187            /* POSSIBLE SHORTCUTS: 1,2,3,4,5,6,7,8,9,0=10 */
188            visibilityToggleShortcuts[i] = Shortcut.registerShortcut("subwindow:layers:toggleLayer" + i1,
189                    tr("Toggle visibility of layer: {0}", i1), KeyEvent.VK_0 + (i1 % 10), Shortcut.ALT);
190            visibilityToggleActions[i] = new ToggleLayerIndexVisibility(i);
191            MainApplication.registerActionShortcut(visibilityToggleActions[i], visibilityToggleShortcuts[i]);
192        }
193    }
194
195    /**
196     * Creates a layer list and attach it to the given layer manager.
197     * @param layerManager The layer manager this list is for
198     * @since 10467
199     */
200    public LayerListDialog(MainLayerManager layerManager) {
201        super(tr("Layers"), "layerlist", tr("Open a list of all loaded layers."),
202                Shortcut.registerShortcut("subwindow:layers", tr("Windows: {0}", tr("Layers")), KeyEvent.VK_L,
203                        Shortcut.ALT_SHIFT), 100, true);
204        this.layerManager = layerManager;
205
206        // create the models
207        //
208        DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
209        selectionModel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
210        model = new LayerListModel(layerManager, selectionModel);
211
212        // create the list control
213        //
214        layerList = new LayerList(model);
215        TableHelper.setFont(layerList, getClass());
216        layerList.setSelectionModel(selectionModel);
217        popupHandler = new PopupMenuHandler();
218        layerList.addMouseListener(popupHandler);
219        layerList.setBackground(UIManager.getColor("Button.background"));
220        layerList.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
221        layerList.putClientProperty("JTable.autoStartsEdit", Boolean.FALSE);
222        layerList.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
223        layerList.setTableHeader(null);
224        layerList.setShowGrid(false);
225        layerList.setIntercellSpacing(new Dimension(0, 0));
226        layerList.getColumnModel().getColumn(0).setCellRenderer(new ActiveLayerCellRenderer());
227        layerList.getColumnModel().getColumn(0).setCellEditor(new DefaultCellEditor(new ActiveLayerCheckBox()));
228        layerList.getColumnModel().getColumn(0).setMaxWidth(12);
229        layerList.getColumnModel().getColumn(0).setPreferredWidth(12);
230        layerList.getColumnModel().getColumn(0).setResizable(false);
231
232        layerList.getColumnModel().getColumn(1).setCellRenderer(new NativeScaleLayerCellRenderer());
233        layerList.getColumnModel().getColumn(1).setCellEditor(new DefaultCellEditor(new NativeScaleLayerCheckBox()));
234        layerList.getColumnModel().getColumn(1).setMaxWidth(12);
235        layerList.getColumnModel().getColumn(1).setPreferredWidth(12);
236        layerList.getColumnModel().getColumn(1).setResizable(false);
237
238        layerList.getColumnModel().getColumn(2).setCellRenderer(new OffsetLayerCellRenderer());
239        layerList.getColumnModel().getColumn(2).setCellEditor(new DefaultCellEditor(new OffsetLayerCheckBox()));
240        layerList.getColumnModel().getColumn(2).setMaxWidth(16);
241        layerList.getColumnModel().getColumn(2).setPreferredWidth(16);
242        layerList.getColumnModel().getColumn(2).setResizable(false);
243
244        layerList.getColumnModel().getColumn(3).setCellRenderer(new LayerVisibleCellRenderer());
245        layerList.getColumnModel().getColumn(3).setCellEditor(new LayerVisibleCellEditor(new LayerVisibleCheckBox()));
246        layerList.getColumnModel().getColumn(3).setResizable(false);
247
248        layerList.getColumnModel().getColumn(4).setCellRenderer(new LayerNameCellRenderer());
249        layerList.getColumnModel().getColumn(4).setCellEditor(new LayerNameCellEditor(new DisableShortcutsOnFocusGainedTextField()));
250        // Disable some default JTable shortcuts to use JOSM ones (see #5678, #10458)
251        for (KeyStroke ks : new KeyStroke[] {
252                KeyStroke.getKeyStroke(KeyEvent.VK_C, PlatformManager.getPlatform().getMenuShortcutKeyMaskEx()),
253                KeyStroke.getKeyStroke(KeyEvent.VK_V, PlatformManager.getPlatform().getMenuShortcutKeyMaskEx()),
254                KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.SHIFT_DOWN_MASK),
255                KeyStroke.getKeyStroke(KeyEvent.VK_UP, InputEvent.SHIFT_DOWN_MASK),
256                KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, InputEvent.SHIFT_DOWN_MASK),
257                KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, InputEvent.SHIFT_DOWN_MASK),
258                KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, InputEvent.CTRL_DOWN_MASK),
259                KeyStroke.getKeyStroke(KeyEvent.VK_UP, InputEvent.CTRL_DOWN_MASK),
260                KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, InputEvent.CTRL_DOWN_MASK),
261                KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, InputEvent.CTRL_DOWN_MASK),
262                KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0),
263                KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, 0),
264                KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0),
265                KeyStroke.getKeyStroke(KeyEvent.VK_F8, 0),
266        }) {
267            layerList.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks, new Object());
268        }
269
270        visibilityWidthListener = new ColumnWidthAdaptionListener(3, 16);
271        DISPLAY_NUMBERS.addListener(visibilityWidthListener);
272        ExpertToggleAction.addExpertModeChangeListener(visibilityWidthListener);
273        layerManager.addLayerChangeListener(visibilityWidthListener);
274        visibilityWidthListener.updateColumnWidth();
275
276        // init the model
277        //
278        model.populate();
279        model.setSelectedLayer(layerManager.getActiveLayer());
280        modelListener = new LayerListModelListener() {
281            @Override
282            public void makeVisible(int row, Layer layer) {
283                layerList.scrollToVisible(row, 0);
284                layerList.repaint();
285            }
286
287            @Override
288            public void refresh() {
289                layerList.repaint();
290            }
291        };
292
293        model.addLayerListModelListener(modelListener);
294
295        // -- move up action
296        MoveUpAction moveUpAction = new MoveUpAction(model);
297        TableHelper.adaptTo(moveUpAction, model);
298        TableHelper.adaptTo(moveUpAction, selectionModel);
299
300        // -- move down action
301        MoveDownAction moveDownAction = new MoveDownAction(model);
302        TableHelper.adaptTo(moveDownAction, model);
303        TableHelper.adaptTo(moveDownAction, selectionModel);
304
305        // -- activate action
306        activateLayerAction = new ActivateLayerAction(model);
307        activateLayerAction.updateEnabledState();
308        MultikeyActionsHandler.getInstance().addAction(activateLayerAction);
309        TableHelper.adaptTo(activateLayerAction, selectionModel);
310
311        JumpToMarkerActions.initialize();
312
313        // -- show hide action
314        showHideLayerAction = new ShowHideLayerAction(model);
315        MultikeyActionsHandler.getInstance().addAction(showHideLayerAction);
316        TableHelper.adaptTo(showHideLayerAction, selectionModel);
317
318        LayerVisibilityAction visibilityAction = new LayerVisibilityAction(model);
319        TableHelper.adaptTo(visibilityAction, selectionModel);
320        SideButton visibilityButton = new SideButton(visibilityAction, false);
321        visibilityAction.setCorrespondingSideButton(visibilityButton);
322
323        // -- delete layer action
324        DeleteLayerAction deleteLayerAction = new DeleteLayerAction(model);
325        layerList.getActionMap().put("deleteLayer", deleteLayerAction);
326        TableHelper.adaptTo(deleteLayerAction, selectionModel);
327        getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(
328                KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "delete"
329                );
330        getActionMap().put("delete", deleteLayerAction);
331
332        // Activate layer on Enter key press
333        InputMapUtils.addEnterAction(layerList, new AbstractAction() {
334            @Override
335            public void actionPerformed(ActionEvent e) {
336                activateLayerAction.actionPerformed(null);
337                layerList.requestFocus();
338            }
339        });
340
341        // Show/Activate layer on Enter key press
342        InputMapUtils.addSpacebarAction(layerList, showHideLayerAction);
343
344        // Cycle layer actions
345        cycleLayerUpAction = new CycleLayerUpAction();
346        cycleLayerDownAction = new CycleLayerDownAction();
347
348        createLayout(layerList, true, Arrays.asList(
349                new SideButton(moveUpAction, false),
350                new SideButton(moveDownAction, false),
351                new SideButton(activateLayerAction, false),
352                visibilityButton,
353                new SideButton(deleteLayerAction, false)
354        ));
355
356        createVisibilityToggleShortcuts();
357    }
358
359    private static boolean displayLayerNumbers() {
360        return ExpertToggleAction.isExpert() && DISPLAY_NUMBERS.get();
361    }
362
363    /**
364     * Gets the layer manager this dialog is for.
365     * @return The layer manager.
366     * @since 10288
367     */
368    public MainLayerManager getLayerManager() {
369        return layerManager;
370    }
371
372    @Override
373    public void showNotify() {
374        layerManager.addActiveLayerChangeListener(activateLayerAction);
375        layerManager.addAndFireLayerChangeListener(model);
376        layerManager.addAndFireActiveLayerChangeListener(model);
377        model.populate();
378    }
379
380    @Override
381    public void hideNotify() {
382        layerManager.removeAndFireLayerChangeListener(model);
383        layerManager.removeActiveLayerChangeListener(model);
384        layerManager.removeActiveLayerChangeListener(activateLayerAction);
385    }
386
387    /**
388     * Returns the layer list model.
389     * @return the layer list model
390     */
391    public LayerListModel getModel() {
392        return model;
393    }
394
395    @Override
396    public void destroy() {
397        for (int i = 0; i < 10; i++) {
398            MainApplication.unregisterActionShortcut(visibilityToggleActions[i], visibilityToggleShortcuts[i]);
399        }
400        MultikeyActionsHandler.getInstance().removeAction(activateLayerAction);
401        MultikeyActionsHandler.getInstance().removeAction(showHideLayerAction);
402        JumpToMarkerActions.unregisterActions();
403        layerList.setTransferHandler(null);
404        layerList.removeMouseListener(popupHandler);
405        DISPLAY_NUMBERS.removeListener(visibilityWidthListener);
406        ExpertToggleAction.removeExpertModeChangeListener(visibilityWidthListener);
407        layerManager.removeLayerChangeListener(visibilityWidthListener);
408        activateLayerAction.destroy();
409        cycleLayerUpAction.destroy();
410        cycleLayerDownAction.destroy();
411        model.removeLayerListModelListener(modelListener);
412        super.destroy();
413        instance = null;
414    }
415
416    static ImageIcon createBlankIcon() {
417        return ImageProvider.createBlankIcon(ImageSizes.LAYER);
418    }
419
420    private class ColumnWidthAdaptionListener implements ValueChangeListener<Boolean>, ExpertModeChangeListener, LayerChangeListener {
421        private final int minWidth;
422        private final int column;
423
424        ColumnWidthAdaptionListener(int column, int minWidth) {
425            this.column = column;
426            this.minWidth = minWidth;
427        }
428
429        @Override
430        public void expertChanged(boolean isExpert) {
431            updateColumnWidth();
432        }
433
434        @Override
435        public void valueChanged(ValueChangeEvent<? extends Boolean> e) {
436            updateColumnWidth();
437        }
438
439        @Override
440        public void layerAdded(LayerAddEvent e) {
441            updateColumnWidth();
442        }
443
444        @Override
445        public void layerRemoving(LayerRemoveEvent e) {
446            updateColumnWidth();
447        }
448
449        @Override
450        public void layerOrderChanged(LayerOrderChangeEvent e) {
451            //not needed
452        }
453
454        public void updateColumnWidth() {
455            int width = minWidth;
456            for (int row = 0; row < layerList.getRowCount(); row++) {
457                TableCellRenderer renderer = layerList.getCellRenderer(row, column);
458                Component comp = layerList.prepareRenderer(renderer, row, column);
459                width = Math.max(comp.getPreferredSize().width + 1, width);
460            }
461            layerList.getColumnModel().getColumn(column).setMaxWidth(width);
462            layerList.getColumnModel().getColumn(column).setPreferredWidth(width);
463            repaint();
464        }
465    }
466
467    private static class ActiveLayerCheckBox extends JCheckBox {
468        ActiveLayerCheckBox() {
469            setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
470            ImageIcon blank = createBlankIcon();
471            ImageIcon active = ImageProvider.get("dialogs/layerlist", "active");
472            setIcon(blank);
473            setSelectedIcon(active);
474            setRolloverIcon(blank);
475            setRolloverSelectedIcon(active);
476        }
477    }
478
479    private static class LayerVisibleCheckBox extends JCheckBox {
480        private final ImageIcon iconEye;
481        private final ImageIcon iconEyeTranslucent;
482        private boolean isTranslucent;
483        private Layer layer;
484
485        /**
486         * Constructs a new {@code LayerVisibleCheckBox}.
487         */
488        LayerVisibleCheckBox() {
489            iconEye = new EyeIcon(/* ICON(dialogs/layerlist/) */ "eye");
490            iconEyeTranslucent = new EyeIcon(/* ICON(dialogs/layerlist/) */ "eye-translucent", true);
491            setIcon(ImageProvider.get("dialogs/layerlist", "eye-off"));
492            setSelectedIcon(iconEye);
493            isTranslucent = false;
494        }
495
496        public void setTranslucent(boolean isTranslucent) {
497            if (this.isTranslucent == isTranslucent) return;
498            if (isTranslucent) {
499                setSelectedIcon(iconEyeTranslucent);
500            } else {
501                setSelectedIcon(iconEye);
502            }
503            this.isTranslucent = isTranslucent;
504        }
505
506        public void updateStatus(Layer layer) {
507            this.layer = layer;
508            boolean visible = layer.isVisible();
509            setSelected(visible);
510            if (displayLayerNumbers()) {
511                List<Layer> layers = MainApplication.getLayerManager().getLayers();
512                int num = layers.size() - layers.indexOf(layer);
513                setText(String.format("%s[%d]", num < 10 ? " " : "", num));
514            } else {
515                setText(null);
516            }
517            setTranslucent(layer.getOpacity() < 1.0);
518            setToolTipText(visible ?
519                tr("layer is currently visible (click to hide layer)") :
520                tr("layer is currently hidden (click to show layer)"));
521        }
522
523        private class EyeIcon extends ImageIcon {
524            private final boolean translucent;
525
526            EyeIcon(String name) {
527                this(name, false);
528            }
529
530            EyeIcon(String name, boolean translucent) {
531                super(ImageProvider.get("dialogs/layerlist", name).getImage());
532                this.translucent = translucent;
533            }
534
535            @Override
536            public synchronized void paintIcon(Component comp, Graphics g, int x, int y) {
537                Color c;
538                if (Config.getPref().getBoolean("dialog.layer.colorname", true)
539                        && layer != null && (c = layer.getColor()) != null) {
540                    if (g instanceof Graphics2D) {
541                        ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
542                    }
543                    if (translucent) {
544                        g.setColor(new Color(c.getRed(), c.getGreen(), c.getBlue(), 125));
545                    } else {
546                        g.setColor(c);
547                    }
548                    g.fillOval(x, y + 2, getIconWidth(), getIconHeight() - 3);
549                }
550                super.paintIcon(comp, g, x, y);
551            }
552        }
553    }
554
555    private static class NativeScaleLayerCheckBox extends JCheckBox {
556        NativeScaleLayerCheckBox() {
557            setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
558            ImageIcon blank = createBlankIcon();
559            ImageIcon active = ImageProvider.get("dialogs/layerlist", "scale");
560            setIcon(blank);
561            setSelectedIcon(active);
562        }
563    }
564
565    private static class OffsetLayerCheckBox extends JCheckBox {
566        OffsetLayerCheckBox() {
567            setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
568            ImageIcon blank = createBlankIcon();
569            ImageIcon withOffset = ImageProvider.get("dialogs/layerlist", "offset");
570            setIcon(blank);
571            setSelectedIcon(withOffset);
572        }
573    }
574
575    private static class ActiveLayerCellRenderer implements TableCellRenderer {
576        private final JCheckBox cb;
577
578        /**
579         * Constructs a new {@code ActiveLayerCellRenderer}.
580         */
581        ActiveLayerCellRenderer() {
582            cb = new ActiveLayerCheckBox();
583        }
584
585        @Override
586        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
587            boolean active = value != null && (Boolean) value;
588            cb.setSelected(active);
589            cb.setToolTipText(active ? tr("this layer is the active layer") : tr("this layer is not currently active (click to activate)"));
590            return cb;
591        }
592    }
593
594    private static class LayerVisibleCellRenderer implements TableCellRenderer {
595        private final LayerVisibleCheckBox cb;
596
597        /**
598         * Constructs a new {@code LayerVisibleCellRenderer}.
599         */
600        LayerVisibleCellRenderer() {
601            this.cb = new LayerVisibleCheckBox();
602        }
603
604        @Override
605        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
606            if (value != null) {
607                cb.updateStatus((Layer) value);
608            }
609            return cb;
610        }
611    }
612
613    private static class LayerVisibleCellEditor extends DefaultCellEditor {
614        private final LayerVisibleCheckBox cb;
615
616        LayerVisibleCellEditor(LayerVisibleCheckBox cb) {
617            super(cb);
618            this.cb = cb;
619        }
620
621        @Override
622        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
623            cb.updateStatus((Layer) value);
624            return cb;
625        }
626    }
627
628    private static class NativeScaleLayerCellRenderer implements TableCellRenderer {
629        private final JCheckBox cb;
630
631        /**
632         * Constructs a new {@code ActiveLayerCellRenderer}.
633         */
634        NativeScaleLayerCellRenderer() {
635            cb = new NativeScaleLayerCheckBox();
636        }
637
638        @Override
639        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
640            Layer layer = (Layer) value;
641            if (layer instanceof NativeScaleLayer) {
642                boolean active = ((NativeScaleLayer) layer) == MainApplication.getMap().mapView.getNativeScaleLayer();
643                cb.setSelected(active);
644                if (MainApplication.getMap().mapView.getNativeScaleLayer() != null) {
645                    cb.setToolTipText(active
646                            ? tr("scale follows native resolution of this layer")
647                            : tr("scale follows native resolution of another layer (click to set this layer)"));
648                } else {
649                    cb.setToolTipText(tr("scale does not follow native resolution of any layer (click to set this layer)"));
650                }
651            } else {
652                cb.setSelected(false);
653                cb.setToolTipText(tr("this layer has no native resolution"));
654            }
655            return cb;
656        }
657    }
658
659    private static class OffsetLayerCellRenderer implements TableCellRenderer {
660        private final JCheckBox cb;
661
662        /**
663         * Constructs a new {@code OffsetLayerCellRenderer}.
664         */
665        OffsetLayerCellRenderer() {
666            cb = new OffsetLayerCheckBox();
667            cb.setEnabled(false);
668        }
669
670        @Override
671        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
672            Layer layer = (Layer) value;
673            if (layer instanceof AbstractTileSourceLayer<?>) {
674                final TileSourceDisplaySettings displaySettings = ((AbstractTileSourceLayer<?>) layer).getDisplaySettings();
675                if (EastNorth.ZERO.equals(displaySettings.getDisplacement())) {
676                    final boolean hasPreviousOffset = displaySettings.getPreviousOffsetBookmark() != null;
677                    cb.setSelected(false);
678                    cb.setEnabled(hasPreviousOffset);
679                    cb.setToolTipText(tr("layer is without a user-defined offset") +
680                            (hasPreviousOffset ? " " + tr("(click to activate previous offset)") : ""));
681                } else {
682                    cb.setSelected(true);
683                    cb.setEnabled(true);
684                    cb.setToolTipText(tr("layer has an offset of {0} (click to remove offset)",
685                            displaySettings.getDisplacementString(Locale.getDefault())));
686                }
687
688            } else {
689                cb.setSelected(false);
690                cb.setEnabled(false);
691                cb.setToolTipText(tr("this layer can not have an offset"));
692            }
693            return cb;
694        }
695    }
696
697    private final class LayerNameCellRenderer extends DefaultTableCellRenderer {
698
699        boolean isActiveLayer(Layer layer) {
700            return getLayerManager().getActiveLayer() == layer;
701        }
702
703        @Override
704        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
705            if (value == null)
706                return this;
707            Layer layer = (Layer) value;
708            JLabel label = (JLabel) super.getTableCellRendererComponent(table,
709                    layer.getLabel(), isSelected, hasFocus, row, column);
710            if (isActiveLayer(layer)) {
711                label.setFont(label.getFont().deriveFont(Font.BOLD));
712            }
713            label.setIcon(layer.getIcon());
714            label.setToolTipText(layer.getToolTipText());
715            return label;
716        }
717    }
718
719    private static class LayerNameCellEditor extends DefaultCellEditor {
720        LayerNameCellEditor(DisableShortcutsOnFocusGainedTextField tf) {
721            super(tf);
722        }
723
724        @Override
725        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
726            JosmTextField tf = (JosmTextField) super.getTableCellEditorComponent(table, value, isSelected, row, column);
727            tf.setText(value == null ? "" : ((Layer) value).getName());
728            return tf;
729        }
730    }
731
732    class PopupMenuHandler extends PopupMenuLauncher {
733        @Override
734        public void showMenu(MouseEvent evt) {
735            menu = new LayerListPopup(getModel().getSelectedLayers());
736            super.showMenu(evt);
737        }
738    }
739
740    /**
741     * Observer interface to be implemented by views using {@link LayerListModel}.
742     */
743    public interface LayerListModelListener {
744
745        /**
746         * Fired when a layer is made visible.
747         * @param index the layer index
748         * @param layer the layer
749         */
750        void makeVisible(int index, Layer layer);
751
752        /**
753         * Fired when something has changed in the layer list model.
754         */
755        void refresh();
756    }
757
758    /**
759     * The layer list model. The model manages a list of layers and provides methods for
760     * moving layers up and down, for toggling their visibility, and for activating a layer.
761     *
762     * The model is a {@link TableModel} and it provides a {@link ListSelectionModel}. It expects
763     * to be configured with a {@link DefaultListSelectionModel}. The selection model is used
764     * to update the selection state of views depending on messages sent to the model.
765     *
766     * The model manages a list of {@link LayerListModelListener} which are mainly notified if
767     * the model requires views to make a specific list entry visible.
768     *
769     * It also listens to {@link PropertyChangeEvent}s of every {@link Layer} it manages, in particular to
770     * the properties {@link Layer#VISIBLE_PROP} and {@link Layer#NAME_PROP}.
771     */
772    public static final class LayerListModel extends AbstractTableModel
773            implements LayerChangeListener, ActiveLayerChangeListener, PropertyChangeListener, ReorderableTableModel<Layer> {
774        /** manages list selection state*/
775        private final DefaultListSelectionModel selectionModel;
776        private final CopyOnWriteArrayList<LayerListModelListener> listeners;
777        private LayerList layerList;
778        private final MainLayerManager layerManager;
779
780        /**
781         * constructor
782         * @param layerManager The layer manager to use for the list.
783         * @param selectionModel the list selection model
784         */
785        LayerListModel(MainLayerManager layerManager, DefaultListSelectionModel selectionModel) {
786            this.layerManager = layerManager;
787            this.selectionModel = selectionModel;
788            listeners = new CopyOnWriteArrayList<>();
789        }
790
791        void setLayerList(LayerList layerList) {
792            this.layerList = layerList;
793        }
794
795        /**
796         * The layer manager this model is for.
797         * @return The layer manager.
798         */
799        public MainLayerManager getLayerManager() {
800            return layerManager;
801        }
802
803        /**
804         * Adds a listener to this model
805         *
806         * @param listener the listener
807         */
808        public void addLayerListModelListener(LayerListModelListener listener) {
809            if (listener != null) {
810                listeners.addIfAbsent(listener);
811            }
812        }
813
814        /**
815         * removes a listener from  this model
816         * @param listener the listener
817         */
818        public void removeLayerListModelListener(LayerListModelListener listener) {
819            listeners.remove(listener);
820        }
821
822        /**
823         * Fires a make visible event to listeners
824         *
825         * @param index the index of the row to make visible
826         * @param layer the layer at this index
827         * @see LayerListModelListener#makeVisible(int, Layer)
828         */
829        private void fireMakeVisible(int index, Layer layer) {
830            for (LayerListModelListener listener : listeners) {
831                listener.makeVisible(index, layer);
832            }
833        }
834
835        /**
836         * Fires a refresh event to listeners of this model
837         *
838         * @see LayerListModelListener#refresh()
839         */
840        private void fireRefresh() {
841            for (LayerListModelListener listener : listeners) {
842                listener.refresh();
843            }
844        }
845
846        /**
847         * Populates the model with the current layers managed by {@link MapView}.
848         */
849        public void populate() {
850            for (Layer layer: getLayers()) {
851                // make sure the model is registered exactly once
852                layer.removePropertyChangeListener(this);
853                layer.addPropertyChangeListener(this);
854            }
855            fireTableDataChanged();
856        }
857
858        /**
859         * Marks <code>layer</code> as selected layer. Ignored, if layer is null.
860         *
861         * @param layer the layer.
862         */
863        public void setSelectedLayer(Layer layer) {
864            if (layer == null)
865                return;
866            int idx = getLayers().indexOf(layer);
867            if (idx >= 0) {
868                selectionModel.setSelectionInterval(idx, idx);
869            }
870            ensureSelectedIsVisible();
871        }
872
873        /**
874         * Replies the list of currently selected layers. Never null, but may be empty.
875         *
876         * @return the list of currently selected layers. Never null, but may be empty.
877         */
878        public List<Layer> getSelectedLayers() {
879            List<Layer> layers = getLayers();
880            return IntStream.range(0, layers.size())
881                    .filter(selectionModel::isSelectedIndex)
882                    .mapToObj(layers::get)
883                    .collect(Collectors.toList());
884        }
885
886        /**
887         * Replies a the list of indices of the selected rows. Never null, but may be empty.
888         *
889         * @return  the list of indices of the selected rows. Never null, but may be empty.
890         */
891        public List<Integer> getSelectedRows() {
892            return TableHelper.selectedIndices(selectionModel).boxed().collect(Collectors.toList());
893        }
894
895        /**
896         * Invoked if a layer managed by {@link MapView} is removed
897         *
898         * @param layer the layer which is removed
899         */
900        private void onRemoveLayer(Layer layer) {
901            if (layer == null)
902                return;
903            layer.removePropertyChangeListener(this);
904            final int size = getRowCount();
905
906            if (selectionModel.isSelectionEmpty() && size > 0) {
907                selectionModel.setSelectionInterval(size-1, size-1);
908            }
909            fireTableDataChanged();
910            fireRefresh();
911            ensureActiveSelected();
912            if (layer instanceof AbstractTileSourceLayer<?>) {
913                ((AbstractTileSourceLayer<?>) layer).getDisplaySettings().removeSettingsChangeListener(LayerListDialog.getInstance());
914            }
915
916        }
917
918        /**
919         * Invoked when a layer managed by {@link MapView} is added
920         *
921         * @param layer the layer
922         */
923        private void onAddLayer(Layer layer) {
924            if (layer == null)
925                return;
926            layer.addPropertyChangeListener(this);
927            fireTableDataChanged();
928            int idx = getLayers().indexOf(layer);
929            Icon icon = layer.getIcon();
930            if (layerList != null && icon != null) {
931                layerList.setRowHeight(idx, Math.max(layerList.getRowHeight(), icon.getIconHeight()));
932            }
933            selectionModel.setSelectionInterval(idx, idx);
934            ensureSelectedIsVisible();
935            if (layer instanceof AbstractTileSourceLayer<?>) {
936                ((AbstractTileSourceLayer<?>) layer).getDisplaySettings().addSettingsChangeListener(LayerListDialog.getInstance());
937            }
938        }
939
940        /**
941         * Replies the first layer. Null if no layers are present
942         *
943         * @return the first layer. Null if no layers are present
944         */
945        public Layer getFirstLayer() {
946            if (getRowCount() == 0)
947                return null;
948            return getLayers().get(0);
949        }
950
951        /**
952         * Replies the layer at position <code>index</code>
953         *
954         * @param index the index
955         * @return the layer at position <code>index</code>. Null,
956         * if index is out of range.
957         */
958        public Layer getLayer(int index) {
959            if (index < 0 || index >= getRowCount())
960                return null;
961            return getLayers().get(index);
962        }
963
964        @Override
965        public DefaultListSelectionModel getSelectionModel() {
966            return selectionModel;
967        }
968
969        @Override
970        public Layer getValue(int index) {
971            return getLayer(index);
972        }
973
974        @Override
975        public Layer setValue(int index, Layer value) {
976            throw new UnsupportedOperationException();
977        }
978
979        @Override
980        public boolean doMove(int delta, int... selectedRows) {
981            if (delta != 0) {
982                List<Layer> layers = getLayers();
983                MapView mapView = MainApplication.getMap().mapView;
984                if (delta < 0) {
985                    for (int row : selectedRows) {
986                        mapView.moveLayer(layers.get(row), row + delta);
987                    }
988                } else {
989                    for (int i = selectedRows.length - 1; i >= 0; i--) {
990                        mapView.moveLayer(layers.get(selectedRows[i]), selectedRows[i] + delta);
991                    }
992                }
993                fireTableDataChanged();
994            }
995            return delta != 0;
996        }
997
998        @Override
999        public boolean move(int delta, int... selectedRows) {
1000            if (!ReorderableTableModel.super.move(delta, selectedRows))
1001                return false;
1002            ensureSelectedIsVisible();
1003            return true;
1004        }
1005
1006        /**
1007         * Make sure the first of the selected layers is visible in the views of this model.
1008         */
1009        private void ensureSelectedIsVisible() {
1010            int index = selectionModel.getMinSelectionIndex();
1011            if (index < 0)
1012                return;
1013            List<Layer> layers = getLayers();
1014            if (index >= layers.size())
1015                return;
1016            Layer layer = layers.get(index);
1017            fireMakeVisible(index, layer);
1018        }
1019
1020        /**
1021         * Replies a list of layers which are possible merge targets for <code>source</code>
1022         *
1023         * @param source the source layer
1024         * @return a list of layers which are possible merge targets
1025         * for <code>source</code>. Never null, but can be empty.
1026         */
1027        public List<Layer> getPossibleMergeTargets(Layer source) {
1028            if (source == null) {
1029                return new ArrayList<>();
1030            }
1031            return getLayers().stream()
1032                    .filter(target -> source != target && target.isMergable(source) && source.isMergable(target))
1033                    .collect(Collectors.toList());
1034        }
1035
1036        /**
1037         * Replies the list of layers currently managed by {@link MapView}.
1038         * Never null, but can be empty.
1039         *
1040         * @return the list of layers currently managed by {@link MapView}.
1041         * Never null, but can be empty.
1042         */
1043        public List<Layer> getLayers() {
1044            return getLayerManager().getLayers();
1045        }
1046
1047        /**
1048         * Ensures that at least one layer is selected in the layer dialog
1049         *
1050         */
1051        private void ensureActiveSelected() {
1052            List<Layer> layers = getLayers();
1053            if (layers.isEmpty())
1054                return;
1055            final Layer activeLayer = getActiveLayer();
1056            if (activeLayer != null) {
1057                // there's an active layer - select it and make it visible
1058                int idx = layers.indexOf(activeLayer);
1059                selectionModel.setSelectionInterval(idx, idx);
1060                ensureSelectedIsVisible();
1061            } else {
1062                // no active layer - select the first one and make it visible
1063                selectionModel.setSelectionInterval(0, 0);
1064                ensureSelectedIsVisible();
1065            }
1066        }
1067
1068        /**
1069         * Replies the active layer. null, if no active layer is available
1070         *
1071         * @return the active layer. null, if no active layer is available
1072         */
1073        private Layer getActiveLayer() {
1074            return getLayerManager().getActiveLayer();
1075        }
1076
1077        /* ------------------------------------------------------------------------------ */
1078        /* Interface TableModel                                                           */
1079        /* ------------------------------------------------------------------------------ */
1080
1081        @Override
1082        public int getRowCount() {
1083            List<Layer> layers = getLayers();
1084            return layers == null ? 0 : layers.size();
1085        }
1086
1087        @Override
1088        public int getColumnCount() {
1089            return 5;
1090        }
1091
1092        @Override
1093        public Object getValueAt(int row, int col) {
1094            List<Layer> layers = getLayers();
1095            if (row >= 0 && row < layers.size()) {
1096                switch (col) {
1097                case 0: return layers.get(row) == getActiveLayer();
1098                case 1:
1099                case 2:
1100                case 3:
1101                case 4: return layers.get(row);
1102                default: // Do nothing
1103                }
1104            }
1105            return null;
1106        }
1107
1108        @Override
1109        public boolean isCellEditable(int row, int col) {
1110            return col != 0 || getActiveLayer() != getLayers().get(row);
1111        }
1112
1113        @Override
1114        public void setValueAt(Object value, int row, int col) {
1115            List<Layer> layers = getLayers();
1116            if (row < layers.size()) {
1117                Layer l = layers.get(row);
1118                switch (col) {
1119                case 0:
1120                    getLayerManager().setActiveLayer(l);
1121                    l.setVisible(true);
1122                    break;
1123                case 1:
1124                    MapFrame map = MainApplication.getMap();
1125                    NativeScaleLayer oldLayer = map.mapView.getNativeScaleLayer();
1126                    if (oldLayer == l) {
1127                        map.mapView.setNativeScaleLayer(null);
1128                    } else if (l instanceof NativeScaleLayer) {
1129                        map.mapView.setNativeScaleLayer((NativeScaleLayer) l);
1130                        if (oldLayer instanceof Layer) {
1131                            int idx = getLayers().indexOf((Layer) oldLayer);
1132                            if (idx >= 0) {
1133                                fireTableCellUpdated(idx, col);
1134                            }
1135                        }
1136                    }
1137                    break;
1138                case 2:
1139                    // reset layer offset
1140                    if (l instanceof AbstractTileSourceLayer<?>) {
1141                        final TileSourceDisplaySettings displaySettings = ((AbstractTileSourceLayer<?>) l).getDisplaySettings();
1142                        final OffsetBookmark offsetBookmark = displaySettings.getOffsetBookmark();
1143                        if (offsetBookmark != null) {
1144                            displaySettings.setOffsetBookmark(null);
1145                            MainApplication.getMenu().imageryMenu.refreshOffsetMenu();
1146                        } else {
1147                            displaySettings.setOffsetBookmark(displaySettings.getPreviousOffsetBookmark());
1148                        }
1149                    }
1150                    break;
1151                case 3:
1152                    l.setVisible((Boolean) value);
1153                    break;
1154                case 4:
1155                    l.rename((String) value);
1156                    break;
1157                default:
1158                    throw new IllegalArgumentException("Wrong column: " + col);
1159                }
1160                fireTableCellUpdated(row, col);
1161            }
1162        }
1163
1164        /* ------------------------------------------------------------------------------ */
1165        /* Interface ActiveLayerChangeListener                                            */
1166        /* ------------------------------------------------------------------------------ */
1167        @Override
1168        public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
1169            Layer oldLayer = e.getPreviousActiveLayer();
1170            if (oldLayer != null) {
1171                int idx = getLayers().indexOf(oldLayer);
1172                if (idx >= 0) {
1173                    fireTableRowsUpdated(idx, idx);
1174                }
1175            }
1176
1177            Layer newLayer = getActiveLayer();
1178            if (newLayer != null) {
1179                int idx = getLayers().indexOf(newLayer);
1180                if (idx >= 0) {
1181                    fireTableRowsUpdated(idx, idx);
1182                }
1183            }
1184            ensureActiveSelected();
1185        }
1186
1187        /* ------------------------------------------------------------------------------ */
1188        /* Interface LayerChangeListener                                                  */
1189        /* ------------------------------------------------------------------------------ */
1190        @Override
1191        public void layerAdded(LayerAddEvent e) {
1192            onAddLayer(e.getAddedLayer());
1193        }
1194
1195        @Override
1196        public void layerRemoving(LayerRemoveEvent e) {
1197            onRemoveLayer(e.getRemovedLayer());
1198        }
1199
1200        @Override
1201        public void layerOrderChanged(LayerOrderChangeEvent e) {
1202            fireTableDataChanged();
1203        }
1204
1205        /* ------------------------------------------------------------------------------ */
1206        /* Interface PropertyChangeListener                                               */
1207        /* ------------------------------------------------------------------------------ */
1208        @Override
1209        public void propertyChange(PropertyChangeEvent evt) {
1210            if (evt.getSource() instanceof Layer) {
1211                Layer layer = (Layer) evt.getSource();
1212                final int idx = getLayers().indexOf(layer);
1213                if (idx < 0)
1214                    return;
1215                fireRefresh();
1216            }
1217        }
1218    }
1219
1220    /**
1221     * This component displays a list of layers and provides the methods needed by {@link LayerListModel}.
1222     */
1223    static class LayerList extends ScrollableTable {
1224
1225        LayerList(LayerListModel dataModel) {
1226            super(dataModel);
1227            dataModel.setLayerList(this);
1228            if (!GraphicsEnvironment.isHeadless()) {
1229                setDragEnabled(true);
1230            }
1231            setDropMode(DropMode.INSERT_ROWS);
1232            setTransferHandler(new LayerListTransferHandler());
1233        }
1234
1235        @Override
1236        public LayerListModel getModel() {
1237            return (LayerListModel) super.getModel();
1238        }
1239    }
1240
1241    /**
1242     * Creates a {@link ShowHideLayerAction} in the context of this {@link LayerListDialog}.
1243     *
1244     * @return the action
1245     */
1246    public ShowHideLayerAction createShowHideLayerAction() {
1247        return new ShowHideLayerAction(model);
1248    }
1249
1250    /**
1251     * Creates a {@link DeleteLayerAction} in the context of this {@link LayerListDialog}.
1252     *
1253     * @return the action
1254     */
1255    public DeleteLayerAction createDeleteLayerAction() {
1256        return new DeleteLayerAction(model);
1257    }
1258
1259    /**
1260     * Creates a {@link ActivateLayerAction} for <code>layer</code> in the context of this {@link LayerListDialog}.
1261     *
1262     * @param layer the layer
1263     * @return the action
1264     */
1265    public ActivateLayerAction createActivateLayerAction(Layer layer) {
1266        return new ActivateLayerAction(layer, model);
1267    }
1268
1269    /**
1270     * Creates a {@link MergeLayerAction} for <code>layer</code> in the context of this {@link LayerListDialog}.
1271     *
1272     * @param layer the layer
1273     * @return the action
1274     */
1275    public MergeAction createMergeLayerAction(Layer layer) {
1276        return new MergeAction(layer, model);
1277    }
1278
1279    /**
1280     * Creates a {@link DuplicateAction} for <code>layer</code> in the context of this {@link LayerListDialog}.
1281     *
1282     * @param layer the layer
1283     * @return the action
1284     */
1285    public DuplicateAction createDuplicateLayerAction(Layer layer) {
1286        return new DuplicateAction(layer, model);
1287    }
1288
1289    /**
1290     * Returns the layer at given index, or {@code null}.
1291     * @param index the index
1292     * @return the layer at given index, or {@code null} if index out of range
1293     */
1294    public static Layer getLayerForIndex(int index) {
1295        List<Layer> layers = MainApplication.getLayerManager().getLayers();
1296
1297        if (index < layers.size() && index >= 0)
1298            return layers.get(index);
1299        else
1300            return null;
1301    }
1302
1303    /**
1304     * Returns a list of info on all layers of a given class.
1305     * @param layerClass The layer class. This is not {@code Class<? extends Layer>} on purpose,
1306     *                   to allow asking for layers implementing some interface
1307     * @return list of info on all layers assignable from {@code layerClass}
1308     */
1309    public static List<MultikeyInfo> getLayerInfoByClass(Class<?> layerClass) {
1310        List<MultikeyInfo> result = new ArrayList<>();
1311
1312        List<Layer> layers = MainApplication.getLayerManager().getLayers();
1313
1314        int index = 0;
1315        for (Layer l: layers) {
1316            if (layerClass.isAssignableFrom(l.getClass())) {
1317                result.add(new MultikeyInfo(index, l.getName()));
1318            }
1319            index++;
1320        }
1321
1322        return result;
1323    }
1324
1325    /**
1326     * Determines if a layer is valid (contained in global layer list).
1327     * @param l the layer
1328     * @return {@code true} if layer {@code l} is contained in current layer list
1329     */
1330    public static boolean isLayerValid(Layer l) {
1331        if (l == null)
1332            return false;
1333
1334        return MainApplication.getLayerManager().containsLayer(l);
1335    }
1336
1337    /**
1338     * Returns info about layer.
1339     * @param l the layer
1340     * @return info about layer {@code l}
1341     */
1342    public static MultikeyInfo getLayerInfo(Layer l) {
1343        if (l == null)
1344            return null;
1345
1346        int index = MainApplication.getLayerManager().getLayers().indexOf(l);
1347        if (index < 0)
1348            return null;
1349
1350        return new MultikeyInfo(index, l.getName());
1351    }
1352
1353    @Override
1354    public void displaySettingsChanged(DisplaySettingsChangeEvent e) {
1355        if ("displacement".equals(e.getChangedSetting())) {
1356            layerList.repaint();
1357        }
1358    }
1359}