Ignore:
Timestamp:
2009-11-14T17:59:10+01:00 (10 years ago)
Author:
Gubaer
Message:

fixed #3352: History doesn't get invalidated on upload?
fixed #3912: Extend history dialog to contain the currently modified version
new: zoom to node in list of nodes in history dialog (popup menu)
new: load history of node from node list in history dialog (popup menu or double click)
fixed: close all history dialogs when the number of layers drop to 0
fixed: implemented equals() and hashCode() on SimplePrimitiveId
fixed: history features now usePrimitiveId instead of long.

Location:
trunk/src/org/openstreetmap/josm/gui/history
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserDialog.java

    r2318 r2448  
    22package org.openstreetmap.josm.gui.history;
    33
     4import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
    45import static org.openstreetmap.josm.tools.I18n.marktr;
    56import static org.openstreetmap.josm.tools.I18n.tr;
     
    1718
    1819import org.openstreetmap.josm.Main;
     20import org.openstreetmap.josm.data.osm.PrimitiveId;
    1921import org.openstreetmap.josm.data.osm.history.History;
    2022import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
     
    2426import org.openstreetmap.josm.gui.help.HelpUtil;
    2527import org.openstreetmap.josm.tools.ImageProvider;
    26 import static org.openstreetmap.josm.gui.help.HelpUtil.ht;
    2728
    2829/**
     
    3536    /** the embedded browser */
    3637    private HistoryBrowser browser;
     38    private CloseAction closeAction;
    3739
    3840    /**
     
    4446        String title = "";
    4547        switch(h.getEarliest().getType()) {
    46             case NODE:  title = marktr("History for node {0}"); break;
    47             case WAY: title = marktr("History for way {0}"); break;
    48             case RELATION:  title = marktr("History for relation {0}"); break;
     48        case NODE:  title = marktr("History for node {0}"); break;
     49        case WAY: title = marktr("History for way {0}"); break;
     50        case RELATION:  title = marktr("History for relation {0}"); break;
    4951        }
    5052        setTitle(tr(
     
    7072        pnl.add(btn);
    7173
    72         btn = new SideButton(new CloseAction());
     74        btn = new SideButton(closeAction = new CloseAction());
    7375        btn.setName("btn.close");
    7476        pnl.add(btn);
     
    106108    }
    107109
    108     public void historyUpdated(HistoryDataSet source, long primitiveId) {
    109         if (primitiveId == browser.getHistory().getId()) {
     110    public void historyUpdated(HistoryDataSet source, PrimitiveId primitiveId) {
     111        if (primitiveId == null) {
     112            browser.populate(source.getHistory(browser.getHistory().getPrimitmiveId()));
     113        } else if (primitiveId.equals(browser.getHistory().getPrimitmiveId())) {
    110114            browser.populate(source.getHistory(primitiveId));
    111         } else if (primitiveId == 0) {
    112             browser.populate(source.getHistory(browser.getHistory().getId()));
    113115        }
     116    }
     117
     118    public void unlinkAsListener() {
     119        getHistoryBrowser().getModel().unlinkAsListener();
    114120    }
    115121
     
    121127        }
    122128
    123         public void actionPerformed(ActionEvent e) {
     129        public void run() {
     130            getHistoryBrowser().getModel().unlinkAsListener();
    124131            HistoryDataSet.getInstance().removeHistoryDataSetListener(HistoryBrowserDialog.this);
    125132            HistoryBrowserDialogManager.getInstance().hide(HistoryBrowserDialog.this);
     133        }
     134
     135        public void actionPerformed(ActionEvent e) {
     136            run();
    126137        }
    127138    }
     
    144155        @Override
    145156        public void windowClosing(WindowEvent e) {
    146             HistoryDataSet.getInstance().removeHistoryDataSetListener(HistoryBrowserDialog.this);
    147             HistoryBrowserDialogManager.getInstance().hide(HistoryBrowserDialog.this);
     157            closeAction.run();
    148158        }
    149159    }
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserDialogManager.java

    r2019 r2448  
    44import java.awt.Dimension;
    55import java.awt.Point;
     6import java.util.ArrayList;
    67import java.util.HashMap;
    78import java.util.Map;
    89
     10import org.openstreetmap.josm.Main;
     11import org.openstreetmap.josm.data.osm.history.History;
     12import org.openstreetmap.josm.gui.layer.Layer;
     13import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    914import org.openstreetmap.josm.tools.WindowGeometry;
    1015
    11 public class HistoryBrowserDialogManager {
     16public class HistoryBrowserDialogManager implements LayerChangeListener {
    1217    static private HistoryBrowserDialogManager instance;
    1318    static public HistoryBrowserDialogManager getInstance() {
     
    2227    protected HistoryBrowserDialogManager() {
    2328        dialogs = new HashMap<Long, HistoryBrowserDialog>();
     29        Layer.listeners.add(this);
    2430    }
    2531
     
    7985        dialog.dispose();
    8086    }
     87
     88    /**
     89     * Hides and destroys all currently visible history browser dialogs
     90     *
     91     */
     92    public void hideAll() {
     93        ArrayList<HistoryBrowserDialog> dialogs = new ArrayList<HistoryBrowserDialog>();
     94        dialogs.addAll(this.dialogs.values());
     95        for (HistoryBrowserDialog dialog: dialogs) {
     96            dialog.unlinkAsListener();
     97            hide(dialog);
     98        }
     99    }
     100
     101    public void show(History h) {
     102        if (h == null)
     103            return;
     104        if (existsDialog(h.getId())) {
     105            show(h.getId());
     106        } else {
     107            HistoryBrowserDialog dialog = new HistoryBrowserDialog(h);
     108            show(h.getId(), dialog);
     109        }
     110    }
     111
     112    /* ----------------------------------------------------------------------------- */
     113    /* LayerChangeListener                                                           */
     114    /* ----------------------------------------------------------------------------- */
     115    public void activeLayerChange(Layer oldLayer, Layer newLayer) {}
     116    public void layerAdded(Layer newLayer) {}
     117
     118    public void layerRemoved(Layer oldLayer) {
     119        // remove all history browsers if the number of layers drops to 0
     120        //
     121        if (Main.map.mapView.getNumLayers() == 0) {
     122            hideAll();
     123        }
     124    }
    81125}
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryBrowserModel.java

    r2243 r2448  
    55
    66import java.util.ArrayList;
     7import java.util.Collection;
    78import java.util.Collections;
    89import java.util.HashSet;
     
    1213import javax.swing.table.DefaultTableModel;
    1314
    14 import org.openstreetmap.josm.data.coor.CoordinateFormat;
    15 import org.openstreetmap.josm.data.coor.LatLon;
     15import org.openstreetmap.josm.Main;
     16import org.openstreetmap.josm.data.osm.DataSetListener;
     17import org.openstreetmap.josm.data.osm.Node;
     18import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1619import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     20import org.openstreetmap.josm.data.osm.PrimitiveId;
     21import org.openstreetmap.josm.data.osm.Relation;
     22import org.openstreetmap.josm.data.osm.RelationMember;
     23import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
     24import org.openstreetmap.josm.data.osm.Way;
    1725import org.openstreetmap.josm.data.osm.history.History;
    1826import org.openstreetmap.josm.data.osm.history.HistoryNode;
     
    2028import org.openstreetmap.josm.data.osm.history.HistoryRelation;
    2129import org.openstreetmap.josm.data.osm.history.HistoryWay;
     30import org.openstreetmap.josm.data.osm.visitor.AbstractVisitor;
     31import org.openstreetmap.josm.gui.layer.DataChangeListener;
     32import org.openstreetmap.josm.gui.layer.Layer;
     33import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     34import org.openstreetmap.josm.gui.layer.Layer.LayerChangeListener;
    2235
    2336/**
    2437 * This is the model used by the history browser.
    2538 *
    26  * The state this model manages consists of the following elements:
     39 * The model state consists of the following elements:
    2740 * <ul>
    2841 *   <li>the {@see History} of a specific {@see OsmPrimitive}</li>
     
    4659 * @see HistoryBrowser
    4760 */
    48 public class HistoryBrowserModel extends Observable {
     61public class HistoryBrowserModel extends Observable implements LayerChangeListener, DataSetListener, DataChangeListener {
    4962
    5063    private static Logger logger = Logger.getLogger(HistoryBrowserModel.class.getName());
     
    5467    private HistoryOsmPrimitive reference;
    5568    private HistoryOsmPrimitive current;
     69    /**
     70     * latest isn't a reference of history. It's a clone of the currently edited
     71     * {@see OsmPrimitive} in the current edit layer.
     72     */
     73    private HistoryOsmPrimitive latest;
    5674
    5775    private VersionTableModel versionTableModel;
     
    6381    private RelationMemberTableModel referenceRelationMemberTableModel;
    6482
     83    /**
     84     * constructor
     85     */
    6586    public HistoryBrowserModel() {
    6687        versionTableModel = new VersionTableModel();
     
    7192        currentRelationMemberTableModel = new RelationMemberTableModel(PointInTimeType.CURRENT_POINT_IN_TIME);
    7293        referenceRelationMemberTableModel = new RelationMemberTableModel(PointInTimeType.REFERENCE_POINT_IN_TIME);
    73     }
    74 
     94
     95        if (getEditLayer() != null) {
     96            getEditLayer().data.addDataSetListener(this);
     97            getEditLayer().listenerDataChanged.add(this);
     98        }
     99        Layer.listeners.add(this);
     100
     101    }
     102
     103    /**
     104     * Creates a new history browser model for a given history.
     105     *
     106     * @param history the history. Must not be null.
     107     * @throws IllegalArgumentException thrown if history is null
     108     */
    75109    public HistoryBrowserModel(History history) {
    76110        this();
     111        if (history == null)
     112            throw new IllegalArgumentException(tr("Parameter ''{0}'' must not be null", "history"));
    77113        setHistory(history);
     114    }
     115
     116    /**
     117     * Replies the current edit layer; null, if there isn't a current edit layer
     118     * of type {@see OsmDataLayer}.
     119     *
     120     * @return the current edit layer
     121     */
     122    protected OsmDataLayer getEditLayer() {
     123        try {
     124            return Main.map.mapView.getEditLayer();
     125        } catch(NullPointerException e) {
     126            return null;
     127        }
    78128    }
    79129
     
    84134    public History getHistory() {
    85135        return history;
     136    }
     137
     138    protected boolean hasNewNodes(Way way) {
     139        for (Node n: way.getNodes()) {
     140            if (n.isNew()) return true;
     141        }
     142        return false;
     143    }
     144    protected boolean canShowAsLatest(OsmPrimitive primitive) {
     145        if (primitive == null) return false;
     146        if (primitive.isNew()) return false;
     147        if (history == null) return false;
     148        // only show latest of the same version if it is
     149        // modified
     150        if (history.getByVersion(primitive.getVersion()) != null)
     151            return primitive.isModified();
     152
     153        // latest has a higher version than one of the primitives
     154        // in the history (probably because the history got out of sync
     155        // with uploaded data) -> show the primitive as latest
     156        return true;
    86157    }
    87158
     
    97168            current = history.getEarliest();
    98169            reference = history.getEarliest();
     170            setLatest(null);
     171            if (getEditLayer() != null) {
     172                OsmPrimitive p = getEditLayer().data.getPrimitiveById(history.getId(), history.getType());
     173                if (canShowAsLatest(p)) {
     174                    HistoryOsmPrimitive latest = new HistoryPrimitiveBuilder().build(p);
     175                    setLatest(latest);
     176                }
     177            }
    99178        }
    100179        initTagTableModels();
    101180        fireModelChange();
    102181    }
    103 
    104182
    105183    protected void fireModelChange() {
     
    177255    }
    178256
     257    /**
     258     * Sets the {@see HistoryOsmPrimitive} which plays the role of a reference point
     259     * in time (see {@see PointInTimeType}).
     260     *
     261     * @param reference the reference history primitive. Must not be null.
     262     * @throws IllegalArgumentException thrown if reference is null
     263     * @throws IllegalStateException thrown if this model isn't a assigned a history yet
     264     * @throws IllegalArgumentException if reference isn't an history primitive for the history managed by this mode
     265     *
     266     * @see #setHistory(History)
     267     * @see PointInTimeType
     268     */
    179269    public void setReferencePointInTime(HistoryOsmPrimitive reference) throws IllegalArgumentException, IllegalStateException{
    180270        if (reference == null)
     
    196286    }
    197287
     288    /**
     289     * Sets the {@see HistoryOsmPrimitive} which plays the role of the current point
     290     * in time (see {@see PointInTimeType}).
     291     *
     292     * @param reference the reference history primitive. Must not be null.
     293     * @throws IllegalArgumentException thrown if reference is null
     294     * @throws IllegalStateException thrown if this model isn't a assigned a history yet
     295     * @throws IllegalArgumentException if reference isn't an history primitive for the history managed by this mode
     296     *
     297     * @see #setHistory(History)
     298     * @see PointInTimeType
     299     */
    198300    public void setCurrentPointInTime(HistoryOsmPrimitive current) throws IllegalArgumentException, IllegalStateException{
    199301        if (current == null)
     
    252354
    253355    /**
     356     * Returns true if <code>primitive</code> is the latest primitive
     357     * representing the version currently edited in the current data
     358     * layer.
     359     *
     360     * @param primitive the primitive to check
     361     * @return true if <code>primitive</code> is the latest primitive
     362     */
     363    public boolean isLatest(HistoryOsmPrimitive primitive) {
     364        if (primitive == null) return false;
     365        return primitive == latest;
     366    }
     367
     368    /**
    254369     * The table model for the list of versions in the current history
    255370     *
    256371     */
    257     public class VersionTableModel extends DefaultTableModel {
     372    public class VersionTableModel extends DefaultTableModel{
    258373
    259374        private VersionTableModel() {
     
    264379            if (history == null)
    265380                return 0;
    266             return history.getNumVersions();
     381            int ret = history.getNumVersions();
     382            if (latest != null) {
     383                ret++;
     384            }
     385            return ret;
    267386        }
    268387
     
    271390            if(history == null)
    272391                return null;
    273             return history.get(row);
     392            if (row < history.getNumVersions())
     393                return history.get(row);
     394            if (row == history.getNumVersions())
     395                return latest;
     396            return null;
    274397        }
    275398
     
    281404        public void setReferencePointInTime(int row) {
    282405            if (history == null) return;
     406            if (row == history.getNumVersions()) {
     407                if (latest != null) {
     408                    HistoryBrowserModel.this.setReferencePointInTime(latest);
     409                }
     410                return;
     411            }
    283412            if (row < 0 || row > history.getNumVersions()) return;
    284413            HistoryOsmPrimitive reference = history.get(row);
     
    288417        public void setCurrentPointInTime(int row) {
    289418            if (history == null) return;
     419            if (row == history.getNumVersions()) {
     420                if (latest != null) {
     421                    HistoryBrowserModel.this.setCurrentPointInTime(latest);
     422                }
     423                return;
     424            }
    290425            if (row < 0 || row > history.getNumVersions()) return;
    291426            HistoryOsmPrimitive current = history.get(row);
     
    295430        public boolean isReferencePointInTime(int row) {
    296431            if (history == null) return false;
     432            if (row == history.getNumVersions())
     433                return latest == reference;
    297434            if (row < 0 || row > history.getNumVersions()) return false;
    298435            HistoryOsmPrimitive p = history.get(row);
    299             return p.equals(reference);
     436            return p == reference;
    300437        }
    301438
    302439        public HistoryOsmPrimitive getPrimitive(int row) {
    303440            return history.get(row);
     441        }
     442
     443        public boolean isLatest(int row) {
     444            return row >= history.getNumVersions();
     445        }
     446
     447        public OsmPrimitive getLatest() {
     448            if (latest == null) return null;
     449            if (getEditLayer() == null) return null;
     450            OsmPrimitive p = getEditLayer().data.getPrimitiveById(latest.getId(), latest.getType());
     451            return p;
    304452        }
    305453    }
     
    467615                return null;
    468616            return way.getNodes().get(row);
     617        }
     618
     619        public PrimitiveId getNodeId(int row) {
     620            HistoryWay way = getWay();
     621            if (way == null) return null;
     622            if (row > way.getNumNodes()) return null;
     623            return new SimplePrimitiveId(way.getNodeId(row), OsmPrimitiveType.NODE);
    469624        }
    470625
     
    587742        }
    588743    }
     744
     745    protected void setLatest(HistoryOsmPrimitive latest) {
     746        if (latest == null) {
     747            if (this.current == this.latest) {
     748                this.current = history.getLatest();
     749            }
     750            if (this.reference == this.latest) {
     751                this.current = history.getLatest();
     752            }
     753            this.latest = null;
     754        } else {
     755            if (this.current == this.latest) {
     756                this.current = latest;
     757            }
     758            if (this.reference == this.latest) {
     759                this.reference = latest;
     760            }
     761            this.latest = latest;
     762        }
     763        fireModelChange();
     764    }
     765
     766    /**
     767     * Removes this model as listener for data change and layer change
     768     * events.
     769     *
     770     */
     771    public void unlinkAsListener() {
     772        if (getEditLayer() != null) {
     773            getEditLayer().data.removeDataSetListener(this);
     774        }
     775        Layer.listeners.remove(this);
     776
     777    }
     778
     779    /* ---------------------------------------------------------------------- */
     780    /* DataSetListener                                                        */
     781    /* ---------------------------------------------------------------------- */
     782    public void nodeMoved(Node node) {
     783        if (!node.isNew() && node.getId() == history.getId()) {
     784            setLatest(new HistoryPrimitiveBuilder().build(node));
     785        }
     786    }
     787
     788    public void primtivesAdded(Collection<? extends OsmPrimitive> added) {
     789        if (added == null || added.isEmpty()) return;
     790        for (OsmPrimitive p: added) {
     791            if (canShowAsLatest(p)) {
     792                setLatest(new HistoryPrimitiveBuilder().build(p));
     793            }
     794        }
     795    }
     796
     797    public void primtivesRemoved(Collection<? extends OsmPrimitive> removed) {
     798        if (removed == null || removed.isEmpty()) return;
     799        for (OsmPrimitive p: removed) {
     800            if (!p.isNew() && p.getId() == history.getId()) {
     801                setLatest(null);
     802            }
     803        }
     804    }
     805
     806    public void relationMembersChanged(Relation r) {
     807        if (!r.isNew() && r.getId() == history.getId()) {
     808            setLatest(new HistoryPrimitiveBuilder().build(r));
     809        }
     810    }
     811
     812    public void tagsChanged(OsmPrimitive prim) {
     813        if (!prim.isNew() && prim.getId() == history.getId()) {
     814            setLatest(new HistoryPrimitiveBuilder().build(prim));
     815        }
     816    }
     817
     818    public void wayNodesChanged(Way way) {
     819        if (!way.isNew() && way.getId() == history.getId()) {
     820            setLatest(new HistoryPrimitiveBuilder().build(way));
     821        }
     822    }
     823
     824    /* ---------------------------------------------------------------------- */
     825    /* DataChangeListener                                                    */
     826    /* ---------------------------------------------------------------------- */
     827    public void dataChanged(OsmDataLayer l) {
     828        if (l != getEditLayer()) return;
     829        OsmPrimitive primitive = l.data.getPrimitiveById(history.getId(), history.getType());
     830        HistoryOsmPrimitive latest;
     831        if (canShowAsLatest(primitive)) {
     832            latest = new HistoryPrimitiveBuilder().build(primitive);
     833        } else {
     834            latest = null;
     835        }
     836        setLatest(latest);
     837        fireModelChange();
     838    }
     839
     840    /* ---------------------------------------------------------------------- */
     841    /* LayerChangeListener                                                    */
     842    /* ---------------------------------------------------------------------- */
     843    public void activeLayerChange(Layer oldLayer, Layer newLayer) {
     844        if (oldLayer != null && oldLayer instanceof OsmDataLayer) {
     845            OsmDataLayer l = (OsmDataLayer)oldLayer;
     846            l.data.removeDataSetListener(this);
     847            l.listenerDataChanged.remove(this);
     848        }
     849        if (newLayer == null || ! (newLayer instanceof OsmDataLayer)) {
     850            latest = null;
     851            fireModelChange();
     852            return;
     853        }
     854        OsmDataLayer l = (OsmDataLayer)newLayer;
     855        l.data.addDataSetListener(this);
     856        l.listenerDataChanged.add(this);
     857        OsmPrimitive primitive = l.data.getPrimitiveById(history.getId(), history.getType());
     858        HistoryOsmPrimitive latest;
     859        if (canShowAsLatest(primitive)) {
     860            latest = new HistoryPrimitiveBuilder().build(primitive);
     861        } else {
     862            latest = null;
     863        }
     864        setLatest(latest);
     865        fireModelChange();
     866    }
     867
     868    public void layerAdded(Layer newLayer) {}
     869    public void layerRemoved(Layer oldLayer) {}
     870
     871    /**
     872     * Creates a {@see HistoryOsmPrimitive} from a {@see OsmPrimitive}
     873     *
     874     */
     875    class HistoryPrimitiveBuilder extends AbstractVisitor {
     876        private HistoryOsmPrimitive clone;
     877
     878        public void visit(Node n) {
     879            clone = new HistoryNode(n.getId(), n.getVersion(), n.isVisible(),n.getUser().getName(), n.getUser().getId(), 0, n.getTimestamp(), n.getCoor());
     880            clone.setTags(n.getKeys());
     881        }
     882
     883        public void visit(Relation r) {
     884            clone = new HistoryRelation(r.getId(), r.getVersion(), r.isVisible(),r.getUser().getName(), r.getUser().getId(), 0, r.getTimestamp());
     885            clone.setTags(r.getKeys());
     886            HistoryRelation hr = (HistoryRelation)clone;
     887            for (RelationMember rm : r.getMembers()) {
     888                hr.addMember(new org.openstreetmap.josm.data.osm.history.RelationMember(rm.getRole(), rm.getType(), rm.getUniqueId()));
     889            }
     890        }
     891
     892        public void visit(Way w) {
     893            clone = new HistoryWay(w.getId(), w.getVersion(), w.isVisible(),w.getUser().getName(), w.getUser().getId(), 0, w.getTimestamp());
     894            clone.setTags(w.getKeys());
     895            for (Node n: w.getNodes()) {
     896                ((HistoryWay)clone).addNode(n.getUniqueId());
     897            }
     898        }
     899
     900        public HistoryOsmPrimitive build(OsmPrimitive primitive) {
     901            primitive.visit(this);
     902            return clone;
     903        }
     904    }
    589905}
  • trunk/src/org/openstreetmap/josm/gui/history/HistoryLoadTask.java

    r2275 r2448  
    77import java.io.IOException;
    88import java.util.Collection;
    9 import java.util.HashMap;
    10 import java.util.Map;
     9import java.util.HashSet;
    1110
    1211import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1312import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
     13import org.openstreetmap.josm.data.osm.PrimitiveId;
     14import org.openstreetmap.josm.data.osm.SimplePrimitiveId;
    1415import org.openstreetmap.josm.data.osm.history.History;
    1516import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
     
    4546    private boolean cancelled = false;
    4647    private Exception lastException  = null;
    47     private Map<Long, OsmPrimitiveType> toLoad;
     48    private HashSet<PrimitiveId> toLoad;
    4849    private HistoryDataSet loadedData;
    4950
    5051    public HistoryLoadTask() {
    5152        super(tr("Load history"), true);
    52         toLoad = new HashMap<Long, OsmPrimitiveType>();
     53        toLoad = new HashSet<PrimitiveId>();
    5354    }
    5455
     
    6061     * @return this task
    6162     */
    62     public HistoryLoadTask add(long id, OsmPrimitiveType type) {
     63    public HistoryLoadTask add(long id, OsmPrimitiveType type) throws IllegalArgumentException {
    6364        if (id <= 0)
    64             throw new IllegalArgumentException(tr("ID > 0 expected. Got {0}.", id));
     65            throw new IllegalArgumentException(tr("Parameter ''{0}'' > 0 expected. Got {1}.", "id", id));
    6566        if (type == null)
    6667            throw new IllegalArgumentException(tr("Parameter ''{0}'' must not be null.", "type"));
    67         if (!toLoad.containsKey(id)) {
    68             toLoad.put(id, type);
    69         }
     68        SimplePrimitiveId pid = new SimplePrimitiveId(id, type);
     69        toLoad.add(pid);
     70        return this;
     71    }
     72
     73    /**
     74     * Adds an object whose history is to be loaded.
     75     *
     76     * @param pid  the primitive id. Must not be null. Id > 0 required.
     77     * @return this task
     78     */
     79    public HistoryLoadTask add(PrimitiveId pid) throws IllegalArgumentException {
     80        if (pid == null)
     81            throw new IllegalArgumentException(tr("Parameter ''{0}'' must not be null.", "pid"));
     82        if (pid.getUniqueId() <= 0)
     83            throw new IllegalArgumentException(tr("id in parameter ''{0}'' > 0 expected, got {1}.", "pid", pid.getUniqueId()));
     84        toLoad.add(pid);
    7085        return this;
    7186    }
     
    8196        if (primitive == null)
    8297            throw new IllegalArgumentException(tr("Parameter ''{0}'' must not be null.", "primitive"));
    83         if (!toLoad.containsKey(primitive.getId())) {
    84             toLoad.put(primitive.getId(), primitive.getType());
    85         }
     98        toLoad.add(primitive.getPrimitiveId());
    8699        return this;
    87100    }
     
    97110        if (history == null)
    98111            throw new IllegalArgumentException(tr("Parameter ''{0}'' must not be null.", "history"));
    99         if (!toLoad.containsKey(history.getId())) {
    100             toLoad.put(history.getId(), history.getEarliest().getType());
    101         }
     112        toLoad.add(history.getPrimitmiveId());
    102113        return this;
    103114    }
     
    116127        if (primitive.getId() <= 0)
    117128            throw new IllegalArgumentException(tr("Object id > 0 expected. Got {0}", primitive.getId()));
    118 
    119         return add(primitive.getId(), OsmPrimitiveType.from(primitive));
     129        toLoad.add(primitive.getPrimitiveId());
     130        return this;
    120131    }
    121132
     
    161172        loadedData = new HistoryDataSet();
    162173        try {
    163             for(Map.Entry<Long, OsmPrimitiveType> entry: toLoad.entrySet()) {
     174            for(PrimitiveId pid: toLoad) {
    164175                if (cancelled) {
    165176                    break;
    166177                }
    167                 if (entry.getKey() == 0) {
    168                     continue;
    169                 }
    170178                String msg = "";
    171                 switch(entry.getValue()) {
    172                     case NODE: msg = marktr("Loading history for node {0}"); break;
    173                     case WAY: msg = marktr("Loading history for way {0}"); break;
    174                     case RELATION: msg = marktr("Loading history for relation {0}"); break;
     179                switch(pid.getType()) {
     180                case NODE: msg = marktr("Loading history for node {0}"); break;
     181                case WAY: msg = marktr("Loading history for way {0}"); break;
     182                case RELATION: msg = marktr("Loading history for relation {0}"); break;
    175183                }
    176184                progressMonitor.indeterminateSubTask(tr(msg,
    177                         Long.toString(entry.getKey())));
     185                        Long.toString(pid.getUniqueId())));
    178186                OsmServerHistoryReader reader = null;
    179187                HistoryDataSet ds = null;
    180188                try {
    181                     reader = new OsmServerHistoryReader(entry.getValue(), entry.getKey());
     189                    reader = new OsmServerHistoryReader(pid.getType(), pid.getUniqueId());
    182190                    ds = reader.parseHistory(progressMonitor.createSubTaskMonitor(1, false));
    183191                } catch(OsmTransferException e) {
  • trunk/src/org/openstreetmap/josm/gui/history/NodeListViewer.java

    r2243 r2448  
    11// License: GPL. For details, see LICENSE file.
    22package org.openstreetmap.josm.gui.history;
     3
     4import static org.openstreetmap.josm.tools.I18n.tr;
    35
    46import java.awt.GridBagConstraints;
    57import java.awt.GridBagLayout;
    68import java.awt.Insets;
    7 
     9import java.awt.Point;
     10import java.awt.event.ActionEvent;
     11import java.awt.event.MouseAdapter;
     12import java.awt.event.MouseEvent;
     13
     14import javax.swing.AbstractAction;
    815import javax.swing.JPanel;
     16import javax.swing.JPopupMenu;
    917import javax.swing.JScrollPane;
    1018import javax.swing.JTable;
    1119import javax.swing.ListSelectionModel;
     20
     21import org.openstreetmap.josm.Main;
     22import org.openstreetmap.josm.actions.AutoScaleAction;
     23import org.openstreetmap.josm.data.osm.OsmPrimitive;
     24import org.openstreetmap.josm.data.osm.PrimitiveId;
     25import org.openstreetmap.josm.data.osm.history.History;
     26import org.openstreetmap.josm.data.osm.history.HistoryDataSet;
     27import org.openstreetmap.josm.gui.history.HistoryBrowserModel.NodeListTableModel;
     28import org.openstreetmap.josm.gui.layer.OsmDataLayer;
     29import org.openstreetmap.josm.tools.ImageProvider;
    1230
    1331/**
     
    2846    private AdjustmentSynchronizer adjustmentSynchronizer;
    2947    private SelectionSynchronizer selectionSynchronizer;
     48    private NodeListPopupMenu popupMenu;
    3049
    3150    protected JScrollPane embeddInScrollPane(JTable table) {
     
    4564        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    4665        selectionSynchronizer.participateInSynchronizedSelection(table.getSelectionModel());
     66        table.addMouseListener(new PopupMenuLauncher(table));
     67        table.addMouseListener(new DoubleClickAdapter(table));
    4768        return table;
    4869    }
     
    5677        table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    5778        selectionSynchronizer.participateInSynchronizedSelection(table.getSelectionModel());
     79        table.addMouseListener(new PopupMenuLauncher(table));
     80        table.addMouseListener(new DoubleClickAdapter(table));
    5881        return table;
    5982    }
     
    110133        gc.anchor = GridBagConstraints.NORTHWEST;
    111134        add(embeddInScrollPane(buildCurrentNodeListTable()),gc);
     135
     136        popupMenu = new NodeListPopupMenu();
    112137    }
    113138
     
    143168        }
    144169    }
     170
     171
     172    class NodeListPopupMenu extends JPopupMenu {
     173        private ZoomToNodeAction zoomToNodeAction;
     174        private ShowHistoryAction showHistoryAction;
     175
     176        public NodeListPopupMenu() {
     177            zoomToNodeAction = new ZoomToNodeAction();
     178            add(zoomToNodeAction);
     179            showHistoryAction = new ShowHistoryAction();
     180            add(showHistoryAction);
     181        }
     182
     183        public void prepare(PrimitiveId pid){
     184            zoomToNodeAction.setPrimitiveId(pid);
     185            zoomToNodeAction.updateEnabledState();
     186
     187            showHistoryAction.setPrimitiveId(pid);
     188            showHistoryAction.updateEnabledState();
     189        }
     190    }
     191
     192    class ZoomToNodeAction extends AbstractAction {
     193        private PrimitiveId primitiveId;
     194
     195        public ZoomToNodeAction() {
     196            putValue(NAME, tr("Zoom to node"));
     197            putValue(SHORT_DESCRIPTION, tr("Zoom to this node in the current data layer"));
     198            putValue(SMALL_ICON, ImageProvider.get("dialogs", "zoomin"));
     199        }
     200
     201        public void actionPerformed(ActionEvent e) {
     202            if (!isEnabled()) return;
     203            OsmPrimitive p = getPrimitiveToZoom();
     204            if (p!= null) {
     205                getEditLayer().data.setSelected(p.getPrimitiveId());
     206                new AutoScaleAction("selection").autoScale();
     207            }
     208        }
     209
     210        public void setPrimitiveId(PrimitiveId pid) {
     211            this.primitiveId = pid;
     212            updateEnabledState();
     213        }
     214
     215        protected OsmDataLayer getEditLayer() {
     216            try {
     217                return Main.map.mapView.getEditLayer();
     218            } catch(NullPointerException e) {
     219                return null;
     220            }
     221        }
     222
     223        protected OsmPrimitive getPrimitiveToZoom() {
     224            if (primitiveId == null) return null;
     225            OsmPrimitive p = getEditLayer().data.getPrimitiveById(primitiveId);
     226            return p;
     227        }
     228
     229        public void updateEnabledState() {
     230            if (getEditLayer() == null) {
     231                setEnabled(false);
     232                return;
     233            }
     234            setEnabled(getPrimitiveToZoom() != null);
     235        }
     236    }
     237
     238    class ShowHistoryAction extends AbstractAction {
     239        private PrimitiveId primitiveId;
     240
     241        public ShowHistoryAction() {
     242            putValue(NAME, tr("Show history"));
     243            putValue(SHORT_DESCRIPTION, tr("Open a history browser with the history of this node"));
     244            putValue(SMALL_ICON, ImageProvider.get("dialogs", "history"));
     245        }
     246
     247        public void actionPerformed(ActionEvent e) {
     248            if (!isEnabled()) return;
     249            run();
     250        }
     251
     252        public void setPrimitiveId(PrimitiveId pid) {
     253            this.primitiveId = pid;
     254            updateEnabledState();
     255        }
     256
     257        public void run() {
     258            if (HistoryDataSet.getInstance().getHistory(primitiveId) == null) {
     259                Main.worker.submit(new HistoryLoadTask().add(primitiveId));
     260            }
     261            Runnable r = new Runnable() {
     262                public void run() {
     263                    History h = HistoryDataSet.getInstance().getHistory(primitiveId);
     264                    if (h == null)
     265                        return;
     266                    HistoryBrowserDialogManager.getInstance().show(h);
     267                }
     268            };
     269            Main.worker.submit(r);
     270        }
     271
     272        public void updateEnabledState() {
     273            setEnabled(primitiveId != null && primitiveId.getUniqueId() > 0);
     274        }
     275    }
     276
     277    class PopupMenuLauncher extends MouseAdapter {
     278        private JTable table;
     279
     280        public PopupMenuLauncher(JTable table) {
     281            this.table = table;
     282        }
     283
     284        @Override
     285        public void mousePressed(MouseEvent e) {
     286            showPopup(e);
     287        }
     288
     289        @Override
     290        public void mouseReleased(MouseEvent e) {
     291            showPopup(e);
     292        }
     293
     294        private void showPopup(MouseEvent e) {
     295            if (!e.isPopupTrigger()) return;
     296            Point p = e.getPoint();
     297            int row = table.rowAtPoint(p);
     298            NodeListTableModel model = (NodeListTableModel) table.getModel();
     299            PrimitiveId pid = model.getNodeId(row);
     300            popupMenu.prepare(pid);
     301            popupMenu.show(e.getComponent(), e.getX(), e.getY());
     302        }
     303    }
     304
     305    class DoubleClickAdapter extends MouseAdapter {
     306        private JTable table;
     307        private ShowHistoryAction showHistoryAction;
     308
     309        public DoubleClickAdapter(JTable table) {
     310            this.table = table;
     311            showHistoryAction = new ShowHistoryAction();
     312        }
     313
     314        protected NodeListTableModel getModel() {
     315            return (NodeListTableModel)table.getModel();
     316        }
     317
     318        @Override
     319        public void mouseClicked(MouseEvent e) {
     320            if (e.getClickCount() < 2) return;
     321            int row = table.rowAtPoint(e.getPoint());
     322            PrimitiveId pid = getModel().getNodeId(row);
     323            if (pid == null)
     324                return;
     325            showHistoryAction.setPrimitiveId(pid);
     326            showHistoryAction.run();
     327        }
     328    }
    145329}
  • trunk/src/org/openstreetmap/josm/gui/history/TagTableCellRenderer.java

    r2017 r2448  
    66import java.awt.Color;
    77import java.awt.Component;
     8import java.awt.Font;
    89import java.util.logging.Logger;
    910
    1011import javax.swing.JLabel;
    1112import javax.swing.JTable;
     13import javax.swing.UIManager;
    1214import javax.swing.table.TableCellRenderer;
    1315
     
    2022    static private Logger logger = Logger.getLogger(TagTableCellRenderer.class.getName());
    2123
    22     public final static Color BGCOLOR_SELECTED = new Color(143,170,255);
    2324    public final static Color BGCOLOR_DIFFERENCE = new Color(255,197,197);
    2425
    2526    public TagTableCellRenderer() {
    2627        setOpaque(true);
    27         setForeground(Color.BLACK);
    2828    }
    2929
    3030    protected void renderName(String key, HistoryBrowserModel.TagTableModel model, boolean isSelected) {
    3131        String text = key;
    32         Color bgColor = Color.WHITE;
     32        Color bgColor = UIManager.getColor("Table.background");
     33        Color fgColor = UIManager.getColor("Table.foreground");
     34        Font font = UIManager.getFont("Table.font");
    3335        if (! model.hasTag(key)) {
    34             text = tr("<undefined>");
     36            text = tr("not present");
    3537            bgColor = BGCOLOR_DIFFERENCE;
     38            font = font.deriveFont(Font.ITALIC);
    3639        } else if (!model.oppositeHasTag(key)) {
    3740            bgColor = BGCOLOR_DIFFERENCE;
    3841        }
    3942        if (isSelected) {
    40             bgColor = BGCOLOR_SELECTED;
     43            bgColor = UIManager.getColor("Table.backgroundSelected");
     44            fgColor = UIManager.getColor("Table.foregroundSelected");
    4145        }
     46
    4247        setText(text);
    4348        setToolTipText(text);
    4449        setBackground(bgColor);
     50        setForeground(fgColor);
     51        setFont(font);
    4552    }
    4653
    4754    protected void renderValue(String key, HistoryBrowserModel.TagTableModel model, boolean isSelected) {
    4855        String text = "";
    49         Color bgColor = Color.WHITE;
     56        Color bgColor = UIManager.getColor("Table.background");
     57        Color fgColor = UIManager.getColor("Table.foreground");
     58        Font font = UIManager.getFont("Table.font");
    5059        if (! model.hasTag(key)) {
    51             text = tr("<undefined>");
     60            text = tr("not present");
    5261            bgColor = BGCOLOR_DIFFERENCE;
     62            font = font.deriveFont(Font.ITALIC);
    5363        } else {
    5464            text = model.getValue(key);
     
    5868        }
    5969        if (isSelected) {
    60             bgColor = BGCOLOR_SELECTED;
     70            bgColor = UIManager.getColor("Table.backgroundSelected");
     71            fgColor = UIManager.getColor("Table.foregroundSelected");
    6172        }
    6273
     
    6475        setToolTipText(text);
    6576        setBackground(bgColor);
     77        setForeground(fgColor);
     78        setFont(font);
    6679    }
    6780
  • trunk/src/org/openstreetmap/josm/gui/history/VersionInfoPanel.java

    r2318 r2448  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.awt.BorderLayout;
    67import java.awt.FlowLayout;
    78import java.awt.GridBagConstraints;
     
    1718import javax.swing.JPanel;
    1819
     20import org.openstreetmap.josm.Main;
    1921import org.openstreetmap.josm.actions.AbstractInfoAction;
    2022import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
     23import org.openstreetmap.josm.gui.JMultilineLabel;
     24import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    2125import org.openstreetmap.josm.tools.UrlLabel;
    2226
     
    3135    private PointInTimeType pointInTimeType;
    3236    private HistoryBrowserModel model;
    33     private JLabel lblInfo;
     37    private JMultilineLabel lblInfo;
    3438    private UrlLabel lblUser;
    3539    private UrlLabel lblChangeset;
     40    private JPanel pnlUserAndChangeset;
    3641
    3742    protected void build() {
    3843        JPanel pnl1 = new JPanel();
    39         pnl1.setLayout(new FlowLayout(FlowLayout.LEFT));
    40         lblInfo = new JLabel();
    41         lblInfo.setHorizontalAlignment(JLabel.LEFT);
    42         pnl1.add(lblInfo);
     44        pnl1.setLayout(new BorderLayout());
     45        lblInfo = new JMultilineLabel("");
     46        //lblInfo.setHorizontalAlignment(JLabel.LEFT);
     47        pnl1.add(lblInfo, BorderLayout.CENTER);
    4348
    44         JPanel pnl2 = new JPanel();
    45         pnl2.setLayout(new FlowLayout(FlowLayout.LEFT));
     49        pnlUserAndChangeset = new JPanel();
     50        pnlUserAndChangeset.setLayout(new FlowLayout(FlowLayout.LEFT));
    4651        lblUser = new UrlLabel();
    47         pnl2.add(new JLabel(tr("User")));
    48         pnl2.add(lblUser);
    49         pnl2.add(new JLabel(tr("Changeset")));
     52        pnlUserAndChangeset.add(new JLabel(tr("User")));
     53        pnlUserAndChangeset.add(lblUser);
     54        pnlUserAndChangeset.add(new JLabel(tr("Changeset")));
    5055        lblChangeset = new UrlLabel();
    51         pnl2.add(lblChangeset);
     56        pnlUserAndChangeset.add(lblChangeset);
    5257
    5358        setLayout(new GridBagLayout());
     
    5661        gc.fill = GridBagConstraints.HORIZONTAL;
    5762        gc.weightx = 1.0;
    58         gc.weighty = 0.0;
     63        gc.weighty = 1.0;
    5964        add(pnl1, gc);
    6065        gc.gridy = 1;
    61         add(pnl2, gc);
     66        gc.weighty = 0.0;
     67        add(pnlUserAndChangeset, gc);
    6268    }
    6369
     
    6874    }
    6975
     76    protected OsmDataLayer getEditLayer() {
     77        try {
     78            return Main.map.mapView.getEditLayer();
     79        } catch(NullPointerException e) {
     80            return null;
     81        }
     82    }
     83
    7084    protected String getInfoText() {
    7185        HistoryOsmPrimitive primitive = getPrimitive();
    7286        if (primitive == null)
    7387            return "";
    74         String text = tr(
    75                 "<html>Version <strong>{0}</strong> created on <strong>{1}</strong></html>",
    76                 Long.toString(primitive.getVersion()),
    77                 new SimpleDateFormat().format(primitive.getTimestamp())
    78         );
     88        String text;
     89        if (model.isLatest(primitive)) {
     90            text = tr("<html>Version <strong>{0}</strong> currently edited in layer ''{1}''</html>",
     91                    Long.toString(primitive.getVersion()),
     92                    getEditLayer() == null ? tr("unknown") : getEditLayer().getName()
     93            );
     94        } else {
     95            text = tr(
     96                    "<html>Version <strong>{0}</strong> created on <strong>{1}</strong></html>",
     97                    Long.toString(primitive.getVersion()),
     98                    new SimpleDateFormat().format(primitive.getTimestamp())
     99            );
     100        }
    79101        return text;
    80102    }
     
    110132        lblInfo.setText(getInfoText());
    111133
    112         String url = AbstractInfoAction.getBaseBrowseUrl() + "/changeset/" + getPrimitive().getChangesetId();
    113         lblChangeset.setUrl(url);
    114         lblChangeset.setDescription(Long.toString(getPrimitive().getChangesetId()));
     134        if (!model.isLatest(getPrimitive())) {
     135            String url = AbstractInfoAction.getBaseBrowseUrl() + "/changeset/" + getPrimitive().getChangesetId();
     136            lblChangeset.setUrl(url);
     137            lblChangeset.setDescription(Long.toString(getPrimitive().getChangesetId()));
    115138
    116         try {
    117             if (getPrimitive().getUid() != -1) {
    118                 url = AbstractInfoAction.getBaseUserUrl() + "/" +  URLEncoder.encode(getPrimitive().getUser(), "UTF-8").replaceAll("\\+", "%20");
    119                 lblUser.setUrl(url);
    120             } else {
     139            try {
     140                if (getPrimitive().getUid() != -1) {
     141                    url = AbstractInfoAction.getBaseUserUrl() + "/" +  URLEncoder.encode(getPrimitive().getUser(), "UTF-8").replaceAll("\\+", "%20");
     142                    lblUser.setUrl(url);
     143                } else {
     144                    lblUser.setUrl(null);
     145                }
     146            } catch(UnsupportedEncodingException e) {
     147                e.printStackTrace();
    121148                lblUser.setUrl(null);
    122149            }
    123         } catch(UnsupportedEncodingException e) {
    124             e.printStackTrace();
    125             lblUser.setUrl(null);
     150            String username = getPrimitive().getUser();
     151            lblUser.setDescription(username);
     152        } else {
     153            String user = Main.pref.get("osm-server.username");
     154            if (user == null) {
     155                lblUser.setDescription(tr("anonymous"));
     156            } else {
     157                try {
     158                    String url = AbstractInfoAction.getBaseUserUrl() + "/" +  URLEncoder.encode(user, "UTF-8").replaceAll("\\+", "%20");
     159                    lblUser.setUrl(url);
     160                } catch(UnsupportedEncodingException e) {
     161                    e.printStackTrace();
     162                    lblUser.setUrl(null);
     163                }
     164                lblUser.setDescription(user);
     165            }
     166            lblChangeset.setDescription(tr("none"));
     167            lblChangeset.setUrl(null);
    126168        }
    127         String username = getPrimitive().getUser();
    128         lblUser.setDescription(username);
    129169    }
    130170}
  • trunk/src/org/openstreetmap/josm/gui/history/VersionTableCellRenderer.java

    r2250 r2448  
    1515import javax.swing.table.TableCellRenderer;
    1616
     17import org.openstreetmap.josm.Main;
     18import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1719import org.openstreetmap.josm.data.osm.OsmPrimitiveType;
    1820import org.openstreetmap.josm.data.osm.history.HistoryOsmPrimitive;
     21import org.openstreetmap.josm.gui.layer.OsmDataLayer;
    1922import org.openstreetmap.josm.tools.ImageProvider;
    2023
     
    4447    }
    4548
    46     protected void renderIcon(HistoryOsmPrimitive primitive) {
    47         ImageIcon icon = null;
    48         if (primitive != null) {
    49             icon = icons.get(primitive.getType());
    50         }
     49    protected void renderIcon(OsmPrimitiveType type) {
     50        ImageIcon icon = type == null? null : icons.get(type);
    5151        setIcon(icon);
    5252    }
    5353
    5454    protected void renderText(HistoryOsmPrimitive primitive) {
    55         // render lable text
     55        // render label text
    5656        //
    5757        StringBuilder sb = new StringBuilder();
     
    8686    }
    8787
     88    protected OsmDataLayer getEditLayer() {
     89        try {
     90            return Main.map.mapView.getEditLayer();
     91        } catch(NullPointerException e) {
     92            return null;
     93        }
     94    }
     95
     96    protected void renderLatestText(OsmPrimitive primitive) {
     97        // -- label text
     98        StringBuffer sb = new StringBuffer();
     99        if (primitive == null) {
     100            setText("");
     101            return;
     102        }
     103        if (primitive.isModified()) {
     104            sb.append("*");
     105        }
     106        sb.append(tr("Version {0} in editor", primitive.getVersion()));
     107        if (primitive.isDeleted()) {
     108            sb.append(tr("[deleted]"));
     109        }
     110        setText(sb.toString());
     111
     112        // -- tooltip text
     113        sb = new StringBuffer();
     114        OsmDataLayer l = getEditLayer();
     115
     116        sb.append(
     117                tr(
     118                        "Version {0} currently edited in data layer ''{1}''",
     119                        primitive.getId(),
     120                        l == null ? tr("unknown") : l.getName()
     121                )
     122        );
     123        setToolTipText(sb.toString());
     124    }
     125
    88126    protected void renderBackground(JTable table, int row, boolean isSelected) {
    89127        Color bgColor = Color.WHITE;
     
    96134    }
    97135
     136    public void renderVersionFromHistory(HistoryOsmPrimitive primitive, JTable table, int row, boolean isSelected) {
     137        renderIcon(primitive.getType());
     138        renderText(primitive);
     139        renderBackground(table, row, isSelected);
     140    }
     141
     142    public void renderLatest(OsmPrimitive primitive, JTable table, int row, boolean isSelected) {
     143        renderIcon(primitive.getType());
     144        renderLatestText(getModel(table).getLatest());
     145        renderBackground(table, row, isSelected);
     146    }
     147
    98148    public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
    99149            int row, int column) {
    100 
    101         HistoryOsmPrimitive primitive = (HistoryOsmPrimitive)value;
    102         renderIcon(primitive);
    103         renderText(primitive);
    104         renderBackground(table, row, isSelected);
     150        if (getModel(table).isLatest(row)) {
     151            renderLatest(getModel(table).getLatest(),table, row, isSelected);
     152        } else {
     153            renderVersionFromHistory((HistoryOsmPrimitive)value, table, row, isSelected);
     154        }
    105155        return this;
    106156    }
Note: See TracChangeset for help on using the changeset viewer.