Ticket #12409: RecentRelationsAction.patch

src/org/openstreetmap/josm/actions/CreateMultipolygonAction.java

@@ -120 +120 @@
 
                                 editor.setModal(true);
                                 editor.setVisible(true);
+                            } else {
+                                Main.main.getEditLayer().setRecentRelation(relation);
                             }
                         }
                     });

new file src/org/openstreetmap/josm/actions/relation/RecentRelationsAction.java

@@ +1 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.actions.relation;
+
+import static org.openstreetmap.josm.tools.I18n.tr;
+import static org.openstreetmap.josm.tools.I18n.trn;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
+import java.awt.Rectangle;
+import java.util.Collection;
+import java.util.List;
+
+import javax.swing.AbstractAction;
+import javax.swing.JMenuItem;
+import javax.swing.JPopupMenu;
+import javax.swing.KeyStroke;
+import javax.swing.plaf.basic.BasicArrowButton;
+
+import org.openstreetmap.josm.Main;
+import org.openstreetmap.josm.data.osm.Relation;
+import org.openstreetmap.josm.gui.layer.Layer;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer;
+import org.openstreetmap.josm.gui.layer.OsmDataLayer.CommandQueueListener;
+import org.openstreetmap.josm.gui.DefaultNameFormatter;
+import org.openstreetmap.josm.gui.MapView;
+import org.openstreetmap.josm.gui.MapView.LayerChangeListener;
+import org.openstreetmap.josm.gui.SideButton;
+import org.openstreetmap.josm.tools.Shortcut;
+
+/**
+ * Action for accessing recent relations.
+ */
+public class RecentRelationsAction implements ActionListener, CommandQueueListener, LayerChangeListener{
+
+    private SideButton editButton;
+    private BasicArrowButton arrow;
+    private Shortcut shortcut;
+
+    /**
+     * Constructs a new <code>RecentRelationsAction</code>.
+     */
+    public RecentRelationsAction(SideButton editButton) {
+        this.editButton = editButton;
+        arrow = editButton.createArrow(this);
+        arrow.setToolTipText(tr("List of recent relations"));
+        Main.main.undoRedo.addCommandQueueListener(this);
+        MapView.addLayerChangeListener(this);
+        enableArrow();
+        shortcut = Shortcut.registerShortcut(
+            "relationeditor:editrecentrelation",
+            tr("Relation Editor: {0}", tr("Open recent relation")),
+            KeyEvent.VK_ESCAPE,
+            Shortcut.SHIFT
+        );
+        Main.registerActionShortcut(new AbstractAction() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                EditRelationAction.launchEditor(getLastRelation());
+            }
+        }, shortcut);
+    }
+
+    public void enableArrow() {
+        arrow.setEnabled(getLastRelation() != null);
+    }
+
+    public static Relation getLastRelation() {
+        List<Relation> recentRelations = getRecentRelationsOnActiveLayer();
+        if (recentRelations == null || recentRelations.isEmpty()) return null;
+        for (Relation relation: recentRelations) {
+            if (!isRelationListable(relation)) continue;
+            return relation;
+        }
+        return null;
+    }
+
+    public static boolean isRelationListable(Relation relation) {
+        return relation != null &&
+            !relation.isDeleted() &&
+            Main.main.getCurrentDataSet().containsRelation(relation);
+    }
+
+    @Override
+    public void actionPerformed(ActionEvent e) {
+        RecentRelationsPopupMenu.launch(editButton, shortcut.getKeyStroke());
+    }
+
+    @Override
+    public void commandChanged(int queueSize, int redoSize) {
+        enableArrow();
+    }
+
+    @Override
+    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
+        enableArrow();
+    }
+
+    @Override
+    public void layerAdded(Layer newLayer) {
+        enableArrow();
+    }
+
+    @Override
+    public void layerRemoved(Layer oldLayer) {
+        enableArrow();
+    }
+
+    public static List<Relation> getRecentRelationsOnActiveLayer() {
+        if (Main.map == null || Main.map.mapView == null) return null;
+        Layer activeLayer = Main.map.mapView.getActiveLayer();
+        if (!(activeLayer instanceof OsmDataLayer)) {
+            return null;
+        } else {
+            return ((OsmDataLayer) activeLayer).getRecentRelations();
+        }
+    }
+
+    protected static class RecentRelationsPopupMenu extends JPopupMenu {
+        public static void launch(Component parent, KeyStroke keystroke) {
+            List<Relation> recentRelations = getRecentRelationsOnActiveLayer();
+            JPopupMenu menu = new RecentRelationsPopupMenu(recentRelations, keystroke);
+            Rectangle r = parent.getBounds();
+            menu.show(parent, r.x, r.y + r.height);
+        }
+
+        /**
+         * Constructs a new {@code SearchPopupMenu}.
+         */
+        public RecentRelationsPopupMenu(List<Relation> recentRelations, KeyStroke keystroke) {
+            boolean first = true;
+            for (Relation relation: recentRelations) {
+                if (!isRelationListable(relation)) continue;
+                JMenuItem menuItem = new RecentRelationsMenuItem(relation);
+                if (first) {
+                    menuItem.setAccelerator(keystroke);
+                    first = false;
+                }
+                add(menuItem);
+            }
+        }
+    }
+
+    /**
+     * A specialized {@link JMenuItem} for presenting one entry of the relation history
+     */
+    protected static class RecentRelationsMenuItem extends JMenuItem implements ActionListener {
+        protected final transient Relation relation;
+
+        public RecentRelationsMenuItem(Relation relation) {
+            super(relation.getDisplayName(DefaultNameFormatter.getInstance()));
+            this.relation = relation;
+            addActionListener(this);
+        }
+
+        @Override
+        public void actionPerformed(ActionEvent e) {
+            EditRelationAction.launchEditor(relation);
+        }
+    }
+}

src/org/openstreetmap/josm/gui/SideButton.java

@@ -89 +89 @@
         setMargin(new Insets(0, 0, 0, 0));
     }
 
-    public void createArrow(ActionListener listener) {
+    public BasicArrowButton createArrow(ActionListener listener) {
         setMargin(new Insets(0, 0, 0, 0));
         BasicArrowButton arrowButton = new BasicArrowButton(SwingConstants.SOUTH, null, null, Color.BLACK, null);
         arrowButton.setBorder(BorderFactory.createEmptyBorder());
         add(arrowButton, BorderLayout.EAST);
         arrowButton.addActionListener(listener);
+        return arrowButton;
     }
 
     @Override

src/org/openstreetmap/josm/gui/dialogs/RelationListDialog.java

@@ -41 +41 @@
 import org.openstreetmap.josm.actions.relation.DownloadSelectedIncompleteMembersAction;
 import org.openstreetmap.josm.actions.relation.DuplicateRelationAction;
 import org.openstreetmap.josm.actions.relation.EditRelationAction;
+import org.openstreetmap.josm.actions.relation.RecentRelationsAction;
 import org.openstreetmap.josm.actions.relation.SelectMembersAction;
 import org.openstreetmap.josm.actions.relation.SelectRelationAction;
 import org.openstreetmap.josm.actions.search.SearchCompiler;
@@ -122 +123 @@
 
     private final transient HighlightHelper highlightHelper = new HighlightHelper();
     private final boolean highlightEnabled = Main.pref.getBoolean("draw.target-highlight", true);
+    private RecentRelationsAction recentRelationsAction;
 
     /**
      * Constructs <code>RelationListDialog</code>
@@ -168 +170 @@
         JPanel pane = new JPanel(new BorderLayout());
         pane.add(filter, BorderLayout.NORTH);
         pane.add(new JScrollPane(displaylist), BorderLayout.CENTER);
+
+        SideButton editButton = new SideButton(editAction, false);
+        recentRelationsAction = new RecentRelationsAction(editButton);
+
         createLayout(pane, false, Arrays.asList(new SideButton[]{
                 new SideButton(newAction, false),
-                new SideButton(editAction, false),
+                editButton,
                 new SideButton(duplicateAction, false),
                 new SideButton(deleteRelationsAction, false),
                 new SideButton(selectRelationAction, false)
@@ -192 +198 @@
         updateActionsRelationLists();
     }
 
+    public void enableRecentRelations() {
+        recentRelationsAction.enableArrow();
+    }
+
     // inform all actions about list of relations they need
     private void updateActionsRelationLists() {
         List<Relation> sel = model.getSelectedRelations();

src/org/openstreetmap/josm/gui/dialogs/relation/RelationEditor.java

@@ -66 +66 @@
         CheckParameterUtil.ensureParameterNotNull(layer, "layer");
         this.layer = layer;
         setRelation(relation);
+        layer.removeRecentRelation(relation);
     }
 
     /**
@@ -189 +190 @@
     public final void removePropertyChangeListener(PropertyChangeListener listener) {
         this.support.removePropertyChangeListener(listener);
     }
+
+    @Override
+    public void dispose() {
+        layer.setRecentRelation(relation);
+        super.dispose();
+    }
 }

src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

@@ -24 +24 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -74 +76 @@
 import org.openstreetmap.josm.data.osm.visitor.paint.MapRendererFactory;
 import org.openstreetmap.josm.data.osm.visitor.paint.Rendering;
 import org.openstreetmap.josm.data.osm.visitor.paint.relations.MultipolygonCache;
+import org.openstreetmap.josm.data.preferences.IntegerProperty;
 import org.openstreetmap.josm.data.projection.Projection;
 import org.openstreetmap.josm.data.validation.TestError;
 import org.openstreetmap.josm.gui.ExtendedDialog;
@@ -121 +124 @@
      */
     public final List<TestError> validationErrors = new ArrayList<>();
 
+    public static final int DEFAULT_RECENT_RELATIONS_NUMBER = 20;
+    public static final IntegerProperty PROPERTY_RECENT_RELATIONS_NUMBER = new IntegerProperty("properties.last-closed-relations-size",
+            DEFAULT_RECENT_RELATIONS_NUMBER);
+
+    /** List of recent relations */
+    private final Map<Relation, Void> recentRelations = new LinkedHashMap<Relation, Void>(PROPERTY_RECENT_RELATIONS_NUMBER.get()+1, 1.1f, true) {
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<Relation, Void> eldest) {
+            return size() > PROPERTY_RECENT_RELATIONS_NUMBER.get();
+        }
+    };
+
+    /**
+     * Returns list of recently closed relations or null if none.
+     */
+    public ArrayList<Relation> getRecentRelations() {
+        ArrayList<Relation> list = new ArrayList<Relation>(recentRelations.keySet());
+        Collections.reverse(list);
+        return list;
+    }
+
+    public void setRecentRelation(Relation relation) {
+        recentRelations.put(relation, null);
+        Main.map.relationListDialog.enableRecentRelations();
+    }
+
+    public void removeRecentRelation(Relation relation) {
+        recentRelations.remove(relation);
+        Main.map.relationListDialog.enableRecentRelations();
+    }
+
     protected void setRequiresSaveToFile(boolean newValue) {
         boolean oldValue = requiresSaveToFile;
         requiresSaveToFile = newValue;