Changeset 1709 in josm for trunk/src/org

Timestamp:

2009-06-28T11:37:21+02:00 (15 years ago)

Author:

Gubaer

Message:

new: history feature implemented

Location:

trunk/src/org/openstreetmap/josm

Files:

• data/osm/history/HistoryDataSet.java (modified) (2 diffs)
• data/osm/history/HistoryOsmPrimitive.java (modified) (2 diffs)
• gui/dialogs/HistoryDialog.java (modified) (5 diffs)
• gui/history (added)
• gui/history/AdjustmentSynchronizer.java (added)
• gui/history/HistoryBrowser.java (added)
• gui/history/HistoryBrowserDialog.java (added)
• gui/history/HistoryBrowserModel.java (added)
• gui/history/NodeListTableCellRenderer.java (added)
• gui/history/NodeListTableColumnModel.java (added)
• gui/history/NodeListViewer.java (added)
• gui/history/PointInTimeType.java (added)
• gui/history/RelationMemberListTableCellRenderer.java (added)
• gui/history/RelationMemberListViewer.java (added)
• gui/history/RelationMemberTableColumnModel.java (added)
• gui/history/SelectionSynchronizer.java (added)
• gui/history/TagInfoViewer.java (added)
• gui/history/TagTableCellRenderer.java (added)
• gui/history/TagTableColumnModel.java (added)
• gui/history/VersionInfoPanel.java (added)
• gui/history/VersionTable.java (added)
• gui/history/VersionTableCellRenderer.java (added)
• gui/history/VersionTableColumnModel.java (added)

trunk/src/org/openstreetmap/josm/data/osm/history/HistoryDataSet.java

@@ -9 +9 @@
 
 public class HistoryDataSet {
+
+    private static HistoryDataSet historyDataSet;
+
+    public static HistoryDataSet getInstance() {
+        if (historyDataSet == null) {
+            historyDataSet = new HistoryDataSet();
+        }
+        return  historyDataSet;
+    }
 
     private HashMap<Long, ArrayList<HistoryOsmPrimitive>> data;
@@ -44 +53 @@
         ArrayList<HistoryOsmPrimitive> versions = data.get(id);
         if (versions == null)
-            throw new NoSuchElementException(tr("Didn't find an historized primitive with id {0} in this dataset", id));
+            return null;
         return new History(id, versions);
     }
+
+    /**
+     * merges the histories from the {@see HistoryDataSet} other in this history data set
+     * 
+     * @param other the other history data set. Ignored if null.
+     */
+    public void mergeInto(HistoryDataSet other) {
+        if (other == null)
+            return;
+        for (Long id : other.data.keySet()) {
+            if (!this.data.keySet().contains(id)) {
+                this.data.put(id, other.data.get(id));
+            }
+        }
+    }
 }

trunk/src/org/openstreetmap/josm/data/osm/history/HistoryOsmPrimitive.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.osm.history;
 
+import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.Map;
 
 import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
@@ -116 +118 @@
     }
 
