Changeset 10288 in josm for trunk/src/org/openstreetmap/josm


Ignore:
Timestamp:
2016-05-27T19:19:13+02:00 (8 years ago)
Author:
Don-vip
Message:

fix #12882 - Use LayerManager for LayerListDialog (patch by michael2402)

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

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/Main.java

    r10279 r10288  
    144144     * Replies true if JOSM currently displays a map view. False, if it doesn't, i.e. if
    145145     * it only shows the MOTD panel.
     146     * <p>
     147     * You do not need this when accessing the layer manager. The layer manager will be empty if no map view is shown.
    146148     *
    147149     * @return <code>true</code> if JOSM currently displays a map view

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

    r10250 r10288  
    6060import org.openstreetmap.josm.gui.layer.JumpToMarkerActions;
    6161import org.openstreetmap.josm.gui.layer.Layer;
     62import org.openstreetmap.josm.gui.layer.LayerManager.LayerAddEvent;
     63import org.openstreetmap.josm.gui.layer.LayerManager.LayerChangeListener;
     64import org.openstreetmap.josm.gui.layer.LayerManager.LayerOrderChangeEvent;
     65import org.openstreetmap.josm.gui.layer.LayerManager.LayerRemoveEvent;
     66import org.openstreetmap.josm.gui.layer.MainLayerManager;
     67import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeEvent;
     68import org.openstreetmap.josm.gui.layer.MainLayerManager.ActiveLayerChangeListener;
    6269import org.openstreetmap.josm.gui.layer.NativeScaleLayer;
    6370import org.openstreetmap.josm.gui.util.GuiHelper;
    … …  
    7582 * change the ordering of the layers, to hide/show layers, to activate layers,
    7683 * and to delete layers.
     84 * <p>
     85 * Support for multiple {@link LayerListDialog} is currently not complete but intended for the future.
    7786 * @since 17
    7887 */
    … …  
    134143    private final transient Shortcut[] visibilityToggleShortcuts = new Shortcut[10];
    135144    private final ToggleLayerIndexVisibility[] visibilityToggleActions = new ToggleLayerIndexVisibility[10];
     145
     146    /**
     147     * The {@link MainLayerManager} this list is for.
     148     */
     149    private final transient MainLayerManager layerManager;
    136150
    137151    /**
    … …  
    155169     */
    156170    protected LayerListDialog(MapFrame mapFrame) {
     171        this(mapFrame.mapView.getLayerManager());
     172    }
     173
     174    /**
     175     * Creates a layer list and attach it to the given mapView.
     176     * @param layerManager The layer manager this list is for
     177     */
     178    private LayerListDialog(MainLayerManager layerManager) {
    157179        super(tr("Layers"), "layerlist", tr("Open a list of all loaded layers."),
    158180                Shortcut.registerShortcut("subwindow:layers", tr("Toggle: {0}", tr("Layers")), KeyEvent.VK_L,
    159181                        Shortcut.ALT_SHIFT), 100, true);
     182        this.layerManager = layerManager;
    160183
    161184        // create the models
    … …  
    167190        // create the list control
    168191        //
    169         layerList = new LayerList(model);
     192        layerList = new LayerList(model, layerManager);
    170193        layerList.setSelectionModel(selectionModel);
    171194        layerList.addMouseListener(new PopupMenuHandler());
    … …  
    219242        // init the model
    220243        //
    221         final MapView mapView = mapFrame.mapView;
    222244        model.populate();
    223         model.setSelectedLayer(mapView.getActiveLayer());
     245        model.setSelectedLayer(layerManager.getActiveLayer());
    224246        model.addLayerListModelListener(
    225247                new LayerListModelListener() {
    … …  
    297319    }
    298320
     321    /**
     322     * Gets the layer manager this dialog is for.
     323     * @return The layer manager.
     324     * @since 10288
     325     */
     326    public MainLayerManager getLayerManager() {
     327        return layerManager;
     328    }
     329
    299330    @Override
    300331    public void showNotify() {
    301332        MapView.addLayerChangeListener(activateLayerAction);
    302         MapView.addLayerChangeListener(model);
     333        layerManager.addLayerChangeListener(model);
     334        layerManager.addActiveLayerChangeListener(model, true);
    303335        model.populate();
    304336    }
    … …  
    306338    @Override
    307339    public void hideNotify() {
    308         MapView.removeLayerChangeListener(model);
     340        layerManager.removeLayerChangeListener(model);
     341        layerManager.removeActiveLayerChangeListener(model);
    309342        MapView.removeLayerChangeListener(activateLayerAction);
    310343    }
    … …  
    513546
    514547        protected boolean isActiveLayer(Layer layer) {
    515             if (!Main.isDisplayingMapView())
    516                 return false;
    517             return Main.map.mapView.getActiveLayer() == layer;
     548            return getLayerManager().getActiveLayer() == layer;
    518549        }
    519550
    … …  
    612643     * the properties {@link Layer#VISIBLE_PROP} and {@link Layer#NAME_PROP}.
    613644     */
    614     public static final class LayerListModel extends AbstractTableModel implements MapView.LayerChangeListener, PropertyChangeListener {
     645    public static final class LayerListModel extends AbstractTableModel
     646            implements LayerChangeListener, ActiveLayerChangeListener, PropertyChangeListener {
    615647        /** manages list selection state*/
    616648        private final DefaultListSelectionModel selectionModel;
    … …  
    628660        }
    629661
    630         void setlayerList(LayerList layerList) {
     662        void setLayerList(LayerList layerList) {
    631663            this.layerList = layerList;
     664        }
     665
     666        private MainLayerManager getLayerManager() {
     667            // layerList should never be null. But if it is, we should not crash.
     668            if (layerList == null) {
     669                return new MainLayerManager();
     670            } else {
     671                return layerList.getLayerManager();
     672            }
    632673        }
    633674
    … …  
    744785            final int size = getRowCount();
    745786            final List<Integer> rows = getSelectedRows();
    746             GuiHelper.runInEDTAndWait(new Runnable() {
    747                 @Override
    748                 public void run() {
    749                     if (rows.isEmpty() && size > 0) {
    750                         selectionModel.setSelectionInterval(size-1, size-1);
    751                     }
    752                     fireTableDataChanged();
    753                     fireRefresh();
    754                     ensureActiveSelected();
    755                 }
    756             });
     787
     788            if (rows.isEmpty() && size > 0) {
     789                selectionModel.setSelectionInterval(size-1, size-1);
     790            }
     791            fireTableDataChanged();
     792            fireRefresh();
     793            ensureActiveSelected();
    757794        }
    758795
    … …  
    888925        public List<Layer> getPossibleMergeTargets(Layer source) {
    889926            List<Layer> targets = new ArrayList<>();
    890             if (source == null || !Main.isDisplayingMapView()) {
     927            if (source == null) {
    891928                return targets;
    892929            }
    893             for (Layer target : Main.map.mapView.getAllLayersAsList()) {
     930            for (Layer target : getLayers()) {
    894931                if (source == target) {
    895932                    continue;
    … …  
    910947         */
    911948        public List<Layer> getLayers() {
    912             if (!Main.isDisplayingMapView())
    913                 return Collections.<Layer>emptyList();
    914             return Main.map.mapView.getAllLayersAsList();
     949            return getLayerManager().getLayers();
    915950        }
    916951
    … …  
    942977         */
    943978        protected Layer getActiveLayer() {
    944             return Main.isDisplayingMapView() ? Main.map.mapView.getActiveLayer() : null;
    945         }
    946 
    947         /**
    948          * Replies the scale layer. null, if no active layer is available
     979            return getLayerManager().getActiveLayer();
     980        }
     981
     982        /**
     983         * Replies the scale layer. null, if no active layer is available.
    949984         *
    950985         * @return the scale layer. null, if no active layer is available
    951          */
     986         * @deprecated Deprecated since it is unused in JOSM and does not really belong here. Can be removed soon (August 2016).
     987         *             You can directly query MapView.
     988         */
     989        @Deprecated
    952990        protected NativeScaleLayer getNativeScaleLayer() {
    953991            return Main.isDisplayingMapView() ? Main.map.mapView.getNativeScaleLayer() : null;
    … …  
    9981036                switch (col) {
    9991037                case 0:
    1000                     Main.map.mapView.setActiveLayer(l);
     1038                    getLayerManager().setActiveLayer(l);
    10011039                    l.setVisible(true);
    10021040                    break;
    … …  
    10281066
    10291067        /* ------------------------------------------------------------------------------ */
     1068        /* Interface ActiveLayerChangeListener                                            */
     1069        /* ------------------------------------------------------------------------------ */
     1070        @Override
     1071        public void activeOrEditLayerChanged(ActiveLayerChangeEvent e) {
     1072            Layer oldLayer = e.getPreviousActiveLayer();
     1073            if (oldLayer != null) {
     1074                int idx = getLayers().indexOf(oldLayer);
     1075                if (idx >= 0) {
     1076                    fireTableRowsUpdated(idx, idx);
     1077                }
     1078            }
     1079
     1080            Layer newLayer = getActiveLayer();
     1081            if (newLayer != null) {
     1082                int idx = getLayers().indexOf(newLayer);
     1083                if (idx >= 0) {
     1084                    fireTableRowsUpdated(idx, idx);
     1085                }
     1086            }
     1087            ensureActiveSelected();
     1088        }
     1089
     1090        /* ------------------------------------------------------------------------------ */
    10301091        /* Interface LayerChangeListener                                                  */
    10311092        /* ------------------------------------------------------------------------------ */
    10321093        @Override
    1033         public void activeLayerChange(final Layer oldLayer, final Layer newLayer) {
    1034             GuiHelper.runInEDTAndWait(new Runnable() {
    1035                 @Override
    1036                 public void run() {
    1037                     if (oldLayer != null) {
    1038                         int idx = getLayers().indexOf(oldLayer);
    1039                         if (idx >= 0) {
    1040                             fireTableRowsUpdated(idx, idx);
    1041                         }
    1042                     }
    1043 
    1044                     if (newLayer != null) {
    1045                         int idx = getLayers().indexOf(newLayer);
    1046                         if (idx >= 0) {
    1047                             fireTableRowsUpdated(idx, idx);
    1048                         }
    1049                     }
    1050                     ensureActiveSelected();
    1051                 }
    1052             });
    1053         }
    1054 
    1055         @Override
    1056         public void layerAdded(Layer newLayer) {
    1057             onAddLayer(newLayer);
    1058         }
    1059 
    1060         @Override
    1061         public void layerRemoved(final Layer oldLayer) {
    1062             onRemoveLayer(oldLayer);
     1094        public void layerAdded(LayerAddEvent e) {
     1095            onAddLayer(e.getAddedLayer());
     1096        }
     1097
     1098        @Override
     1099        public void layerRemoving(LayerRemoveEvent e) {
     1100            onRemoveLayer(e.getRemovedLayer());
     1101        }
     1102
     1103        @Override
     1104        public void layerOrderChanged(LayerOrderChangeEvent e) {
     1105            // ignored for now, since only we change layer order.
    10631106        }
    10641107
    … …  
    10781121    }
    10791122
     1123    /**
     1124     * This component displays a list of layers and provides the methods needed by {@link LayerListModel}.
     1125     */
    10801126    static class LayerList extends JTable {
    1081         LayerList(LayerListModel dataModel) {
     1127        private final transient MainLayerManager layerManager;
     1128
     1129        LayerList(LayerListModel dataModel, MainLayerManager layerManager) {
    10821130            super(dataModel);
    1083             dataModel.setlayerList(this);
     1131            this.layerManager = layerManager;
     1132            dataModel.setLayerList(this);
    10841133        }
    10851134
    … …  
    10931142            viewport.scrollRectToVisible(rect);
    10941143        }
     1144
     1145        /**
     1146         * Gets you the layer manager used for this list.
     1147         * @return The layer manager.
     1148         * @since 10288
     1149         */
     1150        public MainLayerManager getLayerManager() {
     1151            return layerManager;
     1152        }
    10951153    }
    10961154
    … …  
    11491207     */
    11501208    public static Layer getLayerForIndex(int index) {
    1151         if (!Main.isDisplayingMapView())
    1152             return null;
    1153 
    1154         List<Layer> layers = Main.map.mapView.getAllLayersAsList();
     1209        List<Layer> layers = Main.getLayerManager().getLayers();
    11551210
    11561211        if (index < layers.size() && index >= 0)
    … …  
    11691224        List<MultikeyInfo> result = new ArrayList<>();
    11701225
    1171         if (!Main.isDisplayingMapView())
    1172             return result;
    1173 
    1174         List<Layer> layers = Main.map.mapView.getAllLayersAsList();
     1226        List<Layer> layers = Main.getLayerManager().getLayers();
    11751227
    11761228        int index = 0;
    … …  
    11861238
    11871239    /**
    1188      * Determines if a layer is valid (contained in layer list).
     1240     * Determines if a layer is valid (contained in global layer list).
    11891241     * @param l the layer
    11901242     * @return {@code true} if layer {@code l} is contained in current layer list
    11911243     */
    11921244    public static boolean isLayerValid(Layer l) {
    1193         if (l == null || !Main.isDisplayingMapView())
     1245        if (l == null)
    11941246            return false;
    11951247
    1196         return Main.map.mapView.getAllLayersAsList().contains(l);
     1248        return Main.getLayerManager().containsLayer(l);
    11971249    }
    11981250
    … …  
    12031255     */
    12041256    public static MultikeyInfo getLayerInfo(Layer l) {
    1205         if (l == null || !Main.isDisplayingMapView())
     1257        if (l == null)
    12061258            return null;
    12071259
    1208         int index = Main.map.mapView.getAllLayersAsList().indexOf(l);
     1260        int index = Main.getLayerManager().getLayers().indexOf(l);
    12091261        if (index < 0)
    12101262            return null;
Note: See TracChangeset for help on using the changeset viewer.