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

Last change on this file was 19517, checked in by stoecker, 8 weeks ago

update tools
  • Property svn:eol-style set to native
File size: 52.4 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.gui.dialogs;
3
4import static org.openstreetmap.josm.tools.I18n.tr;
5
6import java.awt.Color;
7import java.awt.Component;
8import java.awt.Dimension;
9import java.awt.Font;
10import java.awt.Graphics;
11import java.awt.Graphics2D;
12import java.awt.GraphicsEnvironment;
13import java.awt.RenderingHints;
14import java.awt.event.ActionEvent;
15import java.awt.event.InputEvent;
16import java.awt.event.KeyEvent;
17import java.awt.event.MouseEvent;
18import java.beans.PropertyChangeEvent;
19import java.beans.PropertyChangeListener;
20import java.util.ArrayList;
21import java.util.Arrays;
22import java.util.List;
23import java.util.Locale;
24import java.util.concurrent.CopyOnWriteArrayList;
25import java.util.stream.Collectors;
26import java.util.stream.IntStream;
27
28import javax.swing.AbstractAction;
29import javax.swing.DefaultCellEditor;
30import javax.swing.DefaultListSelectionModel;
31import javax.swing.DropMode;
32import javax.swing.Icon;
33import javax.swing.ImageIcon;
34import javax.swing.JCheckBox;
35import javax.swing.JComponent;
36import javax.swing.JLabel;
37import javax.swing.JTable;
38import javax.swing.KeyStroke;
39import javax.swing.ListSelectionModel;
40import javax.swing.UIManager;
41import javax.swing.table.AbstractTableModel;
42import javax.swing.table.DefaultTableCellRenderer;
43import javax.swing.table.TableCellRenderer;
44import javax.swing.table.TableModel;
45
46import org.openstreetmap.josm.actions.ExpertToggleAction;
47import org.openstreetmap.josm.actions.ExpertToggleAction.ExpertModeChangeListener;
48import org.openstreetmap.josm.actions.MergeLayerAction;
49import org.openstreetmap.josm.data.coor.EastNorth;
50import org.openstreetmap.josm.data.imagery.OffsetBookmark;
51import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeEvent;
52import org.openstreetmap.josm.data.preferences.AbstractProperty.ValueChangeListener;
53import org.openstreetmap.josm.data.preferences.BooleanProperty;
54import org.openstreetmap.josm.gui.MainApplication;
55import org.openstreetmap.josm.gui.MapFrame;
56import org.openstreetmap.josm.gui.MapView;
57import org.openstreetmap.josm.gui.SideButton;
58import org.openstreetmap.josm.gui.dialogs.layer.ActivateLayerAction;
59import org.openstreetmap.josm.gui.dialogs.layer.CycleLayerDownAction;
60import org.openstreetmap.josm.gui.dialogs.layer.CycleLayerUpAction;
61import org.openstreetmap.josm.gui.dialogs.layer.DeleteLayerAction;
62import org.openstreetmap.josm.gui.dialogs.layer.DuplicateAction;
63import org.openstreetmap.josm.gui.dialogs.layer.LayerListTransferHandler;
64import org.openstreetmap.josm.gui.dialogs.layer.LayerVisibilityAction;
65import org.openstreetmap.josm.gui.dialogs.layer.MergeAction;
66import org.openstreetmap.josm.gui.dialogs.layer.MoveDownAction;
67import org.openstreetmap.josm.gui.dialogs.layer.MoveUpAction;
68import org.openstreetmap.josm.gui.dialogs.layer.ShowHideLayerAction;
69import org.openstreetmap.josm.gui.layer.AbstractTileSourceLayer;
70import org.openstreetmap.josm.gui.layer.JumpToMarkerActions;
71import org.openstreetmap.josm.gui.layer.Layer;
72import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
73import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
74import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
75import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
76import org.openstreetmap.josm.gui.layer.MainLayerManager;
77import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
78import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
79import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
80import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings;
81import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeEvent;
82import org.openstreetmap.josm.gui.layer.imagery.TileSourceDisplaySettings.DisplaySettingsChangeListener;
83import org.openstreetmap.josm.gui.util.MultikeyActionsHandler;
84import org.openstreetmap.josm.gui.util.MultikeyShortcutAction.MultikeyInfo;
85import org.openstreetmap.josm.gui.util.ReorderableTableModel;
86import org.openstreetmap.josm.gui.util.TableHelper;
87import org.openstreetmap.josm.gui.widgets.DisableShortcutsOnFocusGainedTextField;
88import org.openstreetmap.josm.gui.widgets.JosmTextField;
89import org.openstreetmap.josm.gui.widgets.PopupMenuLauncher;
90import org.openstreetmap.josm.gui.widgets.ScrollableTable;
91import org.openstreetmap.josm.spi.preferences.Config;
92import org.openstreetmap.josm.tools.ImageProvider;
93import org.openstreetmap.josm.tools.ImageProvider.ImageSizes;
94import org.openstreetmap.josm.tools.InputMapUtils;
95import org.openstreetmap.josm.tools.PlatformManager;
96import org.openstreetmap.josm.tools.Shortcut;
97
98/**
99 * 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}
Note: See TracBrowser for help on using the repository browser.