Changeset 94 in josm


Ignore:
Timestamp:
2006-04-23T19:51:19+02:00 (14 years ago)
Author:
imi
Message:
  • changed Add Way mode, so that ways can be modified
  • added Command Stack dialog (list the undo buffer)
  • fixed Exception in download gps data
Files:
5 added
39 edited
2 moved

Legend:

Unmodified
Added
Removed
  • src/org/openstreetmap/josm/Main.java

    r93 r94  
    110110                getContentPane().add(panel, BorderLayout.CENTER);
    111111                setSize(1000,740); // some strange default size
    112                 setVisible(true);
    113112
    114113                downloadAction = new DownloadAction();
  • src/org/openstreetmap/josm/actions/AutoScaleAction.java

    r93 r94  
    5151                this.mapFrame = mapFrame;
    5252                Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
    53                         public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     53                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    5454                                if (mode == AutoScaleMode.selection)
    5555                                        mapFrame.mapView.recalculateCenterScale();
  • src/org/openstreetmap/josm/actions/DownloadAction.java

    r92 r94  
    101101                        super("Downloading GPS data");
    102102                        this.reader = reader;
     103                        reader.setProgressInformation(currentAction, progress);
    103104                }
    104105
  • src/org/openstreetmap/josm/actions/GroupAction.java

    r93 r94  
    33import java.awt.event.ActionEvent;
    44import java.awt.event.ActionListener;
    5 import java.awt.event.KeyEvent;
    65import java.beans.PropertyChangeEvent;
    76import java.beans.PropertyChangeListener;
     
    1716import org.openstreetmap.josm.gui.IconToggleButton;
    1817import org.openstreetmap.josm.tools.ImageProvider;
     18import org.openstreetmap.josm.tools.ShortCutLabel;
    1919import org.openstreetmap.josm.tools.ImageProvider.OverlayPosition;
    2020
     
    5050        public GroupAction(int shortCut, int modifiers) {
    5151                registerShortCut(getClass().getName(), KeyStroke.getKeyStroke(shortCut, modifiers));
    52                 if ((modifiers & KeyEvent.CTRL_DOWN_MASK) != 0)
    53                         shortCutName += "Ctrl-";
    54                 if ((modifiers & KeyEvent.ALT_DOWN_MASK) != 0)
    55                         shortCutName += "Alt-";
    56                 if ((modifiers & KeyEvent.ALT_GRAPH_DOWN_MASK) != 0)
    57                         shortCutName += "AltGr-";
    58                 if ((modifiers & KeyEvent.SHIFT_DOWN_MASK) != 0)
    59                         shortCutName += "Shift-";
    60                 shortCutName += Character.toUpperCase((char)shortCut);
     52                shortCutName = ShortCutLabel.name(shortCut, modifiers);
    6153                addPropertyChangeListener(new PropertyChangeListener(){
    6254                        public void propertyChange(PropertyChangeEvent evt) {
  • src/org/openstreetmap/josm/actions/mapmode/AddNodeAction.java

    r93 r94  
    4949        }
    5050
    51         @Override public void registerListener() {
    52                 super.registerListener();
     51        @Override public void enterMode() {
     52                super.enterMode();
    5353                mv.addMouseListener(this);
    5454        }
    5555
    56         @Override public void unregisterListener() {
    57                 super.unregisterListener();
     56        @Override public void exitMode() {
     57                super.exitMode();
    5858                mv.removeMouseListener(this);
    5959        }
  • src/org/openstreetmap/josm/actions/mapmode/AddSegmentAction.java

    r93 r94  
    4949        }
    5050
    51         @Override public void registerListener() {
    52                 super.registerListener();
     51        @Override public void enterMode() {
     52                super.enterMode();
    5353                mv.addMouseListener(this);
    5454                mv.addMouseMotionListener(this);
    5555        }
    5656
    57         @Override public void unregisterListener() {
    58                 super.unregisterListener();
     57        @Override public void exitMode() {
     58                super.exitMode();
    5959                mv.removeMouseListener(this);
    6060                mv.removeMouseMotionListener(this);
  • src/org/openstreetmap/josm/actions/mapmode/AddWayAction.java

    r93 r94  
    11package org.openstreetmap.josm.actions.mapmode;
    22
    3 import java.awt.event.ActionEvent;
    43import java.awt.event.KeyEvent;
     4import java.awt.event.MouseEvent;
     5import java.util.Arrays;
    56import java.util.Collection;
     7import java.util.HashSet;
    68import java.util.Iterator;
    79import java.util.LinkedList;
     
    1113import org.openstreetmap.josm.Main;
    1214import org.openstreetmap.josm.command.AddCommand;
     15import org.openstreetmap.josm.command.ChangeCommand;
     16import org.openstreetmap.josm.command.Command;
     17import org.openstreetmap.josm.command.DeleteCommand;
     18import org.openstreetmap.josm.data.SelectionChangedListener;
     19import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1320import org.openstreetmap.josm.data.osm.Segment;
    14 import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1521import org.openstreetmap.josm.data.osm.Way;
    1622import org.openstreetmap.josm.gui.MapFrame;
    1723
    1824/**
    19  * Add a new way from all selected segments.
     25 * Add a new way. The action is split into the first phase, where a new way get
     26 * created or selected and the second, where this way is modified.
    2027 *
     28 * Way creation mode:
    2129 * If there is a selection when the mode is entered, all segments in this
    22  * selection form a new way, except the user holds down Shift.
     30 * selection form a new way. All non-segment objects are deselected. If there
     31 * were ways selected, the user is asked whether to select all segments of these
     32 * ways or not, except there is exactly one way selected, which enter the
     33 * edit ways mode for this way immediatly.
     34 *
     35 * If there is no selection on entering, and the user clicks on an segment,
     36 * the way editing starts the with a new way and this segment. If the user click
     37 * on a way (not holding Alt down), then this way is edited in the way edit mode.
    2338 *
    24  * The user can click on a segment. If he holds down Shift, no way is
    25  * created yet. If he holds down Alt, the whole way is considered instead of
    26  * the clicked segment. If the user holds down Ctrl, no way is created
    27  * and the clicked segment get removed from the list.
    28  *
    29  * Also, the user may select a rectangle as in selection mode. No node, area or
    30  * way can be selected this way.
     39 * Way editing mode:
     40 * The user can click on subsequent segments. If the segment belonged to the way
     41 * it get removed from the way. Elsewhere it get added to the way. JOSM try to add
     42 * the segment in the correct position. This is done by searching for connections
     43 * to the segment at its 'to' node which are also in the way. The segemnt is
     44 * inserted in the way as predecessor of the found segment (or at last segment, if
     45 * nothing found).
    3146 *
    3247 * @author imi
    33  *
    3448 */
    35 public class AddWayAction extends MapMode {
    36 
    37         private MapMode followMode;
    38        
     49public class AddWayAction extends MapMode implements SelectionChangedListener {
     50
     51        private Way way;
     52
    3953        /**
    4054         * Create a new AddWayAction.
     
    4256         * @param followMode The mode to go into when finished creating a way.
    4357         */
    44         public AddWayAction(MapFrame mapFrame, MapMode followMode) {
    45                 super("Add Way", "addway", "Combine selected segments to a new way.", "W", KeyEvent.VK_W, mapFrame);
    46                 this.followMode = followMode;
    47         }
    48 
    49         @Override public void actionPerformed(ActionEvent e) {
    50                 makeWay();
    51                 super.actionPerformed(e);
    52                 mapFrame.selectMapMode(followMode);
     58        public AddWayAction(MapFrame mapFrame) {
     59                super("Add Way", "addway", "Add a new way to the data.", "W", KeyEvent.VK_W, mapFrame);
     60               
     61                Main.ds.addSelectionChangedListener(this);
     62        }
     63
     64        @Override public void enterMode() {
     65                super.enterMode();
     66                Command c = null;
     67                way = makeWay();
     68                if (way != null) {
     69                        c = new AddCommand(way);
     70                        Main.ds.setSelected(way);
     71                        mv.editLayer().add(c);
     72                } else
     73                        Main.ds.clearSelection();
     74                mv.addMouseListener(this);
     75        }
     76
     77        @Override public void exitMode() {
     78                super.exitMode();
     79                way = null;
     80                mv.removeMouseListener(this);
     81        }
     82
     83        @Override public void mouseClicked(MouseEvent e) {
     84                if (e.getButton() != MouseEvent.BUTTON1)
     85                        return;
     86
     87                Segment s = mv.getNearestSegment(e.getPoint());
     88                if (s == null)
     89                        return;
     90
     91                // special case for initial selecting one way
     92                if (way == null && (e.getModifiers() & MouseEvent.ALT_DOWN_MASK) == 0) {
     93                        Way w = mv.getNearestWay(e.getPoint());
     94                        if (w != null) {
     95                                way = w;
     96                                Main.ds.setSelected(way);
     97                                return;
     98                        }
     99                }
     100
     101                if (way != null && way.segments.contains(s)) {
     102                        Way copy = new Way(way);
     103
     104                        copy.segments.remove(s);
     105                        if (copy.segments.isEmpty()) {
     106                                mv.editLayer().add(new DeleteCommand(Arrays.asList(new OsmPrimitive[]{way})));
     107                                way = null;
     108                        } else
     109                                mv.editLayer().add(new ChangeCommand(way, copy));
     110                } else {
     111                        if (way == null) {
     112                                way = new Way();
     113                                way.segments.add(s);
     114                                mv.editLayer().add(new AddCommand(way));
     115                        } else {
     116                                Way copy = new Way(way);
     117                                int i;
     118                                for (i = 0; i < way.segments.size(); ++i)
     119                                        if (way.segments.get(i).from == s.to)
     120                                                break;
     121                                copy.segments.add(i, s);
     122                                mv.editLayer().add(new ChangeCommand(way, copy));
     123                        }
     124                }
     125                Main.ds.setSelected(way);
    53126        }
    54127
    55128        /**
    56          * Just make a way of all selected items.
     129         * Form a way, either out of the (one) selected way or by creating a way over the selected
     130         * line segments.
    57131         */
    58         private void makeWay() {
     132        private Way makeWay() {
    59133                Collection<OsmPrimitive> selection = Main.ds.getSelected();
    60134                if (selection.isEmpty())
    61                         return;
    62 
    63                 // form a new way
    64                 LinkedList<Segment> segments = new LinkedList<Segment>();
     135                        return null;
     136
     137                if (selection.size() == 1 && selection.iterator().next() instanceof Way)
     138                        return (Way)selection.iterator().next();
     139
     140                HashSet<Segment> segmentSet = new HashSet<Segment>();
    65141                int numberOfSelectedWays = 0;
    66142                for (OsmPrimitive osm : selection) {
     
    68144                                numberOfSelectedWays++;
    69145                        else if (osm instanceof Segment)
    70                                 segments.add((Segment)osm);
    71                 }
    72                
     146                                segmentSet.add((Segment)osm);
     147                }
     148
    73149                if (numberOfSelectedWays > 0) {
    74150                        String ways = "way" + (numberOfSelectedWays==1?" has":"s have");
    75151                        int answer = JOptionPane.showConfirmDialog(Main.main, numberOfSelectedWays+" "+ways+" been selected.\n" +
    76                                         "Do you wish to select all segments belonging to the "+ways+" instead?");
    77                         if (answer == JOptionPane.CANCEL_OPTION)
    78                                 return;
     152                                        "Do you wish to select all segments belonging to the "+ways+" instead?", "Add segments from ways", JOptionPane.YES_NO_OPTION);
    79153                        if (answer == JOptionPane.YES_OPTION) {
    80154                                for (OsmPrimitive osm : selection)
    81155                                        if (osm instanceof Way)
    82                                                 segments.addAll(((Way)osm).segments);
    83                         }
    84                 }
    85                
    86                 if (segments.isEmpty())
    87                         return;
    88                
     156                                                segmentSet.addAll(((Way)osm).segments);
     157                        }
     158                }
     159
     160                if (segmentSet.isEmpty())
     161                        return null;
     162
    89163                // sort the segments in best possible order. This is done by:
    90164                // 0  if no elements in list, quit
     
    94168                // 4  if not found, save the pivot-string and goto 0
    95169                LinkedList<Segment> sortedSegments = new LinkedList<Segment>();
     170                LinkedList<Segment> segments = new LinkedList<Segment>(segmentSet);
    96171                while (!segments.isEmpty()) {
    97172                        LinkedList<Segment> pivotList = new LinkedList<Segment>();
     
    117192                        sortedSegments.addAll(pivotList);
    118193                }
    119                
     194
     195                if (JOptionPane.YES_OPTION != JOptionPane.showConfirmDialog(Main.main, "Create a new way out of "+sortedSegments.size()+" segments?", "Create new way", JOptionPane.YES_NO_OPTION))
     196                        return null;
     197
    120198                Way w = new Way();
    121199                w.segments.addAll(sortedSegments);
    122                 mv.editLayer().add(new AddCommand(w));
    123                 Main.ds.clearSelection();
    124                 mv.repaint();
    125         }
     200                return w;
     201        }
     202
     203        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     204                if (newSelection.size() == 1) {
     205                        OsmPrimitive osm = newSelection.iterator().next();
     206                        way = osm instanceof Way ? (Way)osm : null;
     207                } else
     208                        way = null;
     209    }
    126210}
  • src/org/openstreetmap/josm/actions/mapmode/DeleteAction.java

    r86 r94  
    66import java.util.Collection;
    77import java.util.Collections;
    8 import java.util.LinkedList;
     8import java.util.HashSet;
    99
    1010import javax.swing.JOptionPane;
    1111
    1212import org.openstreetmap.josm.Main;
    13 import org.openstreetmap.josm.command.Command;
    1413import org.openstreetmap.josm.command.DeleteCommand;
    15 import org.openstreetmap.josm.command.SequenceCommand;
    1614import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1715import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
     
    4644        }
    4745
    48         @Override public void registerListener() {
    49                 super.registerListener();
     46        @Override public void enterMode() {
     47                super.enterMode();
    5048                mv.addMouseListener(this);
    5149        }
    5250
    53         @Override public void unregisterListener() {
    54                 super.unregisterListener();
     51        @Override public void exitMode() {
     52                super.exitMode();
    5553                mv.removeMouseListener(this);
    5654        }
     
    104102         */
    105103        private void deleteWithReferences(Collection<OsmPrimitive> selection) {
    106                 Collection<Command> deleteCommands = new LinkedList<Command>();
     104                CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    107105                for (OsmPrimitive osm : selection)
    108                         deleteCommands.add(new DeleteCommand(osm));
    109                 if (!deleteCommands.isEmpty())
    110                         mv.editLayer().add(new SequenceCommand(deleteCommands));
     106                        osm.visit(v);
     107                v.data.addAll(selection);
     108                if (!v.data.isEmpty())
     109                        mv.editLayer().add(new DeleteCommand(v.data));
    111110        }
    112111
     
    120119         */
    121120        private void delete(Collection<OsmPrimitive> selection, boolean msgBox) {
    122                 Collection<Command> deleteCommands = new LinkedList<Command>();
     121                Collection<OsmPrimitive> del = new HashSet<OsmPrimitive>();
    123122                for (OsmPrimitive osm : selection) {
    124123                        CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    125124                        osm.visit(v);
    126125                        if (!selection.containsAll(v.data)) {
    127                                 if (msgBox)
     126                                if (msgBox) {
    128127                                        JOptionPane.showMessageDialog(Main.main, "This object is in use.");
    129                         } else
    130                                 deleteCommands.add(new DeleteCommand(osm));
     128                                        return;
     129                                }
     130                        } else {
     131                                del.addAll(v.data);
     132                                del.add(osm);
     133                        }
    131134                }
    132                 if (!deleteCommands.isEmpty())
    133                         mv.editLayer().add(new SequenceCommand(deleteCommands));
     135                if (!del.isEmpty())
     136                        mv.editLayer().add(new DeleteCommand(del));
    134137        }
    135138}
  • src/org/openstreetmap/josm/actions/mapmode/MapMode.java

    r93 r94  
    3939                this.mapFrame = mapFrame;
    4040                mv = mapFrame.mapView;
     41                putValue("active", false);
    4142        }
    4243
     
    5253        }
    5354
    54         /**
    55          * Register all listener to the mapView
    56          * @param mapView       The view, where the listener should be registered.
    57          */
    58         public void registerListener() {
     55        public void enterMode() {
    5956                putValue("active", true);
    6057        }
    61 
    62         /**
    63          * Unregister all listener previously registered.
    64          * @param mapView       The view from which the listener should be deregistered.
    65          */
    66         public void unregisterListener() {
     58        public void exitMode() {
    6759                putValue("active", false);
    6860        }
  • src/org/openstreetmap/josm/actions/mapmode/MoveAction.java

    r86 r94  
    55import java.awt.event.KeyEvent;
    66import java.awt.event.MouseEvent;
    7 import java.util.Arrays;
    87import java.util.Collection;
    98
     
    5251        }
    5352
    54         @Override public void registerListener() {
    55                 super.registerListener();
     53        @Override public void enterMode() {
     54                super.enterMode();
    5655                mv.addMouseListener(this);
    5756                mv.addMouseMotionListener(this);
    5857        }
    5958
    60         @Override public void unregisterListener() {
    61                 super.unregisterListener();
     59        @Override public void exitMode() {
     60                super.exitMode();
    6261                mv.removeMouseListener(this);
    6362                mv.removeMouseMotionListener(this);
     
    9695                }
    9796               
    98                 Command c = mv.editLayer().lastCommand();
     97                Command c = mv.editLayer().commands.getLast();
    9998                if (c instanceof MoveCommand && affectedNodes.equals(((MoveCommand)c).objects))
    10099                        ((MoveCommand)c).moveAgain(dx,dy);
     
    122121                        OsmPrimitive osm = mv.getNearest(e.getPoint(), (e.getModifiersEx() & MouseEvent.ALT_DOWN_MASK) != 0);
    123122                        if (osm != null)
    124                                 Main.ds.setSelected(Arrays.asList(new OsmPrimitive[]{osm}));
     123                                Main.ds.setSelected(osm);
    125124                        singleOsmPrimitive = osm;
    126125                        mv.repaint();
  • src/org/openstreetmap/josm/actions/mapmode/SelectionAction.java

    r86 r94  
    6868        }
    6969
    70         @Override public void registerListener() {
    71                 super.registerListener();
     70        @Override public void enterMode() {
     71                super.enterMode();
    7272                selectionManager.register(mv);
    7373        }
    7474
    75         @Override public void unregisterListener() {
    76                 super.unregisterListener();
     75        @Override public void exitMode() {
     76                super.exitMode();
    7777                selectionManager.unregister(mv);
    7878        }
  • src/org/openstreetmap/josm/actions/mapmode/ZoomAction.java

    r86 r94  
    5757        }
    5858
    59         @Override public void registerListener() {
    60                 super.registerListener();
     59        @Override public void enterMode() {
     60                super.enterMode();
    6161                selectionManager.register(mv);
    6262        }
    6363
    64         @Override public void unregisterListener() {
    65                 super.unregisterListener();
     64        @Override public void exitMode() {
     65                super.exitMode();
    6666                selectionManager.unregister(mv);
    6767        }
  • src/org/openstreetmap/josm/command/AddCommand.java

    r93 r94  
    22
    33import java.util.Collection;
     4
     5import javax.swing.JLabel;
     6import javax.swing.tree.DefaultMutableTreeNode;
     7import javax.swing.tree.MutableTreeNode;
    48
    59import org.openstreetmap.josm.Main;
     
    711import org.openstreetmap.josm.data.osm.visitor.AddVisitor;
    812import org.openstreetmap.josm.data.osm.visitor.DeleteVisitor;
     13import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
    914
    1015/**
     
    3944                added.add(osm);
    4045        }
     46
     47        @Override public MutableTreeNode description() {
     48                NameVisitor v = new NameVisitor();
     49                osm.visit(v);
     50                return new DefaultMutableTreeNode(new JLabel("Add "+v.className+" "+v.name, v.icon, JLabel.HORIZONTAL));
     51    }
    4152}
  • src/org/openstreetmap/josm/command/ChangeCommand.java

    r93 r94  
    33import java.util.Collection;
    44
     5import javax.swing.JLabel;
     6import javax.swing.tree.DefaultMutableTreeNode;
     7import javax.swing.tree.MutableTreeNode;
     8
    59import org.openstreetmap.josm.data.osm.OsmPrimitive;
     10import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
    611
    712public class ChangeCommand extends Command {
     
    1823            super.executeCommand();
    1924            osm.cloneFrom(newOsm);
     25            osm.modified = true;
    2026    }
    2127
     
    2329                modified.add(osm);
    2430    }
     31
     32        @Override public MutableTreeNode description() {
     33                NameVisitor v = new NameVisitor();
     34                osm.visit(v);
     35                return new DefaultMutableTreeNode(new JLabel("Change "+v.className+" "+v.name, v.icon, JLabel.HORIZONTAL));
     36    }
    2537}
  • src/org/openstreetmap/josm/command/ChangePropertyCommand.java

    r90 r94  
    55import java.util.List;
    66
     7import javax.swing.JLabel;
     8import javax.swing.tree.DefaultMutableTreeNode;
     9import javax.swing.tree.MutableTreeNode;
     10
    711import org.openstreetmap.josm.data.osm.OsmPrimitive;
     12import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
     13import org.openstreetmap.josm.tools.ImageProvider;
    814
    915/**
     
    5561        }
    5662
     63        @Override public MutableTreeNode description() {
     64                String text = value == null ? "Remove '"+key+"'" : "Set '"+key+"="+value+"'";
     65                text += " for ";
     66                if (objects.size() == 1) {
     67                        NameVisitor v = new NameVisitor();
     68                        objects.iterator().next().visit(v);
     69                        text += v.className+" "+v.name;
     70                } else
     71                        text += objects.size()+" objects";
     72                DefaultMutableTreeNode root = new DefaultMutableTreeNode(new JLabel(text, ImageProvider.get("data", "key"), JLabel.HORIZONTAL));
     73                if (objects.size() == 1)
     74                        return root;
     75                NameVisitor v = new NameVisitor();
     76                for (OsmPrimitive osm : objects) {
     77                        osm.visit(v);
     78                        root.add(new DefaultMutableTreeNode(v.toLabel()));
     79                }
     80                return root;
     81    }
    5782}
  • src/org/openstreetmap/josm/command/Command.java

    r86 r94  
    44import java.util.HashSet;
    55import java.util.Map.Entry;
     6
     7import javax.swing.tree.MutableTreeNode;
    68
    79import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    5860                        Collection<OsmPrimitive> deleted,
    5961                        Collection<OsmPrimitive> added);
     62
     63        abstract public MutableTreeNode description();
    6064}
  • src/org/openstreetmap/josm/command/ConflictResolveCommand.java

    r91 r94  
    99import java.util.Map.Entry;
    1010
     11import javax.swing.JLabel;
     12import javax.swing.tree.DefaultMutableTreeNode;
     13import javax.swing.tree.MutableTreeNode;
     14
    1115import org.openstreetmap.josm.Main;
    1216import org.openstreetmap.josm.data.conflict.ConflictItem;
     
    1418import org.openstreetmap.josm.gui.ConflictResolver;
    1519import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
     20import org.openstreetmap.josm.tools.ImageProvider;
    1621
    1722public class ConflictResolveCommand extends Command {
     
    6267                modified.addAll(resolved.keySet());
    6368        }
     69
     70        @Override public MutableTreeNode description() {
     71                int i = 0;
     72                for (ConflictItem c : conflicts)
     73                        if (c.resolution != null)
     74                                i++;
     75                return new DefaultMutableTreeNode(new JLabel("Resolve "+i+" conflicts in "+resolved.size()+" objects", ImageProvider.get("data", "primitive"), JLabel.HORIZONTAL));
     76    }
    6477}
  • src/org/openstreetmap/josm/command/DeleteCommand.java

    r86 r94  
    22
    33import java.util.Collection;
    4 import java.util.HashSet;
    54
    6 import org.openstreetmap.josm.Main;
     5import javax.swing.JLabel;
     6import javax.swing.tree.DefaultMutableTreeNode;
     7import javax.swing.tree.MutableTreeNode;
     8
    79import org.openstreetmap.josm.data.osm.OsmPrimitive;
    8 import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
     10import org.openstreetmap.josm.data.osm.visitor.NameVisitor;
     11import org.openstreetmap.josm.tools.ImageProvider;
    912
    1013/**
     
    1720         * The primitive that get deleted.
    1821         */
    19         final Collection<OsmPrimitive> data = new HashSet<OsmPrimitive>();
     22        private final Collection<OsmPrimitive> data;
    2023
    21         public DeleteCommand(OsmPrimitive osm) {
    22                 CollectBackReferencesVisitor v = new CollectBackReferencesVisitor(Main.ds);
    23                 osm.visit(v);
    24                 data.addAll(v.data);
    25                 data.add(osm);
     24        public DeleteCommand(Collection<OsmPrimitive> data) {
     25                this.data = data;
    2626        }
    27        
     27
    2828        @Override public void executeCommand() {
    2929                super.executeCommand();
     
    3535                deleted.addAll(data);
    3636        }
     37
     38        @Override public MutableTreeNode description() {
     39                NameVisitor v = new NameVisitor();
     40
     41                if (data.size() == 1) {
     42                        data.iterator().next().visit(v);
     43                        return new DefaultMutableTreeNode(new JLabel("Delete "+v.className+" "+v.name, v.icon, JLabel.HORIZONTAL));
     44                }
     45
     46                String cname = null;
     47                for (OsmPrimitive osm : data) {
     48                        osm.visit(v);
     49                        if (cname == null)
     50                                cname = v.className;
     51                        else if (!cname.equals(v.className))
     52                                cname = "primitive";
     53                }
     54                DefaultMutableTreeNode root = new DefaultMutableTreeNode(new JLabel("Delete "+data.size()+" "+cname+(data.size()==1?"":"s"), ImageProvider.get("data", cname), JLabel.HORIZONTAL));
     55                for (OsmPrimitive osm : data) {
     56                        osm.visit(v);
     57                        root.add(new DefaultMutableTreeNode(v.toLabel()));
     58                }
     59                return root;
     60        }
    3761}
  • src/org/openstreetmap/josm/command/MoveCommand.java

    r86 r94  
    66import java.util.List;
    77
     8import javax.swing.JLabel;
     9import javax.swing.tree.DefaultMutableTreeNode;
     10import javax.swing.tree.MutableTreeNode;
     11
    812import org.openstreetmap.josm.Main;
     13import org.openstreetmap.josm.data.coor.EastNorth;
    914import org.openstreetmap.josm.data.coor.LatLon;
    10 import org.openstreetmap.josm.data.coor.EastNorth;
    1115import org.openstreetmap.josm.data.osm.Node;
    1216import org.openstreetmap.josm.data.osm.OsmPrimitive;
    1317import org.openstreetmap.josm.data.osm.visitor.AllNodesVisitor;
     18import org.openstreetmap.josm.tools.ImageProvider;
    1419
    1520/**
     
    106111                        modified.add(osm);
    107112        }
     113
     114        @Override public MutableTreeNode description() {
     115                return new DefaultMutableTreeNode(new JLabel("Move "+objects.size()+" Node"+(objects.size()==1?"":"s"), ImageProvider.get("data", "node"), JLabel.HORIZONTAL));
     116    }
    108117}
  • src/org/openstreetmap/josm/command/SequenceCommand.java

    r86 r94  
    22
    33import java.util.Collection;
     4
     5import javax.swing.tree.DefaultMutableTreeNode;
     6import javax.swing.tree.MutableTreeNode;
    47
    58import org.openstreetmap.josm.data.osm.OsmPrimitive;
     
    1518         * The command sequenz to be executed.
    1619         */
    17         private Command[] sequenz;
     20        private Command[] sequence;
    1821
    1922        /**
     
    2225         */
    2326        public SequenceCommand(Collection<Command> sequenz) {
    24                 this.sequenz = new Command[sequenz.size()];
    25                 this.sequenz = sequenz.toArray(this.sequenz);
     27                this.sequence = new Command[sequenz.size()];
     28                this.sequence = sequenz.toArray(this.sequence);
    2629        }
    2730       
    2831        @Override public void executeCommand() {
    29                 for (Command c : sequenz)
     32                for (Command c : sequence)
    3033                        c.executeCommand();
    3134        }
    3235
    3336        @Override public void undoCommand() {
    34                 for (int i = sequenz.length-1; i >= 0; --i)
    35                         sequenz[i].undoCommand();
     37                for (int i = sequence.length-1; i >= 0; --i)
     38                        sequence[i].undoCommand();
    3639        }
    3740
    3841        @Override public void fillModifiedData(Collection<OsmPrimitive> modified, Collection<OsmPrimitive> deleted, Collection<OsmPrimitive> added) {
    39                 for (Command c : sequenz)
     42                for (Command c : sequence)
    4043                        c.fillModifiedData(modified, deleted, added);
    4144        }
    4245
     46        @Override public MutableTreeNode description() {
     47                DefaultMutableTreeNode root = new DefaultMutableTreeNode("Sequence");
     48                for (Command c : sequence)
     49                        root.add(c.description());
     50            return root;
     51    }
    4352}
  • src/org/openstreetmap/josm/data/SelectionChangedListener.java

    r8 r94  
    2222         * @param newSelection The new selection.
    2323         */
    24         public void selectionChanged(Collection<OsmPrimitive> newSelection);
     24        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection);
    2525}
  • src/org/openstreetmap/josm/data/osm/DataSet.java

    r91 r94  
    11package org.openstreetmap.josm.data.osm;
    22
     3import java.util.Arrays;
    34import java.util.Collection;
    45import java.util.Collections;
     
    9192        }
    9293
    93         public void setSelected(Collection<OsmPrimitive> selection) {
     94        public void setSelected(Collection<? extends OsmPrimitive> selection) {
    9495                clearSelection();
    9596                for (OsmPrimitive osm : selection)
    9697                        osm.selected = true;
    9798                fireSelectionChanged(selection);
     99        }
     100
     101        public void setSelected(OsmPrimitive osm) {
     102                clearSelection();
     103                if (osm == null)
     104                        return;
     105                osm.selected = true;
     106                fireSelectionChanged(Arrays.asList(new OsmPrimitive[]{osm}));
    98107        }
    99108       
     
    127136     * the event immediately. For more, @see SelectionChangedListener
    128137     */
    129     private void fireSelectionChanged(Collection<OsmPrimitive> sel) {
     138    public void fireSelectionChanged(Collection<? extends OsmPrimitive> sel) {
    130139                for (SelectionChangedListener l : listeners)
    131140                        l.selectionChanged(sel);
  • src/org/openstreetmap/josm/data/osm/Node.java

    r86 r94  
    4646                return osm instanceof Node ? super.realEqual(osm) && coor.equals(((Node)osm).coor) : false;
    4747    }
     48
     49        public int compareTo(OsmPrimitive o) {
     50            return o instanceof Node ? Long.valueOf(id).compareTo(o.id) : -1;
     51    }
    4852}
  • src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

    r90 r94  
    2323 * @author imi
    2424 */
    25 abstract public class OsmPrimitive {
     25abstract public class OsmPrimitive implements Comparable<OsmPrimitive> {
    2626
    2727        /**
  • src/org/openstreetmap/josm/data/osm/Segment.java

    r86 r94  
    8585                                to.equals(((Segment)osm).to) : false;
    8686        }
    87 }       
     87
     88        public int compareTo(OsmPrimitive o) {
     89                return o instanceof Segment ? Long.valueOf(id).compareTo(o.id) : (o instanceof Node ? 1 : -1);
     90        }
     91}
  • src/org/openstreetmap/josm/data/osm/Way.java

    r86 r94  
    4646                return osm instanceof Way ? super.realEqual(osm) && segments.equals(((Way)osm).segments) : false;
    4747    }
     48
     49        public int compareTo(OsmPrimitive o) {
     50            return o instanceof Way ? Long.valueOf(id).compareTo(o.id) : 1;
     51    }
    4852}
  • src/org/openstreetmap/josm/data/osm/visitor/NameVisitor.java

    r92 r94  
    66
    77import javax.swing.Icon;
     8import javax.swing.JLabel;
    89
    910import org.openstreetmap.josm.data.osm.Segment;
     
    8283                className = "way";
    8384        }
     85       
     86        public JLabel toLabel() {
     87                return new JLabel(name, icon, JLabel.HORIZONTAL);
     88        }
    8489}
  • src/org/openstreetmap/josm/gui/MapFrame.java

    r93 r94  
    2525import org.openstreetmap.josm.actions.mapmode.ZoomAction;
    2626import org.openstreetmap.josm.actions.mapmode.AddNodeAction.AddNodeGroup;
     27import org.openstreetmap.josm.gui.dialogs.CommandStackDialog;
    2728import org.openstreetmap.josm.gui.dialogs.ConflictDialog;
    2829import org.openstreetmap.josm.gui.dialogs.LayerList;
     
    8283                toolBarActions.add(new IconToggleButton(new AddNodeGroup(this)));
    8384                toolBarActions.add(new IconToggleButton(new AddSegmentAction(this)));
    84                 toolBarActions.add(new IconToggleButton(new AddWayAction(this, selectionAction)));
     85                toolBarActions.add(new IconToggleButton(new AddWayAction(this)));
    8586                toolBarActions.add(new IconToggleButton(new DeleteAction(this)));
    8687
     
    122123                addIconToggle(toggleDialogs, new SelectionListDialog(this));
    123124                addIconToggle(toggleDialogs, conflictDialog = new ConflictDialog());
     125                addIconToggle(toggleDialogs, new CommandStackDialog(this));
    124126
    125127                // status line below the map
     
    159161                        return;
    160162                if (this.mapMode != null)
    161                         this.mapMode.unregisterListener();
     163                        this.mapMode.exitMode();
    162164                this.mapMode = mapMode;
    163                 mapMode.registerListener();
     165                mapMode.enterMode();
    164166        }
    165167
  • src/org/openstreetmap/josm/gui/MapStatus.java

    r92 r94  
    1414import java.beans.PropertyChangeEvent;
    1515import java.beans.PropertyChangeListener;
    16 import java.util.Arrays;
    1716import java.util.Collection;
    1817import java.util.ConcurrentModificationException;
     
    155154                                                                }
    156155                                                                @Override public void mouseClicked(MouseEvent e) {
    157                                                                         Main.ds.setSelected(Arrays.asList(new OsmPrimitive[]{osm}));
     156                                                                        Main.ds.setSelected(osm);
    158157                                                                        mv.repaint();
    159158                                                                }
  • src/org/openstreetmap/josm/gui/MapView.java

    r93 r94  
    8585                // listend to selection changes to redraw the map
    8686                Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
    87                         public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     87                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    8888                                repaint();
    8989                        }
     
    106106                        dataLayer.data.addAllSelectionListener(Main.ds);
    107107                        Main.ds = dataLayer.data;
    108                         dataLayer.addModifiedListener(new ModifiedChangedListener(){
    109                                 public void modifiedChanged(boolean value, OsmDataLayer source) {
    110                                         Main.main.setTitle((value?"*":"")+"Java Open Street Map - Editor");
    111                                 }
    112                         });
     108                        dataLayer.listenerModified.add(new ModifiedChangedListener(){
     109                public void modifiedChanged(boolean value, OsmDataLayer source) {
     110                        Main.main.setTitle((value?"*":"")+"Java Open Street Map - Editor");
     111                }
     112            });
    113113                }
    114114
  • src/org/openstreetmap/josm/gui/OsmPrimitivRenderer.java

    r92 r94  
    44
    55import javax.swing.DefaultListCellRenderer;
    6 import javax.swing.JLabel;
    76import javax.swing.JList;
    87
     
    1918
    2019        @Override public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    21                 Component c = super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
    22                 if (c instanceof JLabel && value != null) {
     20                super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
     21                if (value != null) {
    2322                        ((OsmPrimitive)value).visit(visitor);
    24                         ((JLabel)c).setText(visitor.name);
    25                         ((JLabel)c).setIcon(visitor.icon);
     23                        setText(visitor.name);
     24                        setIcon(visitor.icon);
    2625                }
    27                 return c;
     26                return this;
    2827        }
    2928}
  • src/org/openstreetmap/josm/gui/SelectionManager.java

    r86 r94  
    273273                        // nodes
    274274                        for (Node n : Main.ds.nodes) {
    275                                 if (r.contains(nc.getPoint(n.eastNorth)))
     275                                if (!n.deleted && r.contains(nc.getPoint(n.eastNorth)))
    276276                                        selection.add(n);
    277277                        }
    278278                       
    279279                        // pending segments
    280                         for (Segment ls : Main.ds.segments)
    281                                 if (rectangleContainSegment(r, alt, ls))
    282                                         selection.add(ls);
     280                        for (Segment s : Main.ds.segments)
     281                                if (!s.deleted && rectangleContainSegment(r, alt, s))
     282                                        selection.add(s);
    283283
    284284                        // ways
    285                         for (Way t : Main.ds.ways) {
    286                                 boolean wholeWaySelected = !t.segments.isEmpty();
    287                                 for (Segment ls : t.segments)
    288                                         if (rectangleContainSegment(r, alt, ls))
    289                                                 selection.add(ls);
    290                                         else
     285                        for (Way w : Main.ds.ways) {
     286                                if (w.deleted)
     287                                        continue;
     288                                boolean wholeWaySelected = !w.segments.isEmpty();
     289                                for (Segment s : w.segments) {
     290                                        if (s.incomplete)
     291                                                continue;
     292                                        if (!rectangleContainSegment(r, alt, s)) {
    291293                                                wholeWaySelected = false;
     294                                                break;
     295                                        }
     296                                }
    292297                                if (wholeWaySelected)
    293                                         selection.add(t);
     298                                        selection.add(w);
    294299                        }
    295                        
    296                         // TODO areas
    297300                }
    298301                return selection;
  • src/org/openstreetmap/josm/gui/dialogs/ConflictDialog.java

    r90 r94  
    4848
    4949        public ConflictDialog() {
    50                 super("Conflict", "Conflict Dialog", "merge", "Merging conflicts.", "C", KeyEvent.VK_C, "conflict");
     50                super("Conflict", "conflict", "Merging conflicts.", KeyEvent.VK_C);
    5151                displaylist.setCellRenderer(new OsmPrimitivRenderer());
    5252                displaylist.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
     
    6060
    6161                JPanel buttonPanel = new JPanel(new GridLayout(1,2));
    62                 JButton button = new JButton("Resolve", ImageProvider.get("dialogs", "merge"));
     62                JButton button = new JButton("Resolve", ImageProvider.get("dialogs", "conflict"));
    6363                button.setToolTipText("Open a merge dialog of all selected items in the list above.");
    6464                button.addActionListener(new ActionListener(){
     
    8484
    8585                Main.ds.addSelectionChangedListener(new SelectionChangedListener(){
    86                         public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     86                        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    8787                                displaylist.clearSelection();
    8888                                for (OsmPrimitive osm : newSelection) {
  • src/org/openstreetmap/josm/gui/dialogs/LayerList.java

    r91 r94  
    123123         */
    124124        public LayerList(MapFrame mapFrame) {
    125                 super("Layers", "List of all layers", "layerlist", "Open a list of all loaded layers.", "L", KeyEvent.VK_L, "layerlist");
     125                super("Layers", "layerlist", "Open a list of all loaded layers.", KeyEvent.VK_L);
    126126                setPreferredSize(new Dimension(320,100));
    127127                add(new JScrollPane(layers), BorderLayout.CENTER);
  • src/org/openstreetmap/josm/gui/dialogs/PropertiesDialog.java

    r92 r94  
    210210         */
    211211        public PropertiesDialog(MapFrame mapFrame) {
    212                 super("Properties", "Properties Dialog", "properties", "Property for selected objects.", "P", KeyEvent.VK_P, "propertiesdialog");
     212                super("Properties", "propertiesdialog", "Property for selected objects.", KeyEvent.VK_P);
    213213                mv = mapFrame.mapView;
    214214
     
    284284        }
    285285
    286         public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     286        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
    287287                if (propertyTable == null)
    288288                        return; // selection changed may be received in base class constructor before init
  • src/org/openstreetmap/josm/gui/dialogs/SelectionListDialog.java

    r93 r94  
    1818import java.util.LinkedList;
    1919import java.util.Map;
     20import java.util.TreeSet;
    2021
    2122import javax.swing.ButtonGroup;
     
    116117         */
    117118        public SelectionListDialog(MapFrame mapFrame) {
    118                 super("Current Selection", "Selection List", "selectionlist", "Open a selection list window.", "E", KeyEvent.VK_E, "selectionlist");
     119                super("Current Selection", "selectionlist", "Open a selection list window.", KeyEvent.VK_E);
    119120                setPreferredSize(new Dimension(320,150));
    120121                displaylist.setCellRenderer(new OsmPrimitivRenderer());
     
    141142                buttonPanel.add(button);
    142143
     144                button = new JButton("Reload", ImageProvider.get("dialogs", "refresh"));
     145                button.setToolTipText("Refresh the selection list.");
     146                button.addActionListener(new ActionListener(){
     147                        public void actionPerformed(ActionEvent e) {
     148                                selectionChanged(Main.ds.getSelected());
     149                        }
     150                });
     151                buttonPanel.add(button);
     152               
    143153                button = new JButton("Search", ImageProvider.get("dialogs", "search"));
    144154                button.setToolTipText("Search for objects.");
     
    205215         * @param newSelection The new selection array.
    206216         */
    207         public void selectionChanged(Collection<OsmPrimitive> newSelection) {
     217        public void selectionChanged(Collection<? extends OsmPrimitive> newSelection) {
     218                TreeSet<OsmPrimitive> sortedSel = new TreeSet<OsmPrimitive>(newSelection);
    208219                if (list == null)
    209220                        return; // selection changed may be received in base class constructor before init
    210                 list.removeAllElements();
    211                 list.setSize(newSelection.size());
     221                list.setSize(sortedSel.size());
    212222                int i = 0;
    213                 for (OsmPrimitive osm : newSelection)
     223                for (OsmPrimitive osm : sortedSel)
    214224                        list.setElementAt(osm, i++);
    215225        }
  • src/org/openstreetmap/josm/gui/dialogs/ToggleDialog.java

    r90 r94  
    1313import org.openstreetmap.josm.Main;
    1414import org.openstreetmap.josm.actions.JosmAction;
     15import org.openstreetmap.josm.tools.ShortCutLabel;
    1516
    1617/**
     
    4445        public ToggleDialogAction action;
    4546
    46         /**
    47          * Create a new ToggleDialog.
    48          * @param title The title of the dialog.
    49      * @param prefName Name of the base preference setting string (prefix)
    50          */
    51         public ToggleDialog(String title, String name, String iconName, String tooltip, String shortCutName, int shortCut, final String prefName) {
    52                 action = new ToggleDialogAction(name, "dialogs/"+iconName, tooltip, "Alt-"+shortCutName, KeyStroke.getKeyStroke(shortCut, KeyEvent.ALT_MASK), prefName);
     47        public ToggleDialog(String name, String iconName, String tooltip, int shortCut) {
     48                action = new ToggleDialogAction(name, "dialogs/"+iconName, tooltip, ShortCutLabel.name(shortCut, KeyEvent.ALT_MASK), KeyStroke.getKeyStroke(shortCut, KeyEvent.ALT_MASK), iconName);
    5349                setLayout(new BorderLayout());
    54                 add(new JLabel(title), BorderLayout.NORTH);
     50                add(new JLabel(name), BorderLayout.NORTH);
    5551                setVisible(false);
    5652                setBorder(BorderFactory.createEtchedBorder());
  • src/org/openstreetmap/josm/gui/layer/OsmDataLayer.java

    r90 r94  
    2323import org.openstreetmap.josm.command.Command;
    2424import org.openstreetmap.josm.data.osm.DataSet;
    25 import org.openstreetmap.josm.data.osm.Segment;
    2625import org.openstreetmap.josm.data.osm.Node;
    2726import org.openstreetmap.josm.data.osm.OsmPrimitive;
     27import org.openstreetmap.josm.data.osm.Segment;
    2828import org.openstreetmap.josm.data.osm.Way;
    2929import org.openstreetmap.josm.data.osm.visitor.BoundingXYVisitor;
     
    7272                void modifiedChanged(boolean value, OsmDataLayer source);
    7373        }
     74        public interface CommandQueueListener {
     75                void commandChanged();
     76        }
    7477
    7578        private static Icon icon;
     
    9497        private boolean fromDisk = false;
    9598        /**
    96          * All commands that were made on the dataset.
    97          */
    98         private LinkedList<Command> commands = new LinkedList<Command>();
     99         * All commands that were made on the dataset. Don't write from outside!
     100         */
     101        public final LinkedList<Command> commands = new LinkedList<Command>();
    99102        /**
    100103         * The stack for redoing commands
     
    102105        private Stack<Command> redoCommands = new Stack<Command>();
    103106
    104         /**
    105          * List of all listeners for changes of modified flag.
    106          */
    107         LinkedList<ModifiedChangedListener> listener;
     107        public final LinkedList<ModifiedChangedListener> listenerModified = new LinkedList<ModifiedChangedListener>();
     108        public final LinkedList<CommandQueueListener> listenerCommands = new LinkedList<CommandQueueListener>();
    108109
    109110
     
    175176        @Override public void visitBoundingBox(BoundingXYVisitor v) {
    176177                for (Node n : data.nodes)
    177                         v.visit(n);
    178         }
    179 
    180         /**
    181          * @return the last command added or <code>null</code> if no command in queue.
    182          */
    183         public Command lastCommand() {
    184                 return commands.isEmpty() ? null : commands.getLast();
     178                        if (!n.deleted)
     179                                v.visit(n);
    185180        }
    186181
     
    197192                Main.main.redoAction.setEnabled(false);
    198193                setModified(true);
     194                for (CommandQueueListener l : listenerCommands)
     195                        l.commandChanged();
    199196        }
    200197
     
    213210                if (commands.isEmpty())
    214211                        setModified(uploadedModified);
     212                Main.ds.clearSelection();
     213                for (CommandQueueListener l : listenerCommands)
     214                        l.commandChanged();
    215215        }
    216216        /**
     
    227227                Main.main.redoAction.setEnabled(!redoCommands.isEmpty());
    228228                setModified(true);
     229                for (CommandQueueListener l : listenerCommands)
     230                        l.commandChanged();
    229231        }
    230232
     
    234236         * after a successfull upload.
    235237         *
    236          * @param uploaded <code>true</code>, if the data was uploaded, false if saved to disk
    237238         * @param processed A list of all objects, that were actually uploaded.
    238239         *              May be <code>null</code>, which means nothing has been uploaded but
     
    292293                        return;
    293294                this.modified = modified;
    294                 if (listener != null)
    295                         for (ModifiedChangedListener l : listener)
    296                                 l.modifiedChanged(modified, this);
    297         }
    298 
    299         /**
    300          * Add the parameter to the intern list of listener for modified state.
    301          * @param l Listener to add to the list. Must not be null.
    302          */
    303         public void addModifiedListener(ModifiedChangedListener l) {
    304                 if (listener == null)
    305                         listener = new LinkedList<ModifiedChangedListener>();
    306                 listener.add(l);
     295                for (ModifiedChangedListener l : listenerModified)
     296                        l.modifiedChanged(modified, this);
    307297        }
    308298
     
    328318                        if (counter.deleted[i] > 0)
    329319                                s += " ("+counter.deleted[i]+" deleted)";
    330                         p.add(new JLabel(s, ImageProvider.get("data", counter.names[i]), JLabel.HORIZONTAL), GBC.eol().insets(15,0,0,0));
     320                        p.add(new JLabel(s, ImageProvider.get("data", counter.names[i]), JLabel.HORIZONTAL), GBC.eop().insets(15,0,0,0));
    331321                }
    332322                return p;
Note: See TracChangeset for help on using the changeset viewer.