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

Last change on this file since 15632 was 15632, checked in by Don-vip, 4 years ago

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