+    public Map<String,String> getTags() {
+        return Collections.unmodifiableMap(tags);
+    }
+
     @Override
     public int hashCode() {

trunk/src/org/openstreetmap/josm/gui/dialogs/HistoryDialog.java

@@ -3 +3 @@
 
 import static org.openstreetmap.josm.tools.I18n.tr;
-import static org.openstreetmap.josm.tools.I18n.marktr;
 
 import java.awt.BorderLayout;
+import java.awt.Color;
 import java.awt.Component;
-import java.awt.GridBagLayout;
 import java.awt.GridLayout;
 import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
-import java.util.Calendar;
+import java.awt.event.MouseAdapter;
+import java.awt.event.MouseEvent;
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Date;
 import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.SortedSet;
-import java.util.TreeSet;
-
+import java.util.Iterator;
+
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import javax.swing.ImageIcon;
+import javax.swing.JButton;
 import javax.swing.JComponent;
 import javax.swing.JLabel;
@@ -27 +28 @@
 import javax.swing.JScrollPane;
 import javax.swing.JTable;
+import javax.swing.ListSelectionModel;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
 import javax.swing.table.DefaultTableCellRenderer;
+import javax.swing.table.DefaultTableColumnModel;
 import javax.swing.table.DefaultTableModel;
 import javax.swing.table.TableCellRenderer;
+import javax.swing.table.TableColumn;
 
 import org.openstreetmap.josm.Main;
@@ -35 +42 @@
 import org.openstreetmap.josm.data.osm.DataSet;
 import org.openstreetmap.josm.data.osm.OsmPrimitive;
-import org.openstreetmap.josm.gui.SideButton;
-import org.openstreetmap.josm.tools.DateUtils;
-import org.openstreetmap.josm.tools.GBC;
+import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
+import org.openstreetmap.josm.data.osm.history.History;
+import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
+import org.openstreetmap.josm.gui.PleaseWaitRunnable;
+import org.openstreetmap.josm.gui.history.HistoryBrowserDialog;
+import org.openstreetmap.josm.io.OsmApi;
+import org.openstreetmap.josm.io.OsmServerHistoryReader;
+import org.openstreetmap.josm.io.OsmTransferException;
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.Shortcut;
+import org.xml.sax.SAXException;
 
 /**
@@ -53 +66 @@
  * @author imi
  */
-public class HistoryDialog extends ToggleDialog implements SelectionChangedListener {
-
-    public static final Date unifyDate(Date d) {
-        Calendar c = Calendar.getInstance();
-        c.setTime(d);
-        c.set(Calendar.MINUTE, 0);
-        c.set(Calendar.SECOND, 0);
-        return c.getTime();
-    }
-
-    private static class HistoryItem implements Comparable<HistoryItem> {
-        OsmPrimitive osm;
-        boolean visible;
-
-        public int compareTo(HistoryItem o) {
-            return unifyDate(osm.getTimestamp()).compareTo(unifyDate(o.osm.getTimestamp()));
-        }
-    }
-
-    private final DefaultTableModel data = new DefaultTableModel(){
-        @Override public boolean isCellEditable(int row, int column) {
-            return false;
-        }
-    };
-
-    /**
-     * Main table. 3 columns:
-     * Object | Date | visible (icon, no text)
-     */
-    private JTable history = new JTable(data);
-    private JScrollPane historyPane = new JScrollPane(history);
-
-    private Map<OsmPrimitive, List<HistoryItem>> cache = new HashMap<OsmPrimitive, List<HistoryItem>>();
-    private JLabel notLoaded = new JLabel("<html><i>"+tr("Click Reload to refresh list")+"</i></html>");
-
-    public HistoryDialog() {
-        super(tr("History"), "history", tr("Display the history of all selected items."),
-        Shortcut.registerShortcut("subwindow:history", tr("Toggle: {0}", tr("History")), KeyEvent.VK_H,
-        Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 150);
-        historyPane.setVisible(false);
-        notLoaded.setVisible(true);
-        notLoaded.setHorizontalAlignment(JLabel.CENTER);
-
-        history.setDefaultRenderer(Object.class, new DefaultTableCellRenderer(){
-            @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
-                return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
-            }
-        });
-        data.setColumnIdentifiers(new Object[]{tr("Object"),tr("Date"),""});
-        history.getColumnModel().getColumn(0).setPreferredWidth(200);
-        history.getColumnModel().getColumn(1).setPreferredWidth(200);
-        history.getColumnModel().getColumn(2).setPreferredWidth(20);
-        final TableCellRenderer oldRenderer = history.getTableHeader().getDefaultRenderer();
-        history.getTableHeader().setDefaultRenderer(new DefaultTableCellRenderer(){
+public class HistoryDialog extends ToggleDialog {
+
+    /** the registry of history browser dialogs which are currently displaying */
+    static private HashMap<Long, HistoryBrowserDialog> historyBrowserDialogs;
+
+    /**
+     * registers a {@see HistoryBrowserDialog}
+     * @param id the id of the primitive dialog shows the history for
+     * @param dialog the dialog
+     */
+    public static void registerHistoryBrowserDialog(long id, HistoryBrowserDialog dialog) {
+        if (historyBrowserDialogs == null) {
+            historyBrowserDialogs = new HashMap<Long, HistoryBrowserDialog>();
+        }
+        historyBrowserDialogs.put(id, dialog);
+    }
+
+    /**
+     * unregisters a {@see HistoryBrowserDialog}
+     * @param id the id of the primitive whose history dialog is to be unregistered
+     * 
+     */
+    public static void unregisterHistoryBrowserDialog(long id) {
+        if (historyBrowserDialogs == null)
+            return;
+        historyBrowserDialogs.remove(id);
+    }
+
+    /**
+     * replies the history dialog for the primitive with id <code>id</code>; null, if
+     * no such {@see HistoryBrowserDialog} is currently showing
+     * 
+     * @param id the id of the primitive
+     * @return the dialog; null, if no such dialog is showing
+     */
+    public static HistoryBrowserDialog getHistoryBrowserDialog(long id) {
+        if (historyBrowserDialogs == null)
+            return null;
+        return historyBrowserDialogs.get(id);
+    }
+
+
+    /** the table model */
+    protected HistoryItemDataModel model;
+    /** the table with the history items */
+    protected JTable historyTable;
+
+    protected ShowHistoryAction showHistoryAction;
+    protected ReloadAction reloadAction;
+
+    /**
+     * builds the row with the command buttons
+     * 
+     * @return the rows with the command buttons
+     */
+    protected JPanel buildButtonRow() {
+        JPanel buttons = new JPanel(new GridLayout(1,2));
+
+        JButton btn = new JButton(reloadAction = new ReloadAction());
+        btn.setName("btn.reload");
+        buttons.add(btn);
+
+        btn = new JButton(showHistoryAction = new ShowHistoryAction());
+        btn.setName("btn.showhistory");
+        buttons.add(btn);
+
+        return buttons;
+    }
+
+    /**
+     * builds the GUI
+     */
+    protected void build() {
+        model = new HistoryItemDataModel();
+        //setLayout(new BorderLayout());
+        historyTable = new JTable(
+                model,
+                new HistoryTableColumnModel()
+        );
+        historyTable.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+        historyTable.setName("table.historyitems");
+        final TableCellRenderer oldRenderer = historyTable.getTableHeader().getDefaultRenderer();
+        historyTable.getTableHeader().setDefaultRenderer(new DefaultTableCellRenderer(){
             @Override public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
                 JComponent c = (JComponent)oldRenderer.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
@@ -120 +162 @@
             }
         });
-
-        JPanel centerPanel = new JPanel(new GridBagLayout());
-        centerPanel.add(notLoaded, GBC.eol().fill(GBC.BOTH));
-        centerPanel.add(historyPane, GBC.eol().fill(GBC.BOTH));
-        add(centerPanel, BorderLayout.CENTER);
-
-        JPanel buttons = new JPanel(new GridLayout(1,2));
-        buttons.add(new SideButton(marktr("Reload"), "refresh", "History", tr("Reload all currently selected objects and refresh the list."),
-        new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                reload();
+        historyTable.addMouseListener(
+                new MouseAdapter() {
+                    @Override
+                    public void mouseClicked(MouseEvent e) {
+                        if (e.getClickCount() == 2) {
+                            int row = historyTable.rowAtPoint(e.getPoint());
+                            History h = model.get(row);
+                            showHistory(h);
+                        }
+                    }
+                }
+        );
+
+        JScrollPane pane = new JScrollPane(historyTable);
+        pane.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
+        pane.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
+        historyTable.setTableHeader(null);
+        pane.setColumnHeaderView(null);
+        add(pane, BorderLayout.CENTER);
+
+        add(buildButtonRow(), BorderLayout.SOUTH);
+
+        // wire actions
+        //
+        historyTable.getSelectionModel().addListSelectionListener(showHistoryAction);
+        DataSet.selListeners.add(reloadAction);
+    }
+
+    public HistoryDialog() {
+        super(tr("History"), "history", tr("Display the history of all selected items."),
+                Shortcut.registerShortcut("subwindow:history", tr("Toggle: {0}", tr("History")), KeyEvent.VK_H,
+                        Shortcut.GROUP_LAYER, Shortcut.SHIFT_DEFAULT), 150);
+        build();
+        DataSet.selListeners.add(model);
+    }
+
+    /**
+     * refreshes the current list of history items; reloads history information from the server
+     */
+    protected void refresh() {
+        HistoryLoadTask task = new HistoryLoadTask();
+        Main.worker.execute(task);
+    }
+
+    /**
+     * shows the {@see HistoryBrowserDialog} for a given {@see History}
+     * 
+     * @param h the history. Must not be null.
+     * @exception IllegalArgumentException thrown, if h is null
+     */
+    protected void showHistory(History h) throws IllegalArgumentException {
+        if (h == null)
+            throw new IllegalArgumentException(tr("parameter ''{0}'' must not be null", "h"));
+        HistoryBrowserDialog dialog = getHistoryBrowserDialog(h.getId());
+        if (dialog == null) {
+            dialog = new HistoryBrowserDialog(h);
+        }
+        dialog.setVisible(true);
+    }
+
+    /**
+     * invoked after the asynchronous {@see HistoryLoadTask} is finished.
+     * 
+     * @param task the task which is calling back.
+     */
+    protected void postRefresh(HistoryLoadTask task) {
+        model.refresh();
+        if (task.isCancelled())
+            return;
+        if (task.getLastException() != null) {
+            task.getLastException().printStackTrace();
+            String msg = task.getLastException().getMessage();
+            if (msg == null) {
+                msg = task.getLastException().toString();
             }
-        }));
-        buttons.add(new SideButton(marktr("Revert"), "revert", "History",
-        tr("Revert the state of all currently selected objects to the version selected in the history list."), new ActionListener(){
-            public void actionPerformed(ActionEvent e) {
-                JOptionPane.showMessageDialog(Main.parent, tr("Not implemented yet."));
+            JOptionPane.showMessageDialog(
+                    Main.parent,
+                    tr(
+                            "<html>Failed to load history from the server. Details:<br>{0}</html>",
+                            msg.replaceAll("&", "&amp;").replaceAll(">", "&gt;").replaceAll("<", "&lt;")
+                    ),
+                    tr("Error"),
+                    JOptionPane.ERROR_MESSAGE
+            );
+        }
+    }
+
+    /**
+     * The table model with the history items
+     * 
+     */
+    class HistoryItemDataModel extends DefaultTableModel implements SelectionChangedListener{
+        private ArrayList<History> data;
+
+        public HistoryItemDataModel() {
+            data = new ArrayList<History>();
+        }
+
+        @Override
+        public int getRowCount() {
+            if (data == null)
+                return 0;
+            return data.size();
+        }
+
+        @Override
+        public Object getValueAt(int row, int column) {
+            return data.get(row);
+        }
+
+        @Override
+        public boolean isCellEditable(int row, int column) {
+            return false;
+        }
+
+        public void refresh() {
+            data.clear();
+            for (OsmPrimitive primitive: Main.ds.getSelected()) {
+                if (primitive.id == 0) {
+                    continue;
+                }
+                History h = HistoryDataSet.getInstance().getHistory(primitive.id);
+                if (h !=null) {
+                    data.add(h);
+                }
             }
-        }));
-        add(buttons, BorderLayout.SOUTH);
-
-        DataSet.selListeners.add(this);
-    }
-
-
-    @Override public void setVisible(boolean b) {
-        super.setVisible(b);
-        if (b)
-            update();
-    }
-
-
-    public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
-        if (isVisible())
-            update();
-    }
-
-    /**
-     * Identify all new objects in the selection and if any, hide the list.
-     * Else, update the list with the selected items shown.
-     */
-    private void update() {
-        Collection<OsmPrimitive> sel = Main.ds.getSelected();
-        if (!cache.keySet().containsAll(sel)) {
-            historyPane.setVisible(false);
-            notLoaded.setVisible(true);
-        } else {
-            SortedSet<HistoryItem> orderedHistory = new TreeSet<HistoryItem>();
-            for (OsmPrimitive osm : sel)
-                orderedHistory.addAll(cache.get(osm));
-            data.setRowCount(0);
-            for (HistoryItem i : orderedHistory)
-                data.addRow(new Object[]{i.osm, DateUtils.fromDate(i.osm.getTimestamp()), i.visible});
-            historyPane.setVisible(true);
-            notLoaded.setVisible(false);
-        }
-    }
-
-    void reload() {
-        JOptionPane.showMessageDialog(Main.parent, tr("Not implemented yet."));
+            fireTableDataChanged();
+        }
+
+        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
+            refresh();
+        }
+
+        public History get(int idx) throws IndexOutOfBoundsException {
+            if (idx < 0 || idx >= data.size())
+                throw new IndexOutOfBoundsException(tr("index out of bounds Got {0}", idx));
+            return data.get(idx);
+        }
+    }
+
+
+    /**
+     * The table cell renderer for the history items.
+     *
+     */
+    class HistoryTableCellRenderer extends JLabel implements TableCellRenderer {
+
+        public final Color BGCOLOR_SELECTED = new Color(143,170,255);
+
+        private HashMap<OsmPrimitiveType, ImageIcon> icons;
+
+        public HistoryTableCellRenderer() {
+            setOpaque(true);
+            icons = new HashMap<OsmPrimitiveType, ImageIcon>();
+            icons.put(OsmPrimitiveType.NODE, ImageProvider.get("data", "node"));
+            icons.put(OsmPrimitiveType.WAY, ImageProvider.get("data", "way"));
+            icons.put(OsmPrimitiveType.RELATION, ImageProvider.get("data", "relation"));
+        }
+
+        protected void renderIcon(History history) {
+            setIcon(icons.get(history.getEarliest().getType()));
+        }
+
+        protected void renderText(History h) {
+            setText(h.getEarliest().getType().getLocalizedDisplayNameSingular() + " " + h.getId());
+        }
+
+        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
+                boolean hasFocus, int row, int column) {
+            History h = (History)value;
+            renderIcon(h);
+            renderText(h);
+            if (isSelected) {
+                setBackground(BGCOLOR_SELECTED);
+            } else {
+                setBackground(Color.WHITE);
+            }
+            return this;
+        }
+    }
+
+    /**
+     * The column model
+     */
+    class HistoryTableColumnModel extends DefaultTableColumnModel {
+        protected void createColumns() {
+            TableColumn col = null;
+            HistoryTableCellRenderer renderer = new HistoryTableCellRenderer();
+            // column 0 - History item
+            col = new TableColumn(0);
+            col.setHeaderValue(tr("History item"));
+            col.setCellRenderer(renderer);
+            addColumn(col);
+        }
+
+        public HistoryTableColumnModel() {
+            createColumns();
+        }
+    }
+
+    /**
+     * The asynchronous task which loads history information for  the currently selected
+     * primitives from the server.
+     *
+     */
+    class HistoryLoadTask extends PleaseWaitRunnable {
+
+        private boolean cancelled = false;
+        private Exception lastException  = null;
+
+        public HistoryLoadTask() {
+            super(tr("Load history"), true);
+        }
+
+        @Override
+        protected void cancel() {
+            OsmApi.getOsmApi().cancel();
+            cancelled = true;
+        }
+
+        @Override
+        protected void finish() {
+            postRefresh(this);
+        }
+
+        /**
+         * update the title of the {@see PleaseWaitDialog} with information about
+         * which primitive is currently loaded
+         * 
+         * @param primitive the primitive to be loaded
+         */
+        protected void notifyStartLoadingHistory(final OsmPrimitive primitive) {
+            SwingUtilities.invokeLater(
+                    new Runnable() {
+                        public void run() {
+                            Main.pleaseWaitDlg.setTitle(
+                                    tr("Loading history for {0} with id {1}",
+                                            OsmPrimitiveType.from(primitive).getLocalizedDisplayNameSingular(),
+                                            Long.toString(primitive.id)
+                                    )
+                            );
+                        }
+                    }
+            );
+        }
+
+        /**
+         * enables/disables interminate progress indication in the {@see PleaseWaitDialog}
+         * 
+         * @param enabled true, if interminate progress indication is to enabled; false, otherwise
+         */
+        protected void setInterminateEnabled(final boolean enabled) {
+            SwingUtilities.invokeLater(
+                    new Runnable() {
+                        public void run() {
+                            Main.pleaseWaitDlg.setIndeterminate(enabled);
+                        }
+                    }
+            );
+        }
+
+        @Override
+        protected void realRun() throws SAXException, IOException, OsmTransferException {
+            Collection<OsmPrimitive> selection = Main.ds.getSelected();
+            Iterator<OsmPrimitive> it = selection.iterator();
+            setInterminateEnabled(true);
+            try {
+                while(it.hasNext()) {
+                    OsmPrimitive primitive = it.next();
+                    if (cancelled) {
+                        break;
+                    }
+                    if (primitive.id == 0) {
+                        continue;
+                    }
+                    notifyStartLoadingHistory(primitive);
+                    OsmServerHistoryReader reader = null;
+                    HistoryDataSet ds = null;
+                    try {
+                        reader = new OsmServerHistoryReader(OsmPrimitiveType.from(primitive), primitive.id);
+                        ds = reader.parseHistory();
+                    } catch(OsmTransferException e) {
+                        if (cancelled)
+                            return;
+                        throw e;
+                    }
+                    HistoryDataSet.getInstance().mergeInto(ds);
+                }
+            } catch(OsmTransferException e) {
+                lastException = e;
+                throw e;
+            } finally {
+                setInterminateEnabled(false);
+            }
+        }
+
+        public boolean isCancelled() {
+            return cancelled;
+        }
+
+        public Exception getLastException() {
+            return lastException;
+        }
+    }
+
+    /**
+     * The action for reloading history information of the currently selected primitives.
+     *
+     */
+    class ReloadAction extends AbstractAction implements SelectionChangedListener {
+        public ReloadAction() {
+            putValue(Action.SMALL_ICON, ImageProvider.get("dialogs","refresh"));
+            putValue(Action.SHORT_DESCRIPTION, tr("Reload all currently selected objects and refresh the list."));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            refresh();
+        }
+
+        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
+            setEnabled(Main.ds.getSelected().size() > 0);
+
+        }
+    }
+
+    /**
+     * The action for showing history information of the current history item.
+     */
+    class ShowHistoryAction extends AbstractAction implements ListSelectionListener {
+        public ShowHistoryAction() {
+            //putValue(Action.SMALL_ICON, ImageProvider.get("dialogs","refresh"));
+            putValue(Action.NAME, tr("Show"));
+            putValue(Action.SHORT_DESCRIPTION, tr("Display the history of the selected primitive"));
+        }
+
+        public void actionPerformed(ActionEvent e) {
+            int row = historyTable.getSelectionModel().getMinSelectionIndex();
+            if (row < 0) return;
+            History h = model.get(row);
+            showHistory(h);
+        }
+
+        public void valueChanged(ListSelectionEvent e) {
+            setEnabled(historyTable.getSelectionModel().getMinSelectionIndex() >= 0);
+        }
     }
 